@invect/ui 0.0.1

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

@@ -0,0 +1,9 @@
+import * as React from 'react';
+declare function Card({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent };

package/dist/components/ui/codemirror-js-editor.d.ts

@@ -0,0 +1,25 @@
+interface CodeMirrorJsEditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+    /** Initial height in px (default: 320). */
+    defaultHeight?: number;
+    /** Minimum resize height in px (default: 120). */
+    minHeight?: number;
+    /** Maximum resize height in px (default: 600). */
+    maxHeight?: number;
+    /**
+     * Input data available as variables in scope.
+     * Top-level keys are variable names; nested object keys drive property completions.
+     */
+    inputData?: Record<string, unknown>;
+    /** Hide the left gutter (line numbers / fold indicators). Default: false. */
+    hideGutter?: boolean;
+    /** Hide the top toolbar (word wrap, format buttons). Default: false. */
+    hideToolbar?: boolean;
+    /** Hide the bottom resize drag handle. Default: false. */
+    hideResize?: boolean;
+}
+export declare function CodeMirrorJsEditor({ value, onChange, placeholder, className, defaultHeight, minHeight, maxHeight, inputData, hideGutter, hideToolbar, hideResize, }: CodeMirrorJsEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/codemirror-json-editor.d.ts

@@ -0,0 +1,18 @@
+import { UpstreamSlot } from '../flow-editor/node-config-panel/types';
+interface CodeMirrorJsonEditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    readOnly?: boolean;
+    className?: string;
+    minHeight?: string;
+    /** Disable JSON syntax error highlighting (useful for output panels showing plain text) */
+    disableLinting?: boolean;
+    /** Upstream slot metadata for inline run controls */
+    upstreamSlots?: UpstreamSlot[];
+    /** Called when user clicks the run/retry button for a slot */
+    onRunSlot?: (slot: UpstreamSlot) => void;
+    /** JSON keys to auto-fold when content is set (e.g. ['previous_nodes']) */
+    defaultFoldKeys?: string[];
+}
+export declare function CodeMirrorJsonEditor({ value, onChange, readOnly, className, minHeight, disableLinting, upstreamSlots, onRunSlot, defaultFoldKeys, }: CodeMirrorJsonEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/codemirror-nunjucks-editor.d.ts

@@ -0,0 +1,13 @@
+interface CodeMirrorNunjucksEditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    readOnly?: boolean;
+    className?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    multiline?: boolean;
+    rows?: number;
+    fillAvailableHeight?: boolean;
+}
+export declare function CodeMirrorNunjucksEditor({ value, onChange, readOnly, className, placeholder, disabled, multiline, rows, fillAvailableHeight, }: CodeMirrorNunjucksEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/codemirror-vscode-theme.d.ts

@@ -0,0 +1,24 @@
+import { Extension } from '@codemirror/state';
+export declare const CODEMIRROR_IOSEVKA_FONT_STACK = "\"Iosevka\", var(--font-mono, ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace)";
+export interface CodeMirrorVscodePalette {
+    keyword: string;
+    operator: string;
+    variable: string;
+    string: string;
+    function: string;
+    comment: string;
+    error: string;
+    surface: string;
+    surfaceAlt: string;
+    border: string;
+    foreground: string;
+    foregroundMuted: string;
+    foregroundInverse: string;
+    accent: string;
+    accentHover: string;
+    selection: string;
+}
+export declare const vsCodeDarkModern: Extension;
+export declare const vsCodeLightModern: Extension;
+export declare function useCodeMirrorVscodeTheme(): Extension;
+export declare function useCodeMirrorVscodePalette(): CodeMirrorVscodePalette;

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const Collapsible: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

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

@@ -0,0 +1,18 @@
+import { Command as CommandPrimitive } from 'cmdk';
+import { Dialog } from './dialog';
+import * as React from 'react';
+declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+declare function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function CommandItem({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

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

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ container, children, ...props }: React.ComponentProps<typeof DialogPrimitive.Portal> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    showCloseButton?: boolean;
+    container?: HTMLElement | null;
+} & React.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

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

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/components/ui/empty-state.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+interface EmptyStateAction {
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'outline' | 'ghost';
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+interface EmptyStateProps {
+    icon: React.ReactNode;
+    title: string;
+    description: string;
+    actions?: EmptyStateAction[];
+    /** Optional secondary text below description */
+    hint?: string;
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+export declare function EmptyState({ icon, title, description, actions, hint, className, size, }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

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 * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+declare function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Label };

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

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement | null;
+    disablePortal?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare function PopoverAnchor(props: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

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

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import * as ResizablePrimitive from 'react-resizable-panels';
+declare function ResizablePanelGroup({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>): import("react/jsx-runtime").JSX.Element;
+declare function ResizablePanel({ ...props }: React.ComponentProps<typeof ResizablePrimitive.Panel>): import("react/jsx-runtime").JSX.Element;
+declare function ResizableHandle({ withHandle, className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    withHandle?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle };

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

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): import("react/jsx-runtime").JSX.Element;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: 'sm' | 'default';
+}): import("react/jsx-runtime").JSX.Element;
+type SelectContentProps = React.ComponentProps<typeof SelectPrimitive.Content> & {
+    container?: HTMLElement | null;
+};
+declare function SelectContent({ className, children, position, align, container, ...props }: SelectContentProps): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

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

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Separator };

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

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Slider };

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

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

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

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare function Table({ className, ...props }: React.ComponentProps<'table'>): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<'thead'>): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<'tbody'>): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<'tfoot'>): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<'tr'>): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<'th'>): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<'td'>): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<'caption'>): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption };

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

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

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

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/ui/tree-view.d.ts

@@ -0,0 +1,107 @@
+import { default as React } from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+interface TreeDataItem {
+    id: string;
+    name: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    selectedIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    openIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    children?: TreeDataItem[];
+    trailingContent?: React.ReactNode;
+    childContainerClassName?: string;
+    actions?: React.ReactNode;
+    onClick?: () => void;
+    draggable?: boolean;
+    droppable?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+type TreeRenderItemParams = {
+    item: TreeDataItem;
+    level: number;
+    isLeaf: boolean;
+    isSelected: boolean;
+    isOpen?: boolean;
+    hasChildren: boolean;
+};
+declare const TreeView: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    data: TreeDataItem[] | TreeDataItem;
+    initialSelectedItemId?: string;
+    onSelectChange?: (item: TreeDataItem | undefined) => void;
+    expandAll?: boolean;
+    defaultNodeIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    defaultLeafIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    onDocumentDrag?: (sourceItem: TreeDataItem, targetItem: TreeDataItem) => void;
+    renderItem?: (params: TreeRenderItemParams) => React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TreeItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    data: TreeDataItem[] | TreeDataItem;
+    initialSelectedItemId?: string;
+    onSelectChange?: (item: TreeDataItem | undefined) => void;
+    expandAll?: boolean;
+    defaultNodeIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    defaultLeafIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    onDocumentDrag?: (sourceItem: TreeDataItem, targetItem: TreeDataItem) => void;
+    renderItem?: (params: TreeRenderItemParams) => React.ReactNode;
+} & {
+    selectedItemId?: string;
+    handleSelectChange: (item: TreeDataItem | undefined) => void;
+    expandedItemIds: string[];
+    defaultNodeIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    defaultLeafIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    handleDragStart?: (item: TreeDataItem) => void;
+    handleDrop?: (item: TreeDataItem) => void;
+    draggedItem: TreeDataItem | null;
+    level?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TreeNode: ({ item, handleSelectChange, expandedItemIds, selectedItemId, defaultNodeIcon, defaultLeafIcon, handleDragStart, handleDrop, draggedItem, renderItem, level, }: {
+    item: TreeDataItem;
+    handleSelectChange: (item: TreeDataItem | undefined) => void;
+    expandedItemIds: string[];
+    selectedItemId?: string;
+    defaultNodeIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    defaultLeafIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    handleDragStart?: (item: TreeDataItem) => void;
+    handleDrop?: (item: TreeDataItem) => void;
+    draggedItem: TreeDataItem | null;
+    renderItem?: (params: TreeRenderItemParams) => React.ReactNode;
+    level?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const TreeLeaf: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    item: TreeDataItem;
+    level: number;
+    selectedItemId?: string;
+    handleSelectChange: (item: TreeDataItem | undefined) => void;
+    defaultLeafIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    handleDragStart?: (item: TreeDataItem) => void;
+    handleDrop?: (item: TreeDataItem) => void;
+    draggedItem: TreeDataItem | null;
+    renderItem?: (params: TreeRenderItemParams) => React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { TreeView, type TreeDataItem, type TreeRenderItemParams, AccordionTrigger, AccordionContent, TreeLeaf, TreeNode, TreeItem, };

package/dist/contexts/AgentToolCallbacksContext.d.ts

@@ -0,0 +1,23 @@
+import { ToolDefinition } from '../components/nodes/ToolSelectorModal';
+/**
+ * Context for Agent node tool management callbacks.
+ *
+ * This avoids the expensive pattern of remapping ALL nodes on every render
+ * just to inject callbacks into Agent node data. Instead, AgentNode reads
+ * these callbacks directly from context, and the nodes array passed to
+ * ReactFlow keeps its original object references — letting React Flow's
+ * internal shallow comparison skip re-renders for unmoved nodes.
+ */
+export interface AgentToolCallbacks {
+    onOpenToolSelector: (nodeId: string) => void;
+    onShowMoreTools: (nodeId: string) => void;
+    onRemoveTool: (nodeId: string, instanceId: string) => void;
+    onToolClick: (nodeId: string, instanceId: string) => void;
+    availableTools: ToolDefinition[];
+    /** The node ID that currently has the tool selector/config open */
+    selectedToolNodeId: string | null;
+    /** The tool instance ID currently being configured */
+    selectedToolInstanceId: string | null;
+}
+export declare const AgentToolCallbacksProvider: import('react').Provider<AgentToolCallbacks | null>;
+export declare function useAgentToolCallbacks(): AgentToolCallbacks | null;

package/dist/contexts/ApiContext.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ApiClient } from '../api/client';
+export interface ApiProviderProps {
+    children: React.ReactNode;
+    baseURL?: string;
+    /** Pre-configured API client instance. When provided, baseURL is ignored. */
+    apiClient?: ApiClient;
+}
+export declare const ApiProvider: React.FC<ApiProviderProps>;
+export declare const useApiClient: () => ApiClient;
+export declare const useApiBaseURL: () => string;

package/dist/contexts/FlowDataContext.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { UseFlowDataResult } from '../hooks/use-flow-data';
+interface FlowDataProviderProps {
+    value: UseFlowDataResult;
+    children: React.ReactNode;
+}
+export declare function FlowDataProvider({ value, children }: FlowDataProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFlowDataContext(): UseFlowDataResult;
+export {};

package/dist/contexts/NodeRegistryContext.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { NodeDefinition } from '../types/node-definition.types';
+interface NodeRegistryContextType {
+    nodeDefinitions: NodeDefinition[];
+    isLoading: boolean;
+    error: Error | null;
+    getNodeDefinition: (type: string) => NodeDefinition | undefined;
+    refreshDefinitions: () => Promise<void>;
+}
+export declare const NodeRegistryProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useNodeRegistry: () => NodeRegistryContextType;
+export {};

package/dist/contexts/PluginRegistryContext.d.ts

@@ -0,0 +1,39 @@
+import { default as React, ReactNode } from 'react';
+import { InvectFrontendPlugin, PluginSidebarContribution, PluginRouteContribution, PluginPanelTabContribution, PluginHeaderActionContribution, PermissionContext } from '../types/plugin.types';
+export interface PluginRegistry {
+    /** All sidebar items from plugins, grouped by position */
+    sidebarItems: PluginSidebarContribution[];
+    /** Component for the sidebar footer (user menu). First plugin to provide wins. */
+    SidebarFooter: React.ComponentType<{
+        collapsed: boolean;
+        basePath: string;
+    }> | null;
+    /** All routes contributed by plugins */
+    routes: PluginRouteContribution[];
+    /** Panel tabs grouped by context (e.g. 'flowEditor', 'nodeConfig') */
+    panelTabs: Record<string, PluginPanelTabContribution[]>;
+    /** Header actions grouped by context (e.g. 'flowHeader', 'flowList') */
+    headerActions: Record<string, PluginHeaderActionContribution[]>;
+    /** All provider wrappers from plugins (in registration order) */
+    providers: React.ComponentType<{
+        children: ReactNode;
+    }>[];
+    /**
+     * Permission checker — first plugin to return non-undefined wins.
+     * Returns true if no plugin overrides (default: allow everything).
+     */
+    checkPermission: (permission: string, context?: PermissionContext) => boolean;
+    /** Whether any plugins are registered */
+    hasPlugins: boolean;
+}
+interface PluginRegistryProviderProps {
+    plugins: InvectFrontendPlugin[];
+    children: ReactNode;
+}
+export declare function PluginRegistryProvider({ plugins, children }: PluginRegistryProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the plugin registry from any component inside `<Invect />`.
+ * Returns a default (empty) registry if no plugins are registered.
+ */
+export declare function usePluginRegistry(): PluginRegistry;
+export {};

package/dist/contexts/ThemeProvider.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+type Theme = 'dark' | 'light' | 'system';
+type ResolvedTheme = 'dark' | 'light';
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+    className?: string;
+}
+interface ThemeContextValue {
+    theme: Theme;
+    resolvedTheme: ResolvedTheme;
+    setTheme: (theme: Theme) => void;
+}
+export declare function ThemeProvider({ children, defaultTheme, storageKey, className, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useOptionalTheme(): ThemeContextValue | undefined;
+export declare function useTheme(): ThemeContextValue;
+export {};

package/dist/contexts/ValidationContext.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { FlowValidationResult, FlowValidationError, FlowValidationWarning } from '@invect/core/types';
+interface ValidationContextValue {
+    validationResult: FlowValidationResult | null;
+    setValidationResult: (result: FlowValidationResult | null) => void;
+    clearValidation: () => void;
+    hasErrors: boolean;
+    hasWarnings: boolean;
+    getNodeErrors: (nodeId: string) => FlowValidationError[];
+    getNodeWarnings: (nodeId: string) => FlowValidationWarning[];
+    getEdgeErrors: (edgeId: string) => FlowValidationError[];
+    getEdgeWarnings: (edgeId: string) => FlowValidationWarning[];
+    isNodeInvalid: (nodeId: string) => boolean;
+    isEdgeInvalid: (edgeId: string) => boolean;
+    hasNodeWarnings: (nodeId: string) => boolean;
+    hasEdgeWarnings: (edgeId: string) => boolean;
+}
+export declare function ValidationProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useValidation(): ValidationContextValue;
+export {};

package/dist/demo/DemoInvect.d.ts

@@ -0,0 +1,11 @@
+import { InvectProps } from '../Invect';
+import { DemoData } from './demo-api-client';
+export interface DemoInvectProps extends Omit<InvectProps, 'apiBaseUrl' | 'apiClient'> {
+    /** Static data to power the demo UI */
+    data: DemoData;
+}
+/**
+ * Full Invect UI with no backend — all data comes from the `data` prop.
+ * Uses MemoryRouter by default so it doesn't affect the host page's URL.
+ */
+export declare function DemoInvect({ data, useMemoryRouter, ...rest }: DemoInvectProps): import("react/jsx-runtime").JSX.Element;

package/dist/demo/FlowViewer.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { Node, Edge } from '@xyflow/react';
+import { NodeDefinition } from '../types/node-definition.types';
+import { ReactFlowNodeData, AgentToolDefinition } from '@invect/core/types';
+export interface FlowViewerProps {
+    /** React Flow nodes to render */
+    nodes: Node<ReactFlowNodeData>[];
+    /** React Flow edges to render */
+    edges: Edge[];
+    /** Node definitions for rendering and config panel */
+    nodeDefinitions?: NodeDefinition[];
+    /** Agent tool definitions (shown on agent nodes) */
+    agentTools?: AgentToolDefinition[];
+    /** Theme mode */
+    theme?: 'light' | 'dark' | 'system';
+    /** Allow double-click to open the node config panel */
+    interactive?: boolean;
+    /** Show React Flow controls (zoom, fit) */
+    showControls?: boolean;
+    /** CSS class name for the outer container */
+    className?: string;
+    /** Inline styles for the outer container */
+    style?: React.CSSProperties;
+    /** Additional class for the outer container */
+    containerClassName?: string;
+}
+/**
+ * Self-contained flow viewer with all necessary providers.
+ * Renders React Flow canvas with Invect node styling.
+ */
+export declare function FlowViewer({ theme, className, style, containerClassName, nodeDefinitions, agentTools, ...canvasProps }: FlowViewerProps): import("react/jsx-runtime").JSX.Element;