@imfusion/web-ui 0.5.0

package/dist/components/card/card.d.ts

@@ -0,0 +1,64 @@
+import { VariantProps } from 'class-variance-authority';
+declare const root: (props?: ({
+    density?: "compact" | "comfortable" | "spacious" | null | undefined;
+    variant?: "primary" | "main" | "support" | "minor" | "brand" | null | undefined;
+    shadow?: "sm" | "md" | "lg" | "none" | null | undefined;
+    radius?: "sm" | "md" | "lg" | "brand" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type RootProps = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof root> & {
+    /** Draws the hairline border. Applies to the neutral variants only — coloured variants are always borderless. */
+    /** @default true */
+    withBorder?: boolean;
+};
+/**
+ * Card.Root — a surface container composed of slots: an optional `Card.Image`
+ * (bleeds edge-to-edge, no padding), then `Card.Header` / `Card.Content` /
+ * `Card.Footer`. `density` sets one scale that drives both each slot's padding
+ * and the gap between slots. `variant` picks the look — neutral tonal surfaces
+ * (`main`/`support`/`minor`) carry a hairline border; coloured intent fills
+ * (`primary`/`brand`) flip to contrast text and drop the border. `shadow` and
+ * `radius` layer on top. Also called a panel, tile, or paper.
+ *
+ * The image is always the first entry in the stack, so `orientation` just
+ * switches the stack between a column and a row without reordering slots.
+ *
+ * The ImFusion brand ships flat (`shadow="none"`), but the shadow scale is a
+ * first-class opt-in axis for third-party consumers. `shadow` picks the elevation
+ * level only — how hard or spread that shadow reads is a global lighting decision,
+ * owned by the `--imf-ui-shadow-hardness` / `--imf-ui-shadow-spread` tokens.
+ */
+declare function Root({ density, variant, shadow, radius, orientation, withBorder, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Root {
+    var displayName: string;
+}
+type ImageProps = React.ImgHTMLAttributes<HTMLImageElement>;
+/**
+ * Card.Image — an edge-to-edge media slot. Has no padding, so the image bleeds
+ * to the card edges. Always place it first among the slots.
+ */
+declare function Image({ className, alt, ...props }: ImageProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Image {
+    var displayName: string;
+}
+type SlotProps = React.HTMLAttributes<HTMLDivElement>;
+/** Card.Header — the padded title region at the top of the card body. */
+declare function Header({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Header {
+    var displayName: string;
+}
+/** Card.Content — the padded main body of the card. */
+declare function Content({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Content {
+    var displayName: string;
+}
+/**
+ * Card.Footer — the padded action region at the bottom. Its background inherits
+ * the card fill by default; override `background` in `style` for a distinct
+ * action bar.
+ */
+declare function Footer({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Footer {
+    var displayName: string;
+}
+export { Root, Image, Header, Content, Footer };

package/dist/components/card/card.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const cardMeta: ComponentMeta;

package/dist/components/card/index.d.ts

@@ -0,0 +1,2 @@
+export * as Card from './card';
+export { cardMeta } from './card.meta';

package/dist/components/checkbox/checkbox.d.ts

@@ -0,0 +1,56 @@
+import { Checkbox as CheckboxPrimitive } from '@base-ui/react/checkbox';
+type UpstreamRoot = React.ComponentProps<typeof CheckboxPrimitive.Root>;
+type UpstreamIndicator = React.ComponentProps<typeof CheckboxPrimitive.Indicator>;
+type RootProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    /** @default false */
+    defaultChecked?: boolean;
+    checked?: boolean;
+    onCheckedChange?: UpstreamRoot["onCheckedChange"];
+    /** @default false */
+    indeterminate?: boolean;
+    /** @default false */
+    disabled?: boolean;
+    /** @default false */
+    readOnly?: boolean;
+    /** @default false */
+    required?: boolean;
+    /** @default false */
+    nativeButton?: boolean;
+    /** @default false */
+    parent?: boolean;
+    name?: string;
+    value?: string;
+    uncheckedValue?: string;
+    form?: string;
+    inputRef?: React.Ref<HTMLInputElement>;
+    className?: UpstreamRoot["className"];
+    style?: UpstreamRoot["style"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * Checkbox.Root — binary form control; renders a `<span>` plus a hidden `<input>`.
+ *
+ * @doc https://base-ui.com/react/components/checkbox
+ * @llm https://base-ui.com/react/components/checkbox.md
+ */
+export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type IndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    /** @default false */
+    keepMounted?: boolean;
+    className?: UpstreamIndicator["className"];
+    style?: UpstreamIndicator["style"];
+    render?: UpstreamIndicator["render"];
+};
+/**
+ * Checkbox.Indicator — shows the checked / indeterminate mark. Ships brand
+ * icons by default (check, and a minus while `indeterminate`); pass children
+ * to replace them.
+ */
+export declare function Indicator({ className, children, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Indicator {
+    var displayName: string;
+}
+export {};

package/dist/components/checkbox/checkbox.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const checkboxMeta: ComponentMeta;

package/dist/components/checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export * as Checkbox from './checkbox';
+export { checkboxMeta } from './checkbox.meta';

package/dist/components/chip/chip.cva.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared variants for `Chip` and any sibling primitive that renders the same
+ * Chip visual on a different element (`ChipLink` renders `<a>`; a future
+ * `ChipButton` would render `<button>`). Keeping them in their own module
+ * means variant axes stay aligned without cross-component imports of a
+ * component file.
+ */
+export declare const chip: (props?: ({
+    variant?: "primary" | "positive" | "negative" | "main" | "support" | "minor" | "brand" | "warning" | "info" | "accent-1" | "accent-2" | "accent-3" | null | undefined;
+    appearance?: "outline" | "solid" | "subtle" | null | undefined;
+    inline?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/chip/chip.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { chip } from './chip.cva';
+type Props = React.HTMLAttributes<HTMLSpanElement> & VariantProps<typeof chip> & {
+    children: React.ReactNode;
+};
+/**
+ * Chip — compact inline label for status or category.
+ * Not based on any upstream component.
+ */
+export declare function Chip({ variant, appearance, inline, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chip/chip.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const chipMeta: ComponentMeta;

package/dist/components/chip/index.d.ts

@@ -0,0 +1,2 @@
+export { Chip } from './chip';
+export { chipMeta } from './chip.meta';

package/dist/components/chip-link/chip-link.d.ts

@@ -0,0 +1,17 @@
+import { chip } from '../chip/chip.cva';
+import { VariantProps } from 'class-variance-authority';
+export type ChipLinkKind = "external" | "internal";
+type Props = React.AnchorHTMLAttributes<HTMLAnchorElement> & VariantProps<typeof chip> & {
+    href: string;
+    /** Link target scope. `"external"` (default) opens in a new tab with a diagonal `ArrowUpRight` icon; `"internal"` stays in the current tab with a horizontal `ArrowRight` icon. */
+    kind?: ChipLinkKind;
+    className?: string;
+    children: React.ReactNode;
+};
+/**
+ * ChipLink — anchor styled as a Chip. Reuses Chip's shared variants so the
+ * variant and appearance axes stay aligned, and auto-appends a directional icon
+ * (Lucide `ArrowUpRight` for external, `ArrowRight` for internal).
+ */
+export declare function ChipLink({ variant, appearance, inline, kind, className, children, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chip-link/chip-link.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const chipLinkMeta: ComponentMeta;

package/dist/components/chip-link/index.d.ts

@@ -0,0 +1,2 @@
+export { ChipLink } from './chip-link';
+export { chipLinkMeta } from './chip-link.meta';

package/dist/components/code/code.d.ts

@@ -0,0 +1,60 @@
+type InlineProps = Omit<React.HTMLAttributes<HTMLElement>, "children"> & {
+    /** The inline code, as a raw string — also the value copied when `copyable`. */
+    children: string;
+    /** Show a small copy button on the right, behind a hairline separator. @default false */
+    copyable?: boolean;
+    /** Pre-rendered display content (e.g. syntax-highlighted tokens) shown in place of `children`, which stays the copied value. The code-highlight integration fills this slot. */
+    highlighted?: React.ReactNode;
+};
+/**
+ * Code.Inline — an inline code fragment (a `<code>` chip) for use inside running
+ * text. Dumb: styling only — syntax coloring arrives pre-rendered through the
+ * `highlighted` slot (the code-highlight integration supplies it). `Typo.InlineCode`
+ * renders this under the hood so inline-code chrome is defined in one place.
+ * Children must be a string so an opted-in copy button has clean text to copy.
+ */
+export declare function Inline({ className, copyable, highlighted, children, ...props }: InlineProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Inline {
+    var displayName: string;
+}
+export type CodeInlineLinkKind = "external" | "internal";
+type InlineLinkProps = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & {
+    /** The link text, as a raw string, rendered as a code fragment. */
+    children: string;
+    /** Link target scope. `"external"` (default) opens in a new tab with a diagonal `ArrowUpRight` icon; `"internal"` stays in the current tab with a horizontal `ArrowRight` icon. */
+    kind?: CodeInlineLinkKind;
+};
+/**
+ * Code.InlineLink — the inline-code chip rendered as a link: the same hairline
+ * box, with a directional arrow behind the separator instead of a copy button.
+ * Sibling of `Code.Inline`, sharing its chip visual (`.inline`) — never both a
+ * copy button and a link on the same chip. Mirrors `ChipLink`'s shape (anchor
+ * is the chip root, trailing icon nudges on hover, `data-kind` picks the icon).
+ */
+export declare function InlineLink({ className, kind, children, ...props }: InlineLinkProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace InlineLink {
+    var displayName: string;
+}
+type BlockProps = Omit<React.HTMLAttributes<HTMLPreElement>, "children"> & {
+    /** The code to display, as a raw string — also the value copied by the copy button. */
+    children: string;
+    /** Language label shown in the corner notch. Omit to hide the notch. */
+    language?: string;
+    /** Hide the copy button. @default false */
+    hideCopy?: boolean;
+    /** Pre-rendered display content (e.g. syntax-highlighted tokens) shown in place of `children`, which stays the copied value. The code-highlight integration fills this slot. */
+    highlighted?: React.ReactNode;
+};
+/**
+ * Code.Block — a fenced code block on a flat brand surface, with an optional
+ * chamfered language notch (top-left) and a copy button (top-right). The
+ * surface follows the global corner-radius token when a preset opts in.
+ * Dumb: styling only — syntax coloring arrives pre-rendered through the
+ * `highlighted` slot (the code-highlight integration supplies it). Children
+ * must be a string so the copy button has clean text to copy.
+ */
+export declare function Block({ className, language, hideCopy, highlighted, children, ...props }: BlockProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Block {
+    var displayName: string;
+}
+export {};

package/dist/components/code/code.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const codeMeta: ComponentMeta;

package/dist/components/code/index.d.ts

@@ -0,0 +1,2 @@
+export * as Code from './code';
+export { codeMeta } from './code.meta';

package/dist/components/collapsible/collapsible.d.ts

@@ -0,0 +1,57 @@
+import { Collapsible as CollapsiblePrimitive } from '@base-ui/react/collapsible';
+import { VariantProps } from 'class-variance-authority';
+type UpstreamRoot = React.ComponentProps<typeof CollapsiblePrimitive.Root>;
+type UpstreamTrigger = React.ComponentProps<typeof CollapsiblePrimitive.Trigger>;
+type UpstreamPanel = React.ComponentProps<typeof CollapsiblePrimitive.Panel>;
+declare const collapsibleRoot: (props?: ({
+    variant?: "solid" | "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & VariantProps<typeof collapsibleRoot> & {
+    /** Visual treatment applied to the trigger. `solid` gives the trigger a contained surface background; `default` is transparent at rest and drenched-blue when open. */
+    /** @default false */
+    defaultOpen?: UpstreamRoot["defaultOpen"];
+    open?: UpstreamRoot["open"];
+    onOpenChange?: UpstreamRoot["onOpenChange"];
+    /** @default false */
+    disabled?: UpstreamRoot["disabled"];
+    className?: UpstreamRoot["className"];
+    style?: UpstreamRoot["style"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * Collapsible.Root — container that manages open/closed state for a trigger–panel pair.
+ *
+ * @see https://base-ui.com/react/components/collapsible
+ * @llm https://base-ui.com/react/components/collapsible.md
+ */
+export declare function Root({ variant, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & {
+    /** @default true */
+    nativeButton?: UpstreamTrigger["nativeButton"];
+    className?: UpstreamTrigger["className"];
+    style?: UpstreamTrigger["style"];
+    render?: UpstreamTrigger["render"];
+};
+/** Collapsible.Trigger — button that toggles the panel open and closed. */
+export declare function Trigger({ className, children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+type PanelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    /** @default false */
+    hiddenUntilFound?: UpstreamPanel["hiddenUntilFound"];
+    /** @default false */
+    keepMounted?: UpstreamPanel["keepMounted"];
+    className?: UpstreamPanel["className"];
+    style?: UpstreamPanel["style"];
+    render?: UpstreamPanel["render"];
+};
+/** Collapsible.Panel — region that expands and collapses when the trigger is activated. */
+export declare function Panel({ className, ...props }: PanelProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Panel {
+    var displayName: string;
+}
+export {};

package/dist/components/collapsible/collapsible.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const collapsibleMeta: ComponentMeta;

package/dist/components/collapsible/index.d.ts

@@ -0,0 +1,2 @@
+export * as Collapsible from './collapsible';
+export { collapsibleMeta } from './collapsible.meta';

package/dist/components/copy-button/copy-button.d.ts

@@ -0,0 +1,21 @@
+import { Button } from '../button';
+type Props = Omit<React.ComponentProps<typeof Button>, "children" | "onClick"> & {
+    /** Text written to the clipboard when the button is pressed. */
+    value: string;
+    /** Accessible label in the idle state. @default "Copy" */
+    label?: string;
+    /** Accessible label shown briefly after a successful copy. @default "Copied" */
+    copiedLabel?: string;
+    /** Variant to use for the button. @default "secondary" */
+    variant?: React.ComponentProps<typeof Button>["variant"];
+};
+/**
+ * CopyButton — a Button that copies `value` to the clipboard and shows a
+ * transient confirmation (Copy → Check). Composes Button rather than rendering
+ * its own element, so all Button variants and native attributes pass through.
+ */
+export declare function CopyButton({ value, label, copiedLabel, variant, size, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace CopyButton {
+    var displayName: string;
+}
+export {};

package/dist/components/copy-button/copy-button.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const copyButtonMeta: ComponentMeta;

package/dist/components/copy-button/index.d.ts

@@ -0,0 +1,2 @@
+export { CopyButton } from './copy-button';
+export { copyButtonMeta } from './copy-button.meta';

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

@@ -0,0 +1,191 @@
+import { Drawer as DrawerPrimitive } from '@base-ui/react/drawer';
+type BorderColor = "primary" | "fg-minor" | "fg-support" | "none";
+type BorderStyle = "solid" | "dashed" | "none";
+type UpstreamRoot = React.ComponentProps<typeof DrawerPrimitive.Root>;
+type UpstreamTrigger = React.ComponentProps<typeof DrawerPrimitive.Trigger>;
+type UpstreamPortal = React.ComponentProps<typeof DrawerPrimitive.Portal>;
+type UpstreamBackdrop = React.ComponentProps<typeof DrawerPrimitive.Backdrop>;
+type UpstreamViewport = React.ComponentProps<typeof DrawerPrimitive.Viewport>;
+type UpstreamPopup = React.ComponentProps<typeof DrawerPrimitive.Popup>;
+type UpstreamContent = React.ComponentProps<typeof DrawerPrimitive.Content>;
+type UpstreamTitle = React.ComponentProps<typeof DrawerPrimitive.Title>;
+type UpstreamDescription = React.ComponentProps<typeof DrawerPrimitive.Description>;
+type UpstreamClose = React.ComponentProps<typeof DrawerPrimitive.Close>;
+type UpstreamIndent = React.ComponentProps<typeof DrawerPrimitive.Indent>;
+type UpstreamIndentBackground = React.ComponentProps<typeof DrawerPrimitive.IndentBackground>;
+type UpstreamSwipeArea = React.ComponentProps<typeof DrawerPrimitive.SwipeArea>;
+type RootProps = {
+    open?: UpstreamRoot["open"];
+    /** @default false */
+    defaultOpen?: UpstreamRoot["defaultOpen"];
+    onOpenChange?: UpstreamRoot["onOpenChange"];
+    onOpenChangeComplete?: UpstreamRoot["onOpenChangeComplete"];
+    /** @default true */
+    modal?: UpstreamRoot["modal"];
+    /** @default 'down' */
+    swipeDirection?: UpstreamRoot["swipeDirection"];
+    snapPoints?: UpstreamRoot["snapPoints"];
+    snapPoint?: UpstreamRoot["snapPoint"];
+    onSnapPointChange?: UpstreamRoot["onSnapPointChange"];
+    /** @default false */
+    disablePointerDismissal?: UpstreamRoot["disablePointerDismissal"];
+    /** @default false */
+    snapToSequentialPoints?: UpstreamRoot["snapToSequentialPoints"];
+    /**
+     * Colour of the border on the panel's open edge. Inherited by Drawer.Popup;
+     * a Popup-level prop overrides it.
+     * @default 'primary'
+     */
+    borderColor?: BorderColor;
+    /**
+     * Stroke style of the border on the panel's open edge. Inherited by
+     * Drawer.Popup; a Popup-level prop overrides it.
+     * @default 'solid'
+     */
+    borderStyle?: BorderStyle;
+    children?: UpstreamRoot["children"];
+};
+/**
+ * Drawer.Root — container that manages open/closed state and gesture interaction.
+ *
+ * @see https://base-ui.com/react/components/drawer
+ * @llm https://base-ui.com/react/components/drawer.md
+ */
+export declare function Root({ borderColor, borderStyle, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /** @default true */
+    nativeButton?: UpstreamTrigger["nativeButton"];
+    className?: UpstreamTrigger["className"];
+    render?: UpstreamTrigger["render"];
+};
+/** Drawer.Trigger — button that opens the drawer. */
+export declare function Trigger({ className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+type PortalProps = {
+    container?: UpstreamPortal["container"];
+    children?: UpstreamPortal["children"];
+};
+/** Drawer.Portal — renders backdrop and popup in a portal outside the main document flow. */
+export declare function Portal(props: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Portal {
+    var displayName: string;
+}
+type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamBackdrop["className"];
+    render?: UpstreamBackdrop["render"];
+};
+/** Drawer.Backdrop — semi-transparent overlay that dims the page content behind the drawer. */
+export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Backdrop {
+    var displayName: string;
+}
+type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamViewport["className"];
+    render?: UpstreamViewport["render"];
+};
+/** Drawer.Viewport — full-screen container that positions the popup. */
+export declare function Viewport({ className, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Viewport {
+    var displayName: string;
+}
+type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /**
+     * Colour of the border on the open edge. Overrides the value inherited from
+     * Drawer.Root; defaults to it when unset.
+     */
+    borderColor?: BorderColor;
+    /**
+     * Stroke style of the border on the open edge. Overrides the value inherited
+     * from Drawer.Root; defaults to it when unset.
+     */
+    borderStyle?: BorderStyle;
+    initialFocus?: UpstreamPopup["initialFocus"];
+    finalFocus?: UpstreamPopup["finalFocus"];
+    className?: UpstreamPopup["className"];
+    render?: UpstreamPopup["render"];
+};
+/** Drawer.Popup — the visible panel surface. Positioning is driven automatically by the nearest Drawer.Root's swipeDirection. */
+export declare function Popup({ borderColor, borderStyle, className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Popup {
+    var displayName: string;
+}
+type ContentProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamContent["className"];
+    render?: UpstreamContent["render"];
+};
+/** Drawer.Content — scrollable content wrapper inside the popup. */
+export declare function Content({ className, ...props }: ContentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Content {
+    var displayName: string;
+}
+type TitleProps = React.HTMLAttributes<HTMLHeadingElement> & {
+    render?: UpstreamTitle["render"];
+};
+/** Drawer.Title — semantic heading for the drawer for screen readers. */
+export declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Title {
+    var displayName: string;
+}
+type CloseProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /** @default true */
+    nativeButton?: UpstreamClose["nativeButton"];
+    className?: UpstreamClose["className"];
+    render?: UpstreamClose["render"];
+};
+/** Drawer.Close — button that closes the drawer. */
+export declare function Close({ className, ...props }: CloseProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Close {
+    var displayName: string;
+}
+type DescriptionProps = React.HTMLAttributes<HTMLParagraphElement> & {
+    render?: UpstreamDescription["render"];
+};
+/** Drawer.Description — supplementary paragraph describing the drawer's purpose for screen readers. */
+export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Description {
+    var displayName: string;
+}
+type ProviderProps = {
+    children?: React.ReactNode;
+};
+/** Drawer.Provider — shared context for coordinating indent/background effects across multiple drawers. Required ancestor for Drawer.Indent and Drawer.IndentBackground. */
+export declare function Provider(props: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Provider {
+    var displayName: string;
+}
+type IndentProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamIndent["className"];
+    render?: UpstreamIndent["render"];
+};
+/** Drawer.Indent — wraps app content that scales and lifts when a drawer opens. Receives `data-active` from Base UI; use `--drawer-swipe-progress` in CSS to drive the animation. */
+export declare function Indent({ className, ...props }: IndentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Indent {
+    var displayName: string;
+}
+type IndentBackgroundProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamIndentBackground["className"];
+    render?: UpstreamIndentBackground["render"];
+};
+/** Drawer.IndentBackground — background layer placed behind Drawer.Indent. Styled to reveal a dark surface as the app content scales away. */
+export declare function IndentBackground({ className, ...props }: IndentBackgroundProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace IndentBackground {
+    var displayName: string;
+}
+type SwipeAreaProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** @default false */
+    disabled?: UpstreamSwipeArea["disabled"];
+    swipeDirection?: UpstreamSwipeArea["swipeDirection"];
+    className?: UpstreamSwipeArea["className"];
+    render?: UpstreamSwipeArea["render"];
+};
+/** Drawer.SwipeArea — invisible fixed region that listens for swipe gestures to open the drawer. Position and size it at the screen edge relevant to the swipeDirection. */
+export declare function SwipeArea({ className, ...props }: SwipeAreaProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SwipeArea {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const drawerMeta: ComponentMeta;

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

@@ -0,0 +1,2 @@
+export * as Drawer from './drawer';
+export { drawerMeta } from './drawer.meta';

package/dist/components/input/index.d.ts

@@ -0,0 +1,2 @@
+export { Input } from './input';
+export { inputMeta } from './input.meta';

package/dist/components/input/input.d.ts

@@ -0,0 +1,25 @@
+import { Input as InputPrimitive } from '@base-ui/react/input';
+import { VariantProps } from 'class-variance-authority';
+declare const input: (props?: ({
+    variant?: "outline" | "ghost" | "filled" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type UpstreamInput = React.ComponentProps<typeof InputPrimitive>;
+type Props = Omit<React.InputHTMLAttributes<HTMLInputElement>, "className" | "style" | "size"> & VariantProps<typeof input> & {
+    value?: UpstreamInput["value"];
+    defaultValue?: UpstreamInput["defaultValue"];
+    onValueChange?: UpstreamInput["onValueChange"];
+    className?: UpstreamInput["className"];
+    style?: UpstreamInput["style"];
+    render?: UpstreamInput["render"];
+};
+/**
+ * Single-line text input. Also called a text field or input field.
+ * Wraps Base UI Input for controlled/uncontrolled state, form integration,
+ * and Field context awareness (valid/invalid/dirty/touched/filled/focused).
+ *
+ * @see https://base-ui.com/react/components/input
+ * @llm https://base-ui.com/react/components/input.md
+ */
+export declare function Input({ variant, size, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/input/input.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const inputMeta: ComponentMeta;

package/dist/components/logo/imfusion/imfusion.d.ts

@@ -0,0 +1,16 @@
+import { Logo } from '../logo';
+type Props = Omit<React.ComponentProps<typeof Logo>, "src" | "alt"> & {
+    /** Render the compact glyph instead of the full wordmark. */
+    glyph?: boolean;
+    /** Override the accessible label. Defaults to "ImFusion". */
+    alt?: string;
+};
+/**
+ * ImFusion's own logo — the generic {@link Logo} primitive pre-wired with the
+ * ImFusion marks and the brand variant. The single branded entry point and the
+ * only export from this module; external consumers compose `<Logo src={…} />`
+ * with their own asset. Pass `glyph` for the compact mark; the default is the
+ * full wordmark.
+ */
+export declare function ImFusionLogo({ glyph, alt, variant, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/logo/imfusion/index.d.ts

@@ -0,0 +1 @@
+export { ImFusionLogo } from './imfusion';

package/dist/components/logo/index.d.ts

@@ -0,0 +1,3 @@
+export { Logo } from './logo';
+export { logoMeta } from './logo.meta';
+export { ImFusionLogo } from './imfusion';

package/dist/components/logo/logo.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const logo: (props?: ({
+    size?: "sm" | "md" | "lg" | "hero" | "xs" | "xl" | "fit" | null | undefined;
+    variant?: "main" | "inherit" | "support" | "minor" | "brand" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & VariantProps<typeof logo> & {
+    /** Logo source — an image URL or an inline SVG node. Required; this primitive carries no brand default (see `ImFusionLogo` for our own mark). */
+    src: string | ReactNode;
+    alt: string;
+    /** Explicit height — overrides `size` variant when set. */
+    height?: string | number;
+};
+export declare function Logo({ src, alt, size, variant, height, className, style, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};