@imfusion/web-ui 0.5.0

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

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

package/dist/components/navigation-menu/index.d.ts

@@ -0,0 +1,2 @@
+export * as NavigationMenu from './navigation-menu';
+export { navigationMenuMeta } from './navigation-menu.meta';

package/dist/components/navigation-menu/navigation-menu.d.ts

@@ -0,0 +1,20 @@
+/**
+ * NavigationMenu — a strip of triggers that open a shared, flat flyout Popup for
+ * site/app wayfinding. Adapted from Base UI's navigation-menu.
+ *
+ * This is a large compound component, so its parts are split into `subs/` — one
+ * `.tsx` + `.module.css` per part-group — and re-exported here as the single
+ * `NavigationMenu` namespace. Cross-part styling goes through CSS custom
+ * properties declared on the Root (see `subs/navigation-menu-root.module.css`),
+ * never cross-file descendant selectors (which can't resolve under per-file class
+ * scoping). See `docs/component-definition.md` for the pattern.
+ *
+ * @see https://base-ui.com/react/components/navigation-menu
+ * @llm https://base-ui.com/react/components/navigation-menu.md
+ */
+export { Root, List, Item, Content, Viewport } from './subs/structure';
+export { Trigger, Icon } from './subs/trigger';
+export { Portal, Positioner, Popup, Arrow, Backdrop } from './subs/overlay';
+export { Link, LinkList, LinkCard } from './subs/link';
+export { FlyoutLink } from './subs/flyout-link';
+export { InlineSubmenu, type InlineSubmenuItem } from './subs/inline-submenu';

package/dist/components/navigation-menu/navigation-menu.meta.d.ts

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

package/dist/components/navigation-menu/subs/flyout-link.d.ts

@@ -0,0 +1,24 @@
+import { UpstreamLink } from './shared';
+type FlyoutLinkProps = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className"> & {
+    /**
+     * Marks the link as the current page — renders it in full primary colour.
+     * @default false
+     */
+    active?: UpstreamLink["active"];
+    /** @default false */
+    closeOnClick?: UpstreamLink["closeOnClick"];
+    className?: UpstreamLink["className"];
+    render?: UpstreamLink["render"];
+};
+/**
+ * NavigationMenu.FlyoutLink — a quiet text link inside a flyout `Content`, the
+ * lightweight alternative to a `LinkCard` when a card is too heavy. Renders an
+ * `<a>`. A trailing `ArrowRight` slides in on hover/focus and the label nudges to
+ * meet it; the current page is marked in primary. When a custom `render` is
+ * supplied the icon is omitted — the consumer's element owns its content.
+ */
+export declare function FlyoutLink({ className, children, render, ...props }: FlyoutLinkProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace FlyoutLink {
+    var displayName: string;
+}
+export {};

package/dist/components/navigation-menu/subs/inline-submenu.d.ts

@@ -0,0 +1,41 @@
+/** One category in an `InlineSubmenu` — a rail entry plus its detail pane. */
+export type InlineSubmenuItem = {
+    /** Stable identifier for this category (the nested menu value). */
+    value: string;
+    /** Rail label. */
+    label: React.ReactNode;
+    /** Short line under the rail label. */
+    hint?: React.ReactNode;
+    /** Detail-pane heading. */
+    title: React.ReactNode;
+    /** Detail-pane supporting paragraph. */
+    description?: React.ReactNode;
+    /** Detail-pane links. */
+    links: readonly {
+        href: string;
+        title: React.ReactNode;
+        description?: React.ReactNode;
+    }[];
+};
+type InlineSubmenuProps = {
+    /** The categories: each is a rail entry with its detail pane. */
+    items: readonly InlineSubmenuItem[];
+    /** Which category is open initially (uncontrolled). */
+    defaultValue?: string;
+};
+/**
+ * NavigationMenu.InlineSubmenu — a master/detail submenu that stays inside one
+ * flyout: a category rail beside (or, on narrow viewports, above) its detail.
+ *
+ * A curated partial over the namespace's own primitives (a nested vertical
+ * `Root` without a `Portal`, plus the rail/detail layout). Drop it directly
+ * inside a `NavigationMenu.Content`. It bakes in Base UI's viewport
+ * responsiveness: the nested Root flips `orientation` at `md` via `useMediaQuery`
+ * and the CSS flips the rail from a horizontal tab strip to a side rail at the
+ * same breakpoint — no work for the consumer, no container queries.
+ */
+export declare function InlineSubmenu({ items, defaultValue }: InlineSubmenuProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace InlineSubmenu {
+    var displayName: string;
+}
+export {};

package/dist/components/navigation-menu/subs/link.d.ts

@@ -0,0 +1,64 @@
+import { UpstreamLink } from './shared';
+type LinkProps = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className"> & {
+    /**
+     * Marks the link as the current page — renders it in full primary colour.
+     * @default false
+     */
+    active?: UpstreamLink["active"];
+    /** @default false */
+    closeOnClick?: UpstreamLink["closeOnClick"];
+    className?: UpstreamLink["className"];
+    render?: UpstreamLink["render"];
+};
+/**
+ * NavigationMenu.Link — a top-strip (rail) link: a peer of `Trigger` for a
+ * section that navigates directly instead of opening a flyout. Renders an `<a>`.
+ * For a link inside a flyout, use `NavigationMenu.FlyoutLink`.
+ *
+ * A trailing `ArrowRight` slides in on hover/focus. When a custom `render` is
+ * supplied the icon is omitted — the consumer's element owns its content.
+ */
+export declare function Link({ className, children, render, ...props }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Link {
+    var displayName: string;
+}
+type LinkListProps = React.HTMLAttributes<HTMLUListElement>;
+/**
+ * NavigationMenu.LinkList — a reset `<ul>` that lays out a flyout's `LinkCard`s
+ * (a responsive two-column grid that collapses to one column on narrow flyouts).
+ * Owns the flyout list layout so consumers wrap each card in an `<li>` and add no
+ * layout styling of their own. Renders a `<ul>`.
+ */
+export declare function LinkList({ className, ...props }: LinkListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace LinkList {
+    var displayName: string;
+}
+type LinkCardProps = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "className" | "title"> & {
+    /** Card heading — the link label. */
+    title: React.ReactNode;
+    /** Supporting line beneath the title. */
+    description?: React.ReactNode;
+    /** Optional media — renders an edge-to-edge image above the text. */
+    image?: string;
+    /** Alt text for `image`. */
+    imageAlt?: string;
+    /** Marks the card as the current page. @default false */
+    active?: UpstreamLink["active"];
+    /** @default false */
+    closeOnClick?: UpstreamLink["closeOnClick"];
+    className?: UpstreamLink["className"];
+    render?: UpstreamLink["render"];
+};
+/**
+ * NavigationMenu.LinkCard — a rich flyout entry (optional image + title +
+ * description) for the bigger menus. Built on the `Card` primitive (like
+ * `ChipLink` is built on `Chip`): it composes `Card.Root`/`Image`/`Header`/
+ * `Content` for the surface and layout, and adds the nav-specific state — a
+ * thick primary bar along the card's bottom edge on hover and when active. Use
+ * where a plain `NavigationMenu.FlyoutLink` is too sparse.
+ */
+export declare function LinkCard({ title, description, image, imageAlt, className, ...props }: LinkCardProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace LinkCard {
+    var displayName: string;
+}
+export {};

package/dist/components/navigation-menu/subs/overlay.d.ts

@@ -0,0 +1,75 @@
+import { UpstreamArrow, UpstreamBackdrop, UpstreamPopup, UpstreamPortal, UpstreamPositioner } from './shared';
+type PortalProps = {
+    container?: UpstreamPortal["container"];
+    /** @default false */
+    keepMounted?: UpstreamPortal["keepMounted"];
+    children?: UpstreamPortal["children"];
+};
+/** NavigationMenu.Portal — renders the positioner 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 PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** @default 'bottom' */
+    side?: UpstreamPositioner["side"];
+    /** @default 'start' */
+    align?: UpstreamPositioner["align"];
+    /** @default 0 */
+    sideOffset?: UpstreamPositioner["sideOffset"];
+    /** @default 0 */
+    alignOffset?: UpstreamPositioner["alignOffset"];
+    /** @default 5 */
+    arrowPadding?: UpstreamPositioner["arrowPadding"];
+    anchor?: UpstreamPositioner["anchor"];
+    /** @default 'absolute' */
+    positionMethod?: UpstreamPositioner["positionMethod"];
+    /** @default false */
+    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
+    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
+    /** @default 'clipping-ancestors' */
+    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
+    /** @default 5 */
+    collisionPadding?: UpstreamPositioner["collisionPadding"];
+    /** @default false */
+    sticky?: UpstreamPositioner["sticky"];
+    className?: UpstreamPositioner["className"];
+    render?: UpstreamPositioner["render"];
+};
+/**
+ * NavigationMenu.Positioner — anchors the popup to the active trigger.
+ * Defaults to `align="start"` (DESIGN.md §5) so the flyout reads as anchored to
+ * the trigger edge rather than centered. Renders a `<div>`.
+ */
+export declare function Positioner({ align, className, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Positioner {
+    var displayName: string;
+}
+type PopupProps = Omit<React.HTMLAttributes<HTMLElement>, "className"> & {
+    className?: UpstreamPopup["className"];
+    render?: UpstreamPopup["render"];
+};
+/** NavigationMenu.Popup — the shared flyout surface holding the active Content. Renders a `<nav>`. */
+export declare function Popup({ className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Popup {
+    var displayName: string;
+}
+type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamArrow["className"];
+    render?: UpstreamArrow["render"];
+};
+/** NavigationMenu.Arrow — a pointer anchored to the popup edge. Receives data-side for orientation. Renders a `<div>`. */
+export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Arrow {
+    var displayName: string;
+}
+type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamBackdrop["className"];
+    render?: UpstreamBackdrop["render"];
+};
+/** NavigationMenu.Backdrop — overlay beneath the popup. Receives data-open/data-closed for transitions. Renders a `<div>`. */
+export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Backdrop {
+    var displayName: string;
+}
+export {};

package/dist/components/navigation-menu/subs/shared.d.ts

@@ -0,0 +1,20 @@
+import { NavigationMenu as NavigationMenuPrimitive } from '@base-ui/react/navigation-menu';
+/**
+ * Shared upstream type aliases for the NavigationMenu sub-parts. Each sub-part
+ * file lives beside its own `.module.css`; these Base UI prop types are the one
+ * thing they all reference, so they live here rather than being restated.
+ */
+export type UpstreamRoot = React.ComponentProps<typeof NavigationMenuPrimitive.Root>;
+export type UpstreamList = React.ComponentProps<typeof NavigationMenuPrimitive.List>;
+export type UpstreamItem = React.ComponentProps<typeof NavigationMenuPrimitive.Item>;
+export type UpstreamTrigger = React.ComponentProps<typeof NavigationMenuPrimitive.Trigger>;
+export type UpstreamIcon = React.ComponentProps<typeof NavigationMenuPrimitive.Icon>;
+export type UpstreamContent = React.ComponentProps<typeof NavigationMenuPrimitive.Content>;
+export type UpstreamLink = React.ComponentProps<typeof NavigationMenuPrimitive.Link>;
+export type UpstreamPortal = React.ComponentProps<typeof NavigationMenuPrimitive.Portal>;
+export type UpstreamPositioner = React.ComponentProps<typeof NavigationMenuPrimitive.Positioner>;
+export type UpstreamPopup = React.ComponentProps<typeof NavigationMenuPrimitive.Popup>;
+export type UpstreamViewport = React.ComponentProps<typeof NavigationMenuPrimitive.Viewport>;
+export type UpstreamArrow = React.ComponentProps<typeof NavigationMenuPrimitive.Arrow>;
+export type UpstreamBackdrop = React.ComponentProps<typeof NavigationMenuPrimitive.Backdrop>;
+export type Orientation = "horizontal" | "vertical";

package/dist/components/navigation-menu/subs/structure.d.ts

@@ -0,0 +1,64 @@
+import { NavigationMenu as NavigationMenuPrimitive } from '@base-ui/react/navigation-menu';
+import { Orientation, UpstreamContent, UpstreamItem, UpstreamList, UpstreamRoot, UpstreamViewport } from './shared';
+type RootProps<Value = unknown> = Omit<React.ComponentProps<typeof NavigationMenuPrimitive.Root<Value>>, "className" | "orientation"> & {
+    /**
+     * Layout of the menu. `horizontal` is a top nav bar; `vertical` stacks the
+     * whole menu into a side rail with flyouts opening to the side.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation;
+    className?: UpstreamRoot["className"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * NavigationMenu.Root — groups all parts and manages which item is open.
+ * Renders a `<nav>`.
+ *
+ * @see https://base-ui.com/react/components/navigation-menu
+ * @llm https://base-ui.com/react/components/navigation-menu.md
+ */
+export declare function Root<Value = unknown>({ orientation, className, ...props }: RootProps<Value>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type ListProps = Omit<React.HTMLAttributes<HTMLUListElement>, "className"> & {
+    className?: UpstreamList["className"];
+    render?: UpstreamList["render"];
+};
+/** NavigationMenu.List — the strip of items. Renders a `<ul>`. */
+export declare function List({ className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace List {
+    var displayName: string;
+}
+type ItemProps = Omit<React.LiHTMLAttributes<HTMLLIElement>, "className"> & {
+    /** Unique identifier for controlled use; auto-generated when omitted. */
+    value?: UpstreamItem["value"];
+    className?: UpstreamItem["className"];
+    render?: UpstreamItem["render"];
+};
+/** NavigationMenu.Item — a single item in the list. Renders a `<li>`. */
+export declare function Item({ className, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Item {
+    var displayName: string;
+}
+type ContentProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** @default false */
+    keepMounted?: UpstreamContent["keepMounted"];
+    className?: UpstreamContent["className"];
+    render?: UpstreamContent["render"];
+};
+/** NavigationMenu.Content — an item's flyout body; moved into the shared Popup when active. Renders a `<div>`. */
+export declare function Content({ className, ...props }: ContentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Content {
+    var displayName: string;
+}
+type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamViewport["className"];
+    render?: UpstreamViewport["render"];
+};
+/** NavigationMenu.Viewport — clips the current content for direction-aware transitions. Renders a `<div>`. */
+export declare function Viewport({ className, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Viewport {
+    var displayName: string;
+}
+export {};

package/dist/components/navigation-menu/subs/trigger.d.ts

@@ -0,0 +1,47 @@
+import { UpstreamIcon, UpstreamTrigger } from './shared';
+type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /**
+     * Marks this section as the current page so it shows the active treatment even
+     * when its flyout is closed — the "active trail" anchor for a nav where the
+     * open section isn't the current one. Base UI's Trigger has no active state of
+     * its own, so this stamps `data-active`.
+     * @default false
+     */
+    active?: boolean;
+    /**
+     * Suppresses the built-in chevron. Use when supplying a custom `Icon` (e.g. a
+     * `ChevronRight` for a side-opening nested trigger).
+     * @default false
+     */
+    hideChevron?: boolean;
+    /**
+     * Marks a trigger that lives inside a flyout (a nested submenu opener) so it
+     * sizes to its label instead of filling the row like a top-strip trigger.
+     * @default false
+     */
+    nested?: boolean;
+    /** @default true */
+    nativeButton?: UpstreamTrigger["nativeButton"];
+    className?: UpstreamTrigger["className"];
+    render?: UpstreamTrigger["render"];
+};
+/**
+ * NavigationMenu.Trigger — opens an item's flyout on hover or click. Renders a
+ * `<button>`. Ships a built-in `ChevronDown` (rotates when open) so consumers
+ * don't hand-author an indicator; pass `hideChevron` to supply a custom `Icon`,
+ * and `nested` when the trigger opens a submenu from inside another flyout.
+ */
+export declare function Trigger({ active, hideChevron, nested, children, className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+type IconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className"> & {
+    className?: UpstreamIcon["className"];
+    render?: UpstreamIcon["render"];
+};
+/** NavigationMenu.Icon — a chevron/marker that rotates when its trigger is open. Renders a `<span>`. */
+export declare function Icon({ className, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Icon {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export * as Popover from './popover';
+export { popoverMeta } from './popover.meta';

package/dist/components/popover/popover.d.ts

@@ -0,0 +1,181 @@
+import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
+type UpstreamTrigger = React.ComponentProps<typeof PopoverPrimitive.Trigger>;
+type UpstreamPortal = React.ComponentProps<typeof PopoverPrimitive.Portal>;
+type UpstreamBackdrop = React.ComponentProps<typeof PopoverPrimitive.Backdrop>;
+type UpstreamPositioner = React.ComponentProps<typeof PopoverPrimitive.Positioner>;
+type UpstreamPopup = React.ComponentProps<typeof PopoverPrimitive.Popup>;
+type UpstreamArrow = React.ComponentProps<typeof PopoverPrimitive.Arrow>;
+type UpstreamViewport = React.ComponentProps<typeof PopoverPrimitive.Viewport>;
+type UpstreamTitle = React.ComponentProps<typeof PopoverPrimitive.Title>;
+type UpstreamDescription = React.ComponentProps<typeof PopoverPrimitive.Description>;
+type UpstreamClose = React.ComponentProps<typeof PopoverPrimitive.Close>;
+export declare const createHandle: typeof PopoverPrimitive.createHandle;
+type RootProps<Payload = unknown> = React.ComponentProps<typeof PopoverPrimitive.Root<Payload>>;
+/**
+ * Popover.Root — container that manages open/closed state and positioning context.
+ *
+ * @see https://base-ui.com/react/components/popover
+ * @llm https://base-ui.com/react/components/popover.md
+ */
+export declare function Root<Payload = unknown>(props: RootProps<Payload>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    variant?: "ghost" | "outline" | "primary" | "secondary" | "positive" | "negative";
+    inline?: boolean;
+    /** @default true */
+    nativeButton?: UpstreamTrigger["nativeButton"];
+    /** @default false */
+    openOnHover?: UpstreamTrigger["openOnHover"];
+    /** @default 300 */
+    delay?: UpstreamTrigger["delay"];
+    /** @default 0 */
+    closeDelay?: UpstreamTrigger["closeDelay"];
+    handle?: UpstreamTrigger["handle"];
+    payload?: UpstreamTrigger["payload"];
+    className?: UpstreamTrigger["className"];
+    render?: UpstreamTrigger["render"];
+};
+/** Popover.Trigger — button that opens the popover. */
+export declare function Trigger({ variant, inline, className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+type PortalProps = {
+    container?: UpstreamPortal["container"];
+    /** @default false */
+    keepMounted?: UpstreamPortal["keepMounted"];
+    children?: UpstreamPortal["children"];
+};
+/** Popover.Portal — renders the positioner 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"];
+};
+/** Popover.Backdrop — overlay beneath the popover. Receives data-open/data-closed for transitions. */
+export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Backdrop {
+    var displayName: string;
+}
+type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** @default 'bottom' */
+    side?: UpstreamPositioner["side"];
+    /** @default 'center' */
+    align?: UpstreamPositioner["align"];
+    /** @default 0 */
+    sideOffset?: UpstreamPositioner["sideOffset"];
+    /** @default 0 */
+    alignOffset?: UpstreamPositioner["alignOffset"];
+    /** @default 5 */
+    arrowPadding?: UpstreamPositioner["arrowPadding"];
+    anchor?: UpstreamPositioner["anchor"];
+    /** @default false */
+    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
+    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
+    /** @default 'clipping-ancestors' */
+    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
+    /** @default 5 */
+    collisionPadding?: UpstreamPositioner["collisionPadding"];
+    /** @default false */
+    sticky?: UpstreamPositioner["sticky"];
+    className?: UpstreamPositioner["className"];
+    render?: UpstreamPositioner["render"];
+};
+/** Popover.Positioner — positions the popup relative to the trigger via floating-point layout. */
+export declare function Positioner({ className, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Positioner {
+    var displayName: string;
+}
+type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    /** Match to the Trigger variant to tint the popup border accordingly. */
+    variant?: "ghost" | "outline" | "primary" | "secondary" | "positive" | "negative";
+    className?: UpstreamPopup["className"];
+    render?: UpstreamPopup["render"];
+};
+/** Popover.Popup — the visible surface of the popover. Token-mapped background, border, and shadow. */
+export declare function Popup({ className, variant, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Popup {
+    var displayName: string;
+}
+type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamArrow["className"];
+    render?: UpstreamArrow["render"];
+};
+/** Popover.Arrow — visual pointer arrow anchored to the popup edge. Receives data-side for orientation. */
+export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Arrow {
+    var displayName: string;
+}
+type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    className?: UpstreamViewport["className"];
+    render?: UpstreamViewport["render"];
+};
+/** Popover.Viewport — content wrapper that supports direction-aware animations. */
+export declare function Viewport({ className, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Viewport {
+    var displayName: string;
+}
+type EyebrowProps = React.HTMLAttributes<HTMLParagraphElement>;
+/** Popover.Eyebrow — small uppercase label above Title, for a category or kicker (e.g. "Glossary definition"). */
+export declare function Eyebrow({ className, ...props }: EyebrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Eyebrow {
+    var displayName: string;
+}
+type TitleProps = React.HTMLAttributes<HTMLHeadingElement> & {
+    render?: UpstreamTitle["render"];
+};
+/** Popover.Title — semantic heading for the popover's accessible name. */
+export declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Title {
+    var displayName: string;
+}
+type DescriptionProps = React.HTMLAttributes<HTMLParagraphElement> & {
+    render?: UpstreamDescription["render"];
+};
+/** Popover.Description — supplementary paragraph for the popover's accessible description. */
+export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Description {
+    var displayName: string;
+}
+type CloseProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
+    /** @default true */
+    nativeButton?: UpstreamClose["nativeButton"];
+    className?: UpstreamClose["className"];
+    render?: UpstreamClose["render"];
+};
+/** Popover.Close — button that dismisses the popover. */
+export declare function Close({ className, ...props }: CloseProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Close {
+    var displayName: string;
+}
+type InlineProps = {
+    /** The annotated text rendered as the trigger. */
+    trigger: React.ReactNode;
+    /** Optional heading shown at the top of the popup. */
+    title?: React.ReactNode;
+    /** Description or body content inside the popup. */
+    children?: React.ReactNode;
+    /** Hover delay in ms before the popover opens. @default 150 */
+    delay?: number;
+    /** Which side of the trigger the popup appears on. @default 'top' */
+    side?: UpstreamPositioner["side"];
+    /** Gap between trigger and popup in px. @default 6 */
+    sideOffset?: number;
+};
+/**
+ * Popover.Inline — pre-composed inline annotation. Wraps the full
+ * Root → Trigger(inline, openOnHover) → Portal → Positioner → Popup
+ * pattern into a single component for annotating terms in running prose.
+ *
+ * @see https://base-ui.com/react/components/popover
+ */
+export declare function Inline({ trigger, title, children, delay, side, sideOffset }: InlineProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Inline {
+    var displayName: string;
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export { Row } from './row';
+export { rowMeta } from './row.meta';

package/dist/components/row/row.d.ts

@@ -0,0 +1,28 @@
+import { VariantProps } from 'class-variance-authority';
+declare const row: (props?: ({
+    gap?: "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | null | undefined;
+    align?: "center" | "end" | "start" | "stretch" | null | undefined;
+    justify?: "center" | "end" | "start" | "between" | "around" | "evenly" | null | undefined;
+    wrap?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof row> & {
+    /**
+     * Cross-axis alignment. Sets both `align-items` (item alignment within a
+     * row) and `align-content` (row distribution when `wrap` is on). `"stretch"`
+     * keeps rows packed together via `align-content: flex-start` while items
+     * fill their row height.
+     * @default "stretch"
+     */
+    align?: "start" | "center" | "end" | "stretch";
+};
+/**
+ * Row — horizontal layout primitive.
+ *
+ * Copied and adapted from Mantine's Group; no upstream runtime
+ * dependency. Pure row flex container with token-driven gap and constrained
+ * align/justify unions.
+ *
+ * @see https://mantine.dev/core/group/
+ */
+export declare function Row({ gap, align, justify, wrap, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * as Select from './select';
+export { selectMeta } from './select.meta';