@tangle-network/ui 1.0.0

package/dist/primitives.d.ts

@@ -0,0 +1,332 @@
+export { B as Button, a as ButtonProps, b as buttonVariants } from './button-CMQuQEW_.js';
+import * as React$1 from 'react';
+import { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as LabelPrimitive from '@radix-ui/react-label';
+export { Logo, LogoProps, TangleKnot } from '@tangle-network/brand';
+export { A as ArtifactPane, a as ArtifactPaneProps } from './artifact-pane-DvJyPWV4.js';
+export { C as CodeBlock, a as CodeBlockProps, b as CopyButton } from './code-block-DjXf8eOG.js';
+
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    variant?: "default" | "glass" | "sandbox" | "elevated";
+    hover?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: "default" | "sandbox";
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const inputVariants: (props?: ({
+    variant?: "default" | "sandbox" | "error" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface InputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+    label?: string;
+    error?: string;
+    hint?: string;
+}
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    variant?: "default" | "sandbox";
+    label?: string;
+    error?: string;
+    hint?: string;
+}
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "sandbox" | "error" | "success" | "warning" | "info" | "running" | "creating" | "stopped" | "warm" | "cold" | "deleted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "error" | "info" | "sandbox" | "running" | "creating" | "stopped" | "warm" | "cold" | "deleted" | null;
+interface BadgeProps extends VariantProps<typeof badgeVariants> {
+    variant?: BadgeVariant;
+    className?: string;
+    children?: React$1.ReactNode;
+    dot?: boolean;
+    onClick?: React$1.MouseEventHandler<HTMLDivElement>;
+    style?: React$1.CSSProperties;
+    id?: string;
+    role?: React$1.AriaRole;
+    title?: string;
+    [key: string]: unknown;
+}
+declare function Badge({ className, variant, dot, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: "default" | "pills" | "underline";
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    variant?: "default" | "pills" | "underline";
+} & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Visually lightweight segmented control for single-value selection.
+ *
+ * Uses role="radiogroup" / role="radio" because this is a value-selector
+ * with no associated panels — not a tab interface. Arrow keys navigate
+ * between options (with wrapping), Home/End jump to first/last.
+ *
+ * **Accessibility:** Provide either `aria-label` or `aria-labelledby` — the
+ * ARIA spec requires every radiogroup to have an accessible name. A dev-mode
+ * console warning fires when both are omitted.
+ *
+ * Design rules baked into the default variant:
+ *   - Only the SELECTED segment shows a surface colour + accent text.
+ *   - Unselected segments have NO background — they're plain-text labels
+ *     that darken on hover. This keeps the selected segment as the
+ *     single visual anchor instead of the whole group competing with
+ *     itself.
+ */
+interface SegmentedControlOption<T extends string = string> {
+    value: T;
+    label: React$1.ReactNode;
+    /** Rendered right of the label, typically a count or status pill. */
+    adornment?: React$1.ReactNode;
+}
+interface SegmentedControlProps<T extends string = string> extends Pick<React$1.HTMLAttributes<HTMLDivElement>, "id" | "className" | "aria-label" | "aria-labelledby"> {
+    value: T;
+    onValueChange: (value: T) => void;
+    options: SegmentedControlOption<T>[];
+    /**
+     * Layout:
+     *   - "row"   — horizontal pill bar (default, fits in a header region)
+     *   - "tabs"  — horizontal with a bottom border so the selected pill
+     *              reads as a classic tab (used on the Team page)
+     */
+    variant?: "row" | "tabs";
+}
+declare function SegmentedControl<T extends string = string>({ value, onValueChange, options, variant, className, ...rest }: SegmentedControlProps<T>): react_jsx_runtime.JSX.Element;
+
+declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: "default" | "sandbox";
+    showValue?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function SkeletonCard({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function SkeletonTable({ rows }: {
+    rows?: number;
+}): react_jsx_runtime.JSX.Element;
+
+interface Toast {
+    id: string;
+    title: string;
+    description?: string;
+    variant?: "default" | "success" | "error" | "warning" | "info";
+    duration?: number;
+}
+interface ToastContainerProps {
+    toasts: Toast[];
+    onDismiss: (id: string) => void;
+}
+declare function ToastContainer({ toasts, onDismiss }: ToastContainerProps): react_jsx_runtime.JSX.Element;
+type ToastInput = Omit<Toast, "id">;
+interface ToastContextValue {
+    toasts: Toast[];
+    toast: (input: ToastInput) => void;
+    success: (title: string, description?: string) => void;
+    error: (title: string, description?: string) => void;
+    warning: (title: string, description?: string) => void;
+    info: (title: string, description?: string) => void;
+    dismiss: (id: string) => void;
+}
+declare function ToastProvider({ children }: {
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useToast(): ToastContextValue;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
+
+interface EmptyStateProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    icon?: React$1.ReactNode;
+    title: string;
+    description?: string;
+    action?: React$1.ReactNode;
+}
+declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface StatCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    variant?: "default" | "sandbox";
+    title: string;
+    value: string | number;
+    subtitle?: string;
+    icon?: React$1.ReactNode;
+    trend?: {
+        value: number;
+        label?: string;
+    };
+}
+declare const StatCard: React$1.ForwardRefExoticComponent<StatCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface TerminalDisplayProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    variant?: "default" | "sandbox";
+    title?: string;
+    showHeader?: boolean;
+    autoScroll?: boolean;
+    maxHeight?: string;
+}
+declare const TerminalDisplay: React$1.ForwardRefExoticComponent<TerminalDisplayProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TerminalLineProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    type?: "input" | "output" | "error" | "success" | "info" | "thinking" | "command" | "warning";
+    prompt?: string;
+    timestamp?: string;
+}
+declare const TerminalLine: React$1.ForwardRefExoticComponent<TerminalLineProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TerminalCursor: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLSpanElement> & React$1.RefAttributes<HTMLSpanElement>>;
+interface TerminalInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onSubmit"> {
+    onSubmit?: (value: string) => void;
+    variant?: "default" | "sandbox";
+}
+declare const TerminalInput: React$1.ForwardRefExoticComponent<TerminalInputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface DropZoneProps {
+    /** Called with dropped files */
+    onDrop: (files: File[]) => void;
+    /** Accepted file types (e.g. ".pdf,.csv,.xlsx") */
+    accept?: string;
+    /** Whether drop zone is active */
+    disabled?: boolean;
+    /** Custom overlay content (replaces default) */
+    overlay?: ReactNode;
+    /** Overlay title */
+    title?: string;
+    /** Overlay description */
+    description?: string;
+    /** Overlay icon (Material Symbols name or ReactNode) */
+    icon?: string | ReactNode;
+    /** Children wrapped by the drop zone */
+    children: ReactNode;
+    className?: string;
+}
+declare function DropZone({ onDrop, accept, disabled, overlay, title, description, icon, children, className, }: DropZoneProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * UploadProgress — file upload status indicators.
+ *
+ * Shows a list of files being uploaded with progress bars,
+ * completion checkmarks, and error states.
+ */
+interface UploadFile {
+    id: string;
+    name: string;
+    size: number;
+    status: "pending" | "uploading" | "complete" | "error";
+    progress?: number;
+    error?: string;
+}
+interface UploadProgressProps {
+    files: UploadFile[];
+    onRemove?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    className?: string;
+}
+declare function UploadProgress({ files, onRemove, onRetry, className }: UploadProgressProps): react_jsx_runtime.JSX.Element | null;
+
+interface SidebarDropZoneProps {
+    /** Called with dropped files */
+    onDrop: (files: File[]) => void;
+    /** Accepted file types (e.g. ".pdf,.csv") */
+    accept?: string;
+    /** Whether drop zone is active */
+    disabled?: boolean;
+    /** Title shown in the drop zone */
+    title?: string;
+    /** Description shown below the title */
+    description?: string;
+    /** Custom icon (replaces default upload icon) */
+    icon?: ReactNode;
+    /** Always visible (not just on drag). Useful as a persistent upload area. */
+    persistent?: boolean;
+    className?: string;
+}
+declare function SidebarDropZone({ onDrop, accept, disabled, title, description, icon, persistent, className, }: SidebarDropZoneProps): react_jsx_runtime.JSX.Element;
+
+interface InlineCodeProps extends React.HTMLAttributes<HTMLElement> {
+}
+declare function InlineCode({ className, children, ...props }: InlineCodeProps): react_jsx_runtime.JSX.Element;
+
+export { Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropZone, type DropZoneProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, InlineCode, type InlineCodeProps, Input, type InputProps, Label, Progress, SegmentedControl, type SegmentedControlOption, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SidebarDropZone, type SidebarDropZoneProps, Skeleton, SkeletonCard, SkeletonTable, StatCard, type StatCardProps, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, TerminalCursor, TerminalDisplay, TerminalInput, TerminalLine, Textarea, type TextareaProps, type Toast, ToastContainer, ToastProvider, type UploadFile, UploadProgress, type UploadProgressProps, badgeVariants, useToast };

package/dist/primitives.js

@@ -0,0 +1,191 @@
+import {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  DropZone,
+  EmptyState,
+  Input,
+  Label,
+  Logo,
+  Progress,
+  SegmentedControl,
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+  SidebarDropZone,
+  Skeleton,
+  SkeletonCard,
+  SkeletonTable,
+  StatCard,
+  Switch,
+  TangleKnot,
+  TerminalCursor,
+  TerminalDisplay,
+  TerminalInput,
+  TerminalLine,
+  Textarea,
+  ToastContainer,
+  ToastProvider,
+  UploadProgress,
+  useToast
+} from "./chunk-LISXUB4D.js";
+import {
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger
+} from "./chunk-34A66VBG.js";
+import {
+  Badge,
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  InlineCode,
+  Table,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableHeader,
+  TableRow,
+  badgeVariants
+} from "./chunk-GYPQXTJU.js";
+import {
+  Button,
+  buttonVariants
+} from "./chunk-MKTSMWVD.js";
+import {
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger
+} from "./chunk-Q56BYXQF.js";
+import {
+  ArtifactPane
+} from "./chunk-CSAIKY36.js";
+import {
+  CodeBlock,
+  CopyButton
+} from "./chunk-66BNMOVT.js";
+import "./chunk-RQHJBTEU.js";
+export {
+  ArtifactPane,
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Badge,
+  Button,
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  CodeBlock,
+  CopyButton,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  DropZone,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger,
+  EmptyState,
+  InlineCode,
+  Input,
+  Label,
+  Logo,
+  Progress,
+  SegmentedControl,
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+  SidebarDropZone,
+  Skeleton,
+  SkeletonCard,
+  SkeletonTable,
+  StatCard,
+  Switch,
+  Table,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+  TangleKnot,
+  TerminalCursor,
+  TerminalDisplay,
+  TerminalInput,
+  TerminalLine,
+  Textarea,
+  ToastContainer,
+  ToastProvider,
+  UploadProgress,
+  badgeVariants,
+  buttonVariants,
+  useToast
+};

package/dist/run-PfLmDAox.d.ts

@@ -0,0 +1,41 @@
+import { S as SessionMessage } from './message-BHWbxBtT.js';
+
+/** Broad category of a tool invocation, used for display grouping. */
+type ToolCategory = "command" | "write" | "read" | "search" | "edit" | "task" | "web" | "todo" | "other";
+interface RunStats {
+    toolCount: number;
+    messageCount: number;
+    thinkingDurationMs: number;
+    textPartCount: number;
+    toolCategories: Set<ToolCategory>;
+}
+interface FinalTextPart {
+    messageId: string;
+    partIndex: number;
+    text: string;
+}
+/**
+ * A Run is a consecutive group of assistant messages that form one
+ * logical "turn" of the agent. Runs are collapsible in the UI and
+ * show a summary header when collapsed.
+ */
+interface Run {
+    id: string;
+    messages: SessionMessage[];
+    isComplete: boolean;
+    isStreaming: boolean;
+    stats: RunStats;
+    summaryText: string | null;
+    finalTextPart: FinalTextPart | null;
+}
+interface MessageRun {
+    type: "run";
+    run: Run;
+}
+interface MessageUser {
+    type: "user";
+    message: SessionMessage;
+}
+type GroupedMessage = MessageRun | MessageUser;
+
+export type { FinalTextPart as F, GroupedMessage as G, MessageRun as M, Run as R, ToolCategory as T, MessageUser as a, RunStats as b };

package/dist/run.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { R as Run } from './run-PfLmDAox.js';
+import { S as SessionPart, a as ToolPart, R as ReasoningPart } from './parts-dj7AcUg0.js';
+import { AgentBranding } from './types.js';
+import { C as CustomToolRenderer } from './tool-display-z4JcDmMQ.js';
+export { F as FeedSegment, T as ToolCallData, a as ToolCallFeed, b as ToolCallFeedProps, c as ToolCallGroup, d as ToolCallGroupProps, e as ToolCallStatus, f as ToolCallStep, g as ToolCallStepProps, h as ToolCallType, p as parseToolEvent } from './tool-call-feed-Bs3MyQMT.js';
+import './message-BHWbxBtT.js';
+
+interface RunGroupProps {
+    run: Run;
+    partMap: Record<string, SessionPart[]>;
+    collapsed: boolean;
+    onToggle: () => void;
+    branding?: AgentBranding;
+    renderToolDetail?: CustomToolRenderer;
+    headerActions?: ReactNode;
+    renderToolActions?: (part: ToolPart, options: {
+        run: Run;
+        messageId: string;
+        partIndex: number;
+    }) => ReactNode;
+}
+/**
+ * Collapsible container for a consecutive group of assistant messages (a "run").
+ * Shows a summary header with stats and renders tool/thinking/text parts.
+ */
+declare const RunGroup: React.MemoExoticComponent<({ run, partMap, collapsed, onToggle, branding, renderToolDetail, headerActions, renderToolActions, }: RunGroupProps) => react_jsx_runtime.JSX.Element | null>;
+
+interface InlineToolItemProps {
+    part: ToolPart;
+    renderToolDetail?: CustomToolRenderer;
+    groupPosition?: "single" | "first" | "middle" | "last";
+    className?: string;
+    contentClassName?: string;
+    actions?: ReactNode;
+}
+/**
+ * Compact single-line tool call display (32px height).
+ * Shows icon, title, description, duration, and status indicator.
+ * Expands on click to show ExpandedToolDetail.
+ */
+declare const InlineToolItem: React.MemoExoticComponent<({ part, renderToolDetail, groupPosition, className, contentClassName, actions, }: InlineToolItemProps) => react_jsx_runtime.JSX.Element>;
+
+interface InlineThinkingItemProps {
+    part: ReasoningPart;
+    defaultOpen?: boolean;
+    autoCollapse?: boolean;
+    className?: string;
+    contentClassName?: string;
+}
+declare const InlineThinkingItem: React.MemoExoticComponent<({ part, defaultOpen, autoCollapse, className, contentClassName, }: InlineThinkingItemProps) => react_jsx_runtime.JSX.Element>;
+
+interface ExpandedToolDetailProps {
+    part: ToolPart;
+}
+/**
+ * Renders full tool details when a tool item is expanded.
+ * Dispatches to specialised previews (CommandPreview, WriteFilePreview)
+ * or falls back to a generic input/output code view.
+ */
+declare const ExpandedToolDetail: React.MemoExoticComponent<({ part }: ExpandedToolDetailProps) => react_jsx_runtime.JSX.Element>;
+
+declare function LiveDuration({ startTime }: {
+    startTime: number;
+}): react_jsx_runtime.JSX.Element;
+
+export { ExpandedToolDetail, type ExpandedToolDetailProps, InlineThinkingItem, type InlineThinkingItemProps, InlineToolItem, type InlineToolItemProps, LiveDuration, RunGroup, type RunGroupProps };

package/dist/run.js

@@ -0,0 +1,36 @@
+import "./chunk-LQS34IGP.js";
+import {
+  ToolCallFeed,
+  parseToolEvent
+} from "./chunk-7UO2ZMRQ.js";
+import {
+  ExpandedToolDetail,
+  InlineThinkingItem,
+  InlineToolItem,
+  LiveDuration,
+  RunGroup
+} from "./chunk-YNN4O57I.js";
+import {
+  ToolCallGroup,
+  ToolCallStep
+} from "./chunk-2VH6PUXD.js";
+import "./chunk-4CLN43XT.js";
+import "./chunk-BX6AQMUS.js";
+import "./chunk-XIHMJ7ZQ.js";
+import "./chunk-TMFOPHHN.js";
+import "./chunk-GYPQXTJU.js";
+import "./chunk-MKTSMWVD.js";
+import "./chunk-CD53GZOM.js";
+import "./chunk-66BNMOVT.js";
+import "./chunk-RQHJBTEU.js";
+export {
+  ExpandedToolDetail,
+  InlineThinkingItem,
+  InlineToolItem,
+  LiveDuration,
+  RunGroup,
+  ToolCallFeed,
+  ToolCallGroup,
+  ToolCallStep,
+  parseToolEvent
+};