@republicroad/seal-appshell 1.1.0

package/dist/components/reui/cascader/cascader.d.ts

@@ -0,0 +1,325 @@
+import { Combobox as ComboboxPrimitive } from '@base-ui/react';
+import { useRender } from '@base-ui/react/use-render';
+import { CascaderGetChildren, CascaderOnSearch, CascaderResolveValue } from '../../../components/reui/cascader/cascader-async';
+import { createCascaderHighlightStore, useCascaderActions, useCascaderHighlight, useCascaderRender, useCascaderState, CascaderActionsContextValue, CascaderColumn, CascaderHighlight, CascaderHighlightStore, CascaderItemState, CascaderRenderContextValue, CascaderStateContextValue } from '../../../components/reui/cascader/cascader-context';
+import { CascaderCheckedStrategy } from '../../../components/reui/cascader/cascader-lib';
+import { CascaderActionItem, CascaderChangeDetails, CascaderLabels, CascaderMode, CascaderNode, CascaderSearchScope, CascaderSelectable } from '../../../components/reui/cascader/cascader-types';
+import * as React from 'react';
+/** The pre-split shape, merged, so `useCascader()` returns what it always did. */
+export interface CascaderContextValue<T = unknown> extends CascaderActionsContextValue<T>, CascaderStateContextValue<T> {
+}
+/**
+ * The cascader's internals, typed for the caller's own item payload.
+ * @deprecated Reads BOTH halves, so a caller re-renders on every keystroke.
+ * Prefer `useCascaderActions()` or `useCascaderState()`. Kept for compat.
+ */
+export declare function useCascader<T = unknown>(): CascaderContextValue<T>;
+export interface CascaderSelection<T = unknown> {
+    /** The selected nodes, resolved. Empty when nothing is selected. */
+    selected: CascaderNode<T>[];
+    /** Ancestor chain per selected node, root first, node last. */
+    paths: CascaderNode<T>[][];
+    /** The single selection, or the first one in `multiple` mode. */
+    first: CascaderNode<T> | null;
+    /** Ancestor chain of `first`. */
+    firstPath: CascaderNode<T>[];
+    count: number;
+    isEmpty: boolean;
+    multiple: boolean;
+    remove: (value: string) => void;
+    clear: () => void;
+}
+/** Headless access to the selection, for a trigger that is not
+ * `CascaderValue`. Pass the payload explicitly to get `node.data` typed. */
+export declare function useCascaderSelection<T = unknown>(): CascaderSelection<T>;
+/**
+ * Why the navigation path changed.
+ * - `"drill"`: a branch was entered (row press, level arrow, deep-search hit).
+ * - `"back"`: one level up (back control, Backspace on an empty query).
+ * - `"breadcrumb"`: a jump to an exact depth in the trail.
+ * - `"reveal"`: the reopen navigated to the level holding the selection.
+ * - `"external"`: `setPath` called from outside the primitive's own flows.
+ */
+export type CascaderPathChangeReason = 'drill' | 'back' | 'breadcrumb' | 'reveal' | 'external';
+/** Everything independent of the selection mode; the rest is on the two arms. */
+export interface CascaderBaseProps<T = unknown> {
+    /** Nested tree, or a flat list when `getParent` is supplied. */
+    items: CascaderNode<T>[];
+    /** Opt in to flat adjacency input by returning each node's parent value. */
+    getParent?: (node: CascaderNode<T>) => string | null | undefined;
+    /**
+     * Fetches one level on demand; `node` is `null` for the root. Return an
+     * array, or a `CascaderLoadResult` when the level pages. Pages cache apart
+     * from `items`; mark unfetched branches `hasChildren` or they read as leaves.
+     */
+    getChildren?: CascaderGetChildren<T>;
+    /**
+     * Server-side search, debounced by `searchDebounce`; replaces the local scan
+     * while the query is set. Results are detached: resolvable by value, in no
+     * level. Ignored in `mode="tree"`, where a hit belongs to no visible branch.
+     */
+    onSearch?: CascaderOnSearch<T>;
+    /** Milliseconds of quiet before `onSearch` fires. */
+    searchDebounce?: number;
+    /**
+     * Resolves a value the loader has never seen into its ancestor chain, root
+     * first, so the trigger can path a server-supplied selection. Does NOT mark
+     * those levels loaded: opening one still fetches.
+     */
+    resolveValue?: CascaderResolveValue<T>;
+    /** Cache key. Changing it drops every page and aborts anything in flight. */
+    loadKey?: unknown;
+    /** Prefetch a highlighted branch's children after a pause. Off by default. */
+    prefetch?: boolean;
+    /**
+     * Called when a load fails. `context.parent` is the level (`null` for root);
+     * `context.reason` is `"level"`, `"more"`, `"retry"`, `"prefetch"`,
+     * `"search"` or `"resolve"`. Never for an aborted or superseded request.
+     */
+    onLoadError?: (error: unknown, context: {
+        parent: string | null;
+        reason: string;
+    }) => void;
+    /** Which nodes may be committed. Defaults to leaves only. */
+    selectable?: CascaderSelectable<T>;
+    /**
+     * Whether the built-in SINGLE-SELECT check is drawn. Defaults to true.
+     * `false` also gives back the inline-end gutter every style reserves for it;
+     * `data-selected` and `aria-selected` stay. A no-op under `multiple`, where
+     * the checkbox is the selection CONTROL rather than a decoration.
+     */
+    indicator?: boolean;
+    /**
+     * Footer ACTIONS: commands pinned below the list, never rows in it, and never
+     * touching the data tree. A childless `<CascaderFooter />` draws these; an
+     * action with `items` opens a side-anchored flyout rather than firing.
+     */
+    actions?: CascaderActionItem[];
+    /**
+     * Parent/child cascading. Multi-select only, off by default, and it needs
+     * committable branches (`selectable="any"` or a predicate). A commit selects
+     * or deselects every SELECTABLE node in the LOADED subtree and reconciles
+     * ancestors. LOADED is the semantic, not a hedge: a commit must not fan out
+     * into a request per level, so children arriving later arrive unchecked.
+     */
+    cascade?: boolean;
+    mode?: CascaderMode;
+    /** How a branch opens from the pointer in columns mode's ACTIVE column.
+     * `"click"` is the default, and neither value ever commits a selection. */
+    expandTrigger?: 'click' | 'hover';
+    path?: string[];
+    defaultPath?: string[];
+    /** The second argument says WHY. An existing `(path) => void` still works. */
+    onPathChange?: (path: string[], details: {
+        reason: CascaderPathChangeReason;
+    }) => void;
+    expanded?: string[];
+    defaultExpanded?: string[];
+    onExpandedChange?: (expanded: string[]) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Forwards Base UI's reason; a leaf commit's close says `"item-press"`. */
+    onOpenChange?: (open: boolean, details: {
+        reason: string;
+    }) => void;
+    /**
+     * Whether a SINGLE-SELECT leaf commit closes the popup. Defaults to true.
+     * `false` is for a compare-and-repick flow; Escape, outside press and the
+     * trigger still close. Ignored under `multiple`, which never closes.
+     */
+    closeOnSelect?: boolean;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (value: string) => void;
+    searchScope?: CascaderSearchScope;
+    /** Custom matcher, replacing label + keywords substring matching. */
+    filter?: (node: CascaderNode<T>, normalizedQuery: string) => boolean;
+    /** On open, navigate to the level holding the selection. Default true. */
+    revealSelected?: boolean;
+    maxHeight?: number | string;
+    /**
+     * Window the rendered rows. `undefined` decides per level from
+     * `virtualizeThreshold`; `true`/`false` force it. Also opt-in at the markup
+     * level, so the base install pulls in no virtualization library.
+     */
+    virtualize?: boolean;
+    /** Row count at which windowing turns itself on. */
+    virtualizeThreshold?: number;
+    /** Row height handed to the virtualizer before a row has been measured. */
+    estimateRowSize?: number;
+    /** Rows rendered beyond each edge of the viewport. */
+    overscan?: number;
+    labels?: Partial<CascaderLabels>;
+    /** Replaces the entire row, affordances included. */
+    renderItem?: (node: CascaderNode<T>, state: CascaderItemState<T>) => React.ReactNode;
+    /** Replaces only the label block; icon, count, chevron and check stay. */
+    renderLabel?: (node: CascaderNode<T>, state: CascaderItemState<T>) => React.ReactNode;
+    disabled?: boolean;
+    /** Native form field name. Submits the selected value(s). */
+    name?: string;
+    /** Id of the owning form, for a cascader rendered outside it. */
+    form?: string;
+    /** Id of the control. Pairs the field with a `<label htmlFor>`. */
+    id?: string;
+    /** Marks the field required for native form validation. */
+    required?: boolean;
+    /** The value can be read and submitted, but not changed. */
+    readOnly?: boolean;
+    /** Marks the field invalid: `aria-invalid` and `data-invalid` on the trigger,
+     * the chips and the input, which every style's error treatment reads. */
+    invalid?: boolean;
+    /** Ref to the hidden input Base UI submits with, for form-library focus. */
+    inputRef?: React.Ref<HTMLInputElement>;
+    /** Renders without a floating popup, for an embedded `CascaderPanel`. */
+    inline?: boolean;
+    children?: React.ReactNode;
+}
+export interface CascaderSingleProps<T = unknown> extends CascaderBaseProps<T> {
+    multiple?: false;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, details: CascaderChangeDetails<T>) => void;
+    /** `never` so passing it is a compile error, not a silent no-op. */
+    max?: never;
+}
+/** Multi-select props. Enables checkbox rows and chip display. */
+export interface CascaderMultipleProps<T = unknown> extends CascaderBaseProps<T> {
+    multiple: true;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[], details: CascaderChangeDetails<T>) => void;
+    /** Cap on selections. Further picks are refused, the existing ones survive. */
+    max?: number;
+}
+/** `multiple` discriminates: `value`, `onValueChange` and `max` narrow with it. */
+export type CascaderProps<T = unknown> = CascaderSingleProps<T> | CascaderMultipleProps<T>;
+/** No default on `T`: inferred from `items`, so `node.data` arrives typed. */
+declare function Cascader<T>({ items, getParent, getChildren, onSearch, searchDebounce, resolveValue, loadKey, prefetch, onLoadError, value: valueProp, defaultValue, onValueChange: onValueChangeProp, multiple, selectable, indicator, actions, cascade, max, mode, expandTrigger, path: pathProp, defaultPath, onPathChange, expanded: expandedProp, defaultExpanded, onExpandedChange, open: openProp, defaultOpen, onOpenChange, closeOnSelect, inputValue: inputValueProp, defaultInputValue, onInputValueChange, searchScope, filter, revealSelected, maxHeight, virtualize, virtualizeThreshold, estimateRowSize, overscan, labels: labelsProp, renderItem, renderLabel, disabled, name, form, id, required, readOnly, invalid, inputRef, inline, children, }: CascaderProps<T>): React.JSX.Element;
+/** `Trigger.Props` stops short of `ref`, so it is intersected in, as the
+ * shadcn combobox wrapper also does: a form library needs a ref here, and
+ * `onBlur`, the "touched" signal, lands here too. */
+export interface CascaderTriggerProps extends ComboboxPrimitive.Trigger.Props, Pick<React.ComponentPropsWithRef<'button'>, 'ref'> {
+    /** Hides the trailing chevron, for a trigger that supplies its own. */
+    showIcon?: boolean;
+}
+declare function CascaderTrigger({ className, children, showIcon, ref, ...props }: CascaderTriggerProps): React.JSX.Element;
+/** Ref for the chips container: they replace the trigger, so the popup has to
+ * be anchored to them. Hand it to `CascaderContent`'s `anchor`. */
+export declare function useCascaderAnchor(): React.MutableRefObject<HTMLDivElement | null>;
+export interface CascaderChipsProps extends Omit<ComboboxPrimitive.Chips.Props, 'children'>, Pick<React.ComponentPropsWithRef<'div'>, 'ref'> {
+    /** Shown in place of the chips when nothing is selected. */
+    placeholder?: React.ReactNode;
+    /**
+     * How a `cascade` selection is condensed into chips. DISPLAY ONLY: the
+     * stored value stays the full closure, which keeps a row's checked state an
+     * O(1) lookup. `"all"` (default) is one chip per value, `"parent"` collapses
+     * a fully selected branch, `"child"` chips only the deepest frontier.
+     * Removing a condensed chip removes its whole closure and reconciles.
+     */
+    strategy?: CascaderCheckedStrategy;
+    /** Replaces the chip list, receiving the resolved selection IN SELECTION
+     * ORDER. Keep that order: Base UI removes a chip by sibling position. */
+    children?: React.ReactNode | ((nodes: CascaderNode[]) => React.ReactNode);
+}
+/**
+ * The multi-select trigger surface: one removable chip per selection, where
+ * `CascaderValue` would collapse to "3 selected". A component rather than a
+ * recipe because of three easy misses: the popup anchored to the chips, an
+ * accessible name on every remove button, and labels that disambiguate when
+ * two branches use the same one.
+ *
+ * ```tsx
+ * const anchor = useCascaderAnchor()
+ * <Cascader multiple items={items}>
+ *   <CascaderChips ref={anchor} placeholder="Select attributes" />
+ *   <CascaderContent anchor={anchor}>...</CascaderContent>
+ * </Cascader>
+ * ```
+ */
+declare function CascaderChips({ className, children, placeholder, strategy, ...props }: CascaderChipsProps): React.JSX.Element;
+export interface CascaderChipProps extends Omit<ComboboxPrimitive.Chip.Props, 'children'> {
+    node: CascaderNode;
+    /** Prefix the label with its ancestor trail. */
+    showPath?: boolean;
+    /** Trail segments to show, the node itself included. */
+    maxSegments?: number;
+    /** Hides the remove button, for a read-only chip. */
+    showRemove?: boolean;
+    /** Replaces Base UI's positional removal for this chip (remove button and
+     * Backspace/Delete). Supplied for a `strategy`-condensed chip, whose
+     * position no longer maps onto the stored array. */
+    onRemove?: () => void;
+    /** Replaces the chip's label. The remove button is still rendered. */
+    children?: React.ReactNode;
+}
+/** One chip. Removal goes through Base UI's `ChipRemove`, which reports the
+ * shortened selection to the root, so it lands in the same `setSelection` as
+ * every other deselection and `cascade` applies to it. */
+declare function CascaderChip({ className, node, showPath, maxSegments, showRemove, onRemove, children, ...props }: CascaderChipProps): React.JSX.Element;
+export interface CascaderContentProps extends ComboboxPrimitive.Popup.Props, 
+/** Positioner surface forwarded as-is, so an unusual anchor does not force
+ * a rebuild of the content stack. No `trackAnchor`: Base UI 1.5.0 has
+ * none. */
+Pick<ComboboxPrimitive.Positioner.Props, 'side' | 'align' | 'sideOffset' | 'alignOffset' | 'anchor' | 'collisionBoundary' | 'collisionPadding' | 'sticky' | 'positionMethod'>, 
+/** Where the portal mounts, for a shadow root or a scoped stacking context. */
+Pick<ComboboxPrimitive.Portal.Props, 'container'> {
+}
+/** Portal + Positioner + floating panel. Unlike shadcn's `ComboboxContent` it
+ * does NOT clamp the popup to the anchor width (a cascader panel is routinely
+ * wider), but it keeps `group/combobox-content`, which `CascaderEmpty` needs. */
+declare function CascaderContent({ className, side, sideOffset, align, alignOffset, anchor, collisionBoundary, collisionPadding, sticky, positionMethod, container, ref, ...props }: CascaderContentProps): React.JSX.Element;
+export type CascaderPanelProps = useRender.ComponentProps<'div'>;
+/**
+ * The nav + list(s) + footer container, with no positioning of its own: inside
+ * `CascaderContent` for the popup case, alone for the embedded one.
+ *
+ * `min-h-0` and `max-h-full` are load-bearing. A flex child without `min-h-0`
+ * refuses to shrink below its content, which is the usual reason a scroll area
+ * never scrolls - worst embedded, where no positioner publishes
+ * `--available-height`. It also owns the panel's TAB ORDER: the scroll area
+ * makes itself a tab stop whenever the level overflows, stranding the footer,
+ * and the panel is the only ancestor of both ends of that move in BOTH shapes.
+ */
+declare function CascaderPanel({ className, ...props }: CascaderPanelProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export interface CascaderListProps extends Omit<ComboboxPrimitive.List.Props, 'style'> {
+    /** Applied to the OUTER shell, which owns the height, so an inline
+     * `--cascader-max-height` lands where the bound can read it. Narrowed from
+     * Base UI's `style`: the shell is a plain `<div>` with no list state. */
+    style?: React.CSSProperties;
+    /** Caps this level's height; the panel still shrinks to fit. Default 24rem. */
+    maxHeight?: number | string;
+}
+/**
+ * Scroll container for one level: pattern 3 of the house scroll reference,
+ * viewport-bounded popup scroll. The height is `min()` of `--available-height`
+ * (the positioner's space between anchor and viewport edge) and `maxHeight`,
+ * so neither can be ignored; a fixed pixel cap alone still reserved 288px for
+ * a panel opened 200px above the fold and spilled off screen, and wasted room
+ * in a tall window. The four classes are shared with `CascaderColumns` and
+ * live in `cascader-lib.tsx`.
+ */
+declare function CascaderList({ className, style, maxHeight: maxHeightProp, ...props }: CascaderListProps): React.JSX.Element;
+export interface CascaderEmptyProps extends ComboboxPrimitive.Empty.Props {
+    /** @deprecated Ignored: the loading surface no longer draws skeletons. They
+     * promised a shape the level might not have and cost a second layout; the
+     * progress lives on the branch row instead. Kept so call sites compile. */
+    skeletonRows?: number;
+}
+/** The empty, loading and error surface, in ONE element that never unmounts.
+ * `Combobox.Empty` renders whenever `filteredItems.length === 0`, as true of a
+ * fetching level as of an empty one, so swapping siblings would announce "No
+ * results found." over every async level. Swap the CHILDREN. */
+declare function CascaderEmpty({ className, children, skeletonRows, ...props }: CascaderEmptyProps): React.JSX.Element;
+export type CascaderStatusProps = ComboboxPrimitive.Status.Props;
+/**
+ * Polite live region for the current level and result count, which drill-down
+ * otherwise hides in a visual breadcrumb. Built on `Combobox.Status` for its
+ * initial-mutation marker: Safari and VoiceOver need a text change ~200ms
+ * after mount before reading a polite region at all.
+ */
+declare function CascaderStatus({ className, children, ...props }: CascaderStatusProps): React.JSX.Element;
+export { Cascader, CascaderTrigger, CascaderChip, CascaderChips, CascaderContent, CascaderPanel, CascaderList, CascaderEmpty, CascaderStatus, };
+/** Re-exported from `cascader-context.tsx`: existing import paths keep
+ * working, and the row component avoids an import cycle through this file. */
+export { createCascaderHighlightStore, useCascaderActions, useCascaderHighlight, useCascaderRender, useCascaderState };
+export type { CascaderActionsContextValue, CascaderColumn, CascaderHighlight, CascaderHighlightStore, CascaderItemState, CascaderRenderContextValue, CascaderStateContextValue, };

package/dist/components/shell-header.d.ts

@@ -0,0 +1,20 @@
+import { DecisionGraphRef, DecisionGraphType } from '@republicroad/seal-editor';
+import { default as React } from 'react';
+export type ShellHeaderProps = {
+    /** 注入槽位的图文档（SkinnedDecisionGraph 自动传入；独立使用时由宿主提供） */
+    graph?: DecisionGraphType;
+    disabled?: boolean;
+    /**
+     * 决策图引用：ref 对象（`useRef` 产物，内部自动解包为当前句柄）或句柄本身；
+     * null = 尚未挂载。
+     */
+    graphRef?: DecisionGraphRef | React.RefObject<DecisionGraphRef | null> | null;
+    className?: string;
+};
+/**
+ * 皮肤头部（S005 P3）：渲染 activeSkin.layout.header 的 left/right 槽位——
+ * 左侧标题/环境标识、右侧状态徽标/操作，均注入 SkinSlotContext。
+ * kernel 保持无 header（页面骨架属宿主，规格稿 §10-3 宿主裁决）；
+ * 无槽位时返回 null，宿主页面层头部不受影响。
+ */
+export declare const ShellHeader: React.FC<ShellHeaderProps>;

package/dist/components/skinned-decision-graph.d.ts

@@ -0,0 +1,19 @@
+import { DecisionGraphProps, DecisionGraphRef } from '@republicroad/seal-editor';
+import { default as React } from 'react';
+import { SimulateHandler } from '../shell/types';
+export type SkinnedDecisionGraphProps = DecisionGraphProps & {
+    /**
+     * 传入后自动注册左侧栏 simulator 面板（kernel GraphSimulator：输入 JSON →
+     * Run → 画布命中高亮 + Output/Trace），onRun 经由此 handler 调执行引擎。
+     * 不传则与直接渲染 `<DecisionGraph>` 行为完全一致。
+     */
+    simulateHandler?: SimulateHandler;
+};
+/**
+ * 皮肤感知的 DecisionGraph（S005 P1）：读取 activeSkin.layout 把工具栏槽位
+ * 映射为 kernel `toolbarItems`（追加在宿主自有项之后），其余 props 全透传。
+ *
+ * - 无皮肤 / 皮肤无 layout → 与直接渲染 `<DecisionGraph>` 行为完全一致
+ * - ctx.graph 随受控 value 更新；graphRef 惰性挂载（挂载后首次重渲染时注入）
+ */
+export declare const SkinnedDecisionGraph: React.ForwardRefExoticComponent<SkinnedDecisionGraphProps & React.RefAttributes<DecisionGraphRef>>;

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,20 @@
+import { AlertDialog as AlertDialogPrimitive } from '@base-ui/react/alert-dialog';
+import * as React from 'react';
+declare const AlertDialog: typeof AlertDialogPrimitive.Root;
+declare const AlertDialogTrigger: AlertDialogPrimitive.Trigger;
+declare const AlertDialogPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogBackdropProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<import('../../components/ui/button').ButtonProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<import('../../components/ui/button').ButtonProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare const Avatar: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AvatarRootProps, "ref"> & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AvatarImageProps, "ref"> & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AvatarFallbackProps, "ref"> & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { Button as ButtonPrimitive } from '@base-ui/react/button';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ComponentPropsWithoutRef<typeof ButtonPrimitive>, VariantProps<typeof buttonVariants> {
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
+export { Button, buttonVariants };

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import * as React from 'react';
+declare const DropdownMenu: <Payload>(props: MenuPrimitive.Root.Props<Payload>) => React.JSX.Element;
+declare const DropdownMenuTrigger: MenuPrimitive.Trigger;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSub: typeof MenuPrimitive.SubmenuRoot;
+declare const DropdownMenuRadioGroup: React.NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuSubmenuTriggerProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & Pick<import('@base-ui/react').MenuPositionerProps, "side" | "sideOffset" | "align" | "alignOffset"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & Pick<import('@base-ui/react').MenuPositionerProps, "side" | "sideOffset" | "align" | "alignOffset"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuCheckboxItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuRadioItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuGroupLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/components/ui/field.d.ts

@@ -0,0 +1,24 @@
+import { VariantProps } from 'class-variance-authority';
+import { Label } from '../../components/ui/label';
+declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): import('react').JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<'legend'> & {
+    variant?: 'legend' | 'label';
+}): import('react').JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<'div'> & VariantProps<typeof fieldVariants>): import('react').JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): import('react').JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): import('react').JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<'p'>): import('react').JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<'div'> & {
+    children?: React.ReactNode;
+}): import('react').JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<'div'> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): import('react').JSX.Element | null;
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle, };

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

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/components/ui/label.d.ts

@@ -0,0 +1,4 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Label: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/components/ui/scroll-area.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ScrollAreaRootProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ScrollAreaScrollbarProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,13 @@
+import { Select as SelectPrimitive } from '@base-ui/react/select';
+import * as React from 'react';
+declare const Select: typeof SelectPrimitive.Root;
+declare const SelectGroup: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectValueProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectScrollUpArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectScrollDownArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & Pick<import('@base-ui/react').SelectPositionerProps, "side" | "sideOffset" | "align" | "alignOffset" | "alignItemWithTrigger"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectGroupLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SelectItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/components/ui/separator.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const Separator: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/components/ui/sheet.d.ts

@@ -0,0 +1,23 @@
+import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
+import * as React from 'react';
+declare const Sheet: <Payload>(props: DialogPrimitive.Root.Props<Payload>) => React.JSX.Element;
+declare const SheetTrigger: DialogPrimitive.Trigger;
+declare const SheetClose: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogBackdropProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type SheetSide = 'top' | 'bottom' | 'left' | 'right';
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Popup> {
+    side?: SheetSide;
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, type SheetSide, };

package/dist/components/ui/sonner.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { Toaster as Sonner } from 'sonner';
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+declare const Toaster: ({ ...props }: ToasterProps) => React.JSX.Element;
+export { Toaster };

package/dist/components/ui/spinner.d.ts

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<'svg'>): import('react').JSX.Element;
+export { Spinner };

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const Switch: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').SwitchRootProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export { Switch };

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+declare const Tabs: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').TabsRootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsListProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsTabProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsPanelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/components/ui/toggle-group.d.ts

@@ -0,0 +1,13 @@
+import { Toggle as TogglePrimitive } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroupPrimitive } from '@base-ui/react/toggle-group';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const ToggleGroup: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.Props<string> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<TogglePrimitive.Props<string> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -0,0 +1,12 @@
+import { Toggle as TogglePrimitive } from '@base-ui/react/toggle';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.Props<string> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
+import * as React from 'react';
+declare const TooltipProvider: React.FC<import('@base-ui/react').TooltipProviderProps>;
+declare const Tooltip: <Payload>(props: TooltipPrimitive.Root.Props<Payload>) => React.JSX.Element;
+declare const TooltipTrigger: TooltipPrimitive.Trigger;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TooltipPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & Pick<import('@base-ui/react').TooltipPositionerProps, "side" | "sideOffset" | "align" | "alignOffset"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/version-history/__tests__/version-history-panel.test.d.ts

@@ -0,0 +1 @@
+export {};