@theclearsky/react-blender-nodes 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -1,38 +1,65 @@
+import { Accordion as Accordion_2 } from 'radix-ui';
+import { Action as Action_2 } from '../../../utils';
 import { ActionDispatch } from 'react';
 import { ClassProp } from 'class-variance-authority/types';
 import { ClassValue } from 'clsx';
 import { ComponentProps } from 'react';
+import { ComponentType } from 'react';
 import { Connection } from '@xyflow/react';
 import { Context } from 'react';
+import { ContextData } from '@floating-ui/react';
 import { ControlLinePosition } from '@xyflow/react';
 import { ControlPosition } from '@xyflow/react';
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'zod';
+import { Dispatch } from 'react';
 import { Edge } from '@xyflow/react';
 import { EdgeChange } from '@xyflow/react';
 import { EdgeLabelOptions } from '@xyflow/react';
 import { EdgePosition } from '@xyflow/system';
 import { EdgeProps } from '@xyflow/react';
+import { ExtendedElements } from '@floating-ui/react';
+import { ExtendedRefs } from '@floating-ui/react';
 import { FC } from 'react';
+import { FloatingEvents } from '@floating-ui/react';
 import { ForwardRefExoticComponent } from 'react';
 import { HandleShape as HandleShape_2 } from '../..';
 import { HandleType } from '@xyflow/react';
 import { HTMLAttributes } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { MiddlewareData } from '@floating-ui/core';
+import { MutableRefObject } from 'react';
 import { Node as Node_2 } from '@xyflow/react';
 import { NodeChange } from '@xyflow/react';
 import { NodeProps } from '@xyflow/react';
 import { NodeResizerProps } from '@xyflow/react';
+import { OpenChangeReason } from '@floating-ui/react';
+import { Placement } from '@floating-ui/react';
 import { Position } from '@xyflow/react';
+import * as React_2 from 'react';
 import { ReactNode } from 'react';
 import { RefAttributes } from 'react';
+import { ReferenceType } from '@floating-ui/react';
+import { ReferenceType as ReferenceType_2 } from '@floating-ui/react-dom';
 import { RefObject } from 'react';
 import { ResizeControlDirection } from '@xyflow/system';
 import * as SelectPrimitive from '@radix-ui/react-select';
+import { SetStateAction } from 'react';
+import { Strategy } from '@floating-ui/utils';
 import { TypeOfNode as TypeOfNode_2 } from './types';
 import { VariantProps } from 'class-variance-authority';
 import { Viewport } from '@xyflow/react';
 import { XYPosition } from '@xyflow/react';
 import { z } from 'zod';
 
+export declare function Accordion({ ...props }: React_2.ComponentProps<typeof Accordion_2.Root>): JSX.Element;
+
+export declare function AccordionContent({ className, children, ...props }: React_2.ComponentProps<typeof Accordion_2.Content>): JSX.Element;
+
+export declare function AccordionItem({ className, ...props }: React_2.ComponentProps<typeof Accordion_2.Item>): JSX.Element;
+
+export declare function AccordionTrigger({ className, children, ...props }: React_2.ComponentProps<typeof Accordion_2.Trigger>): JSX.Element;
+
 /**
  * Union type of all possible actions for the graph state reducer
  *
@@ -114,6 +141,13 @@ export declare type Action<DataTypeUniqueId extends string = string, NodeTypeUni
         /** Current viewport of the graph */
         viewport: Viewport;
     };
+} | {
+    /** Replace the entire graph state (used by import) */
+    type: typeof actionTypesMap.REPLACE_STATE;
+    payload: {
+        /** The new state to replace the current state with */
+        state: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>;
+    };
 };
 
 /** Map of action types for type-safe action dispatching */
@@ -128,6 +162,7 @@ export declare const actionTypesMap: {
     readonly CLOSE_NODE_GROUP: "CLOSE_NODE_GROUP";
     readonly ADD_NODE_GROUP: "ADD_NODE_GROUP";
     readonly SET_VIEWPORT: "SET_VIEWPORT";
+    readonly REPLACE_STATE: "REPLACE_STATE";
 };
 
 export declare function addAnInputOrOutputToAllNodesOfANodeTypeAcrossStateIncludingSubtrees<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(state: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>, nodeType: NodeTypeUniqueId, typeOfInputOrOutput: TypeOfInput<DataTypeUniqueId>, addAtIndex: HandleIndices, beforeOrAfterIndex?: 'before' | 'after'): Pick<State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>, 'typeOfNodes' | 'nodes' | 'edges'>;
@@ -232,6 +267,23 @@ export declare type ButtonProps = ComponentProps<'button'> & VariantProps<typeof
     asChild?: boolean;
 };
 
+export declare function ButtonToggle<T extends string>({ options, value, onChange, disabled, size, className, }: ButtonToggleProps<T>): JSX.Element;
+
+export declare type ButtonToggleOption<T extends string> = {
+    value: T;
+    label: string;
+};
+
+export declare type ButtonToggleProps<T extends string> = {
+    options: readonly ButtonToggleOption<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    disabled?: boolean;
+    /** @default 'normal' */
+    size?: 'small' | 'normal';
+    className?: string;
+};
+
 declare const buttonVariants: (props?: ({
     color?: "dark" | "lightNonPriority" | "lightPriority" | "lightParentGroupBasedHover" | null | undefined;
     applyHoverStyles?: boolean | null | undefined;
@@ -270,6 +322,17 @@ declare const buttonVariants: (props?: ({
  */
 export declare function cn(...inputs: ClassValue[]): string;
 
+/**
+ * Recording of a single concurrency level's execution.
+ */
+declare type ConcurrencyLevelRecord = {
+    level: number;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    nodeIds: ReadonlyArray<string>;
+};
+
 /**
  * A configurable edge component with gradient colors and viewport optimization
  *
@@ -396,14 +459,16 @@ export declare type ConfigurableEdgeState = Edge<{}, 'configurableEdge'>;
  * ```
  */
 export declare const ConfigurableNode: ForwardRefExoticComponent<    {
+/** Unique identifier for the node, for debugging when enableDebugMode is true and inside react flow */
+id?: string;
 /** Display name of the node */
 name?: string;
 /** Background color of the node header */
 headerColor?: string;
 /** Array of inputs and input panels */
-inputs?: (ConfigurableNodeInput<"string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", never, string> | ConfigurableNodeInputPanel<"string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", never, string>)[] | undefined;
+inputs?: (ConfigurableNodeInput<"string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never, string> | ConfigurableNodeInputPanel<"string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never, string>)[] | undefined;
 /** Array of output sockets */
-outputs?: ConfigurableNodeOutput<"string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", never, string>[] | undefined;
+outputs?: ConfigurableNodeOutput<"string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never, string>[] | undefined;
 /** Whether the node is currently inside a ReactFlow context */
 isCurrentlyInsideReactFlow?: boolean;
 /** Props for the node resizer component */
@@ -416,6 +481,12 @@ nodeTypeUniqueId?: string | undefined;
 * @default false
 */
 showNodeOpenButton?: boolean;
+/** Runner visual state for this node (undefined = no runner overlay) */
+runnerVisualState?: NodeVisualState;
+/** Errors from the runner for this node */
+runnerErrors?: ReadonlyArray<GraphError>;
+/** Warnings from the runner for this node (e.g., missing implementation) */
+runnerWarnings?: ReadonlyArray<string>;
 } & HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
 
 /**
@@ -435,6 +506,8 @@ export declare type ConfigurableNodeInput<UnderlyingType extends SupportedUnderl
     handleShape?: HandleShape;
     /** Whether to show an interactive input component when not connected */
     allowInput?: boolean;
+    /** Maximum number of connections for this input */
+    maxConnections?: number;
     /** Data type of the input, used by full graph */
     dataType?: {
         dataTypeObject: DataType<UnderlyingType, ComplexSchemaType>;
@@ -459,6 +532,20 @@ export declare type ConfigurableNodeInput<UnderlyingType extends SupportedUnderl
     value?: number;
     /** Callback when the input value changes */
     onChange?: (value: number) => void;
+} | {
+    /**  */
+    type: 'boolean';
+    /** Current value of the input */
+    value?: boolean;
+    /** Callback when the input value changes */
+    onChange?: (value: boolean) => void;
+} | {
+    /** Unsupported input type */
+    type: 'unsupportedDirectly';
+    /** Current value of the input */
+    value?: unknown;
+    /** Callback when the input value changes */
+    onChange?: (value: unknown) => void;
 });
 
 /**
@@ -489,6 +576,8 @@ export declare type ConfigurableNodeOutput<UnderlyingType extends SupportedUnder
     handleColor?: string;
     /** Shape of the output handle (circle, square, diamond, etc.) */
     handleShape?: HandleShape;
+    /** Maximum number of connections for this output */
+    maxConnections?: number;
     /** Data type of the output, used by full graph */
     dataType?: {
         dataTypeObject: DataType<UnderlyingType, ComplexSchemaType>;
@@ -505,6 +594,12 @@ export declare type ConfigurableNodeOutput<UnderlyingType extends SupportedUnder
 } | {
     /** Number output type */
     type: 'number';
+} | {
+    /** Boolean output type */
+    type: 'boolean';
+} | {
+    /** Unsupported output type */
+    type: 'unsupportedDirectly';
 });
 
 /**
@@ -514,6 +609,8 @@ export declare type ConfigurableNodeOutput<UnderlyingType extends SupportedUnder
  * and optional panels. Supports both standalone usage and ReactFlow integration.
  */
 export declare type ConfigurableNodeProps<UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, NodeTypeUniqueId extends string = string, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never, DataTypeUniqueId extends string = string> = {
+    /** Unique identifier for the node, for debugging when enableDebugMode is true and inside react flow */
+    id?: string;
     /** Display name of the node */
     name?: string;
     /** Background color of the node header */
@@ -534,6 +631,12 @@ export declare type ConfigurableNodeProps<UnderlyingType extends SupportedUnderl
      * @default false
      */
     showNodeOpenButton?: boolean;
+    /** Runner visual state for this node (undefined = no runner overlay) */
+    runnerVisualState?: NodeVisualState;
+    /** Errors from the runner for this node */
+    runnerErrors?: ReadonlyArray<GraphError>;
+    /** Warnings from the runner for this node (e.g., missing implementation) */
+    runnerWarnings?: ReadonlyArray<string>;
 } & HTMLAttributes<HTMLDivElement>;
 
 /**
@@ -579,7 +682,7 @@ export declare type ConfigurableNodeProps<UnderlyingType extends SupportedUnderl
  * />
  * ```
  */
-export declare const ConfigurableNodeReactFlowWrapper: ForwardRefExoticComponent<Omit<ConfigurableNodeReactFlowWrapperProps<"string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", string, never, string>, "position"> & RefAttributes<HTMLDivElement>>;
+export declare const ConfigurableNodeReactFlowWrapper: ForwardRefExoticComponent<Omit<ConfigurableNodeReactFlowWrapperProps<"string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", string, never, string>, "position"> & RefAttributes<HTMLDivElement>>;
 
 /** Props for the ConfigurableNodeReactFlowWrapper component */
 export declare type ConfigurableNodeReactFlowWrapperProps<UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, NodeTypeUniqueId extends string = string, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never, DataTypeUniqueId extends string = string> = NodeProps<ConfigurableNodeState<UnderlyingType, NodeTypeUniqueId, ComplexSchemaType, DataTypeUniqueId>> & {
@@ -823,6 +926,8 @@ id: string;
 color?: string;
 /** Shape of the handle */
 shape?: HandleShape;
+/** Maximum number of connections for this handle */
+maxConnections?: number;
 /** Whether the handle is currently inside a ReactFlow context */
 isCurrentlyInsideReactFlow?: boolean;
 } & HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
@@ -841,6 +946,8 @@ export declare type ContextAwareHandleProps = {
     color?: string;
     /** Shape of the handle */
     shape?: HandleShape;
+    /** Maximum number of connections for this handle */
+    maxConnections?: number;
     /** Whether the handle is currently inside a ReactFlow context */
     isCurrentlyInsideReactFlow?: boolean;
 } & HTMLAttributes<HTMLDivElement>;
@@ -876,7 +983,7 @@ export declare type ContextAwareHandleProps = {
  * />
  * ```
  */
-export declare const ContextAwareInput: ({ input, isCurrentlyInsideReactFlow, }: ContextAwareInputProps) => JSX.Element;
+export declare const ContextAwareInput: ({ input, isCurrentlyInsideReactFlow, }: ContextAwareInputProps) => JSX.Element | null;
 
 /**
  * Props for the ContextAwareInput component
@@ -1054,6 +1161,25 @@ export declare type Coordinate = {
     y: number;
 };
 
+/**
+ * Create a type-safe context value from concrete generic params.
+ *
+ * This is the single centralized point where generic variance on dispatch
+ * is bridged. React's createContext doesn't support generic type parameters,
+ * so providing a concrete FullGraphProps<'andGate', ...> to a context typed
+ * as FullGraphProps<string, ...> requires a variance bridge.
+ *
+ * Safety justification: context consumers dispatch actions using
+ * actionTypesMap constants which produce valid payloads regardless of
+ * the concrete generic params. The contravariance on dispatch is safe
+ * because all consumer dispatches originate from user interactions
+ * (right-click menu, group selector) that use the correct node type IDs.
+ */
+export declare function createContextValue(props: {
+    state: unknown;
+    dispatch: unknown;
+}, nodeRunnerStates?: ReadonlyMap<string, NodeRunnerState>, selectedStepRecord?: ExecutionStepRecord | null, edgeValuesAnimated?: boolean): React.ContextType<typeof FullGraphContext>;
+
 /**
  * Creates a context menu tree for adding nodes
  * @param typeOfNodes - The available node types
@@ -1105,6 +1231,8 @@ export declare type DataType<UnderlyingType extends SupportedUnderlyingTypes = S
     shape?: HandleShape;
     /** Whether this input allows direct user input */
     allowInput?: boolean;
+    /** Maximum number of connections for this data type */
+    maxConnections?: number;
 } : {
     /** Display name of the data type */
     name: string;
@@ -1118,8 +1246,23 @@ export declare type DataType<UnderlyingType extends SupportedUnderlyingTypes = S
     shape?: HandleShape;
     /** Whether this input allows direct user input */
     allowInput?: boolean;
+    /** Maximum number of connections for this data type */
+    maxConnections?: number;
 };
 
+/**
+ * Deserialize a serialized ExecutionRecord back to the original type.
+ * Converts all Record fields back to ReadonlyMaps and deserializes errors.
+ */
+export declare function deserializeExecutionRecord(obj: SerializedExecutionRecord): ExecutionRecord;
+
+/**
+ * Deserialize a serialized GraphError back to the original type.
+ * The `originalError` remains in its serialized form since the
+ * original Error instance cannot be reconstructed.
+ */
+export declare function deserializeGraphError(obj: SerializedGraphError): GraphError;
+
 /**
  * Array of edge changes for ReactFlow
  */
@@ -1130,6 +1273,245 @@ export declare type EdgeChanges = EdgeChange<ConfigurableEdgeState>[];
  */
 export declare type Edges = ConfigurableEdgeState[];
 
+/**
+ * Runtime context provided to every function implementation call.
+ * Contains node identity, graph state reference, and control signals.
+ */
+/**
+ * Runtime context passed to each function implementation.
+ *
+ * Non-generic to avoid contravariance: since FunctionImplementation takes
+ * context as a parameter (contravariant position), generic params here would
+ * make FunctionImplementations<ConcreteType> invariant — breaking assignment
+ * to FunctionImplementations<string>. Using default (widened) types for state
+ * keeps FunctionImplementations covariant in NodeTypeUniqueId.
+ */
+declare type ExecutionContext = {
+    /** Runtime node instance ID */
+    nodeId: string;
+    /** Node type ID from the type definitions */
+    nodeTypeId: string;
+    /** Display name of the node type */
+    nodeTypeName: string;
+    /** Read-only reference to the full graph state */
+    state: Readonly<State<string, string, SupportedUnderlyingTypes, z.ZodType>>;
+    /** Current loop iteration (only set when executing inside a loop body) */
+    loopIteration?: number;
+    /** Current group nesting depth (only set when executing inside a group) */
+    groupDepth?: number;
+    /** Signal for cooperative cancellation */
+    abortSignal: AbortSignal;
+};
+
+/**
+ * Complete recording of an execution run, containing all
+ * step records, timing data, errors, and loop/group records.
+ * Used by the timeline/replay UI to visualize execution history.
+ */
+declare type ExecutionRecord = {
+    /** Unique identifier for this execution run */
+    id: string;
+    /** Absolute start time (performance.now()) */
+    startTime: number;
+    /** Absolute end time (performance.now()) */
+    endTime: number;
+    /** Total execution duration (ms) — wall-clock time */
+    totalDuration: number;
+    /**
+     * Time spent warming up the JS engine before execution (ms).
+     * The first nodes in a session pay a JIT compilation cost; this
+     * warmup phase absorbs that cost so recorded step timings are accurate.
+     */
+    compilationDuration: number;
+    /**
+     * Total time spent paused during execution (ms).
+     * Only non-zero in step-by-step mode. Subtract from totalDuration
+     * to get execution-only duration.
+     */
+    totalPauseDuration: number;
+    /** Final status of the execution */
+    status: ExecutionRecordStatus;
+    /** All step records in execution order */
+    steps: ReadonlyArray<ExecutionStepRecord>;
+    /** All errors that occurred during execution */
+    errors: ReadonlyArray<GraphError>;
+    /** Timing data per concurrency level */
+    concurrencyLevels: ReadonlyArray<ConcurrencyLevelRecord>;
+    /** Loop execution recordings, keyed by loop structure ID */
+    loopRecords: ReadonlyMap<string, LoopRecord>;
+    /** Group execution recordings, keyed by group node instance ID */
+    groupRecords: ReadonlyMap<string, GroupRecord>;
+    /** Complete ValueStore snapshot at end of execution ("nodeId:handleId" -> value) */
+    finalValues: ReadonlyMap<string, unknown>;
+    /** UI preferences captured when the recording was saved */
+    viewState?: RecordingViewState;
+};
+
+declare type ExecutionRecordStatus = (typeof executionRecordStatuses)[number];
+
+declare const executionRecordStatuses: readonly ["completed", "errored", "cancelled"];
+
+export declare function ExecutionStepInspector({ stepRecord, onClose, loopRecords, hideComplexValues, debugMode, edgeValuesAnimated, onEdgeValuesAnimatedChange, }: ExecutionStepInspectorProps): JSX.Element | null;
+
+export declare type ExecutionStepInspectorProps = {
+    /** The step record to inspect (null to hide) */
+    stepRecord: ExecutionStepRecord | null;
+    /** Close the inspector */
+    onClose: () => void;
+    /** Loop records for enriched loop context display */
+    loopRecords?: ReadonlyMap<string, LoopRecord>;
+    /** Replace complex values with type summaries */
+    hideComplexValues?: boolean;
+    /** Show node IDs and handle IDs alongside display names */
+    debugMode?: boolean;
+    /** Whether edge values animate along the path or display statically */
+    edgeValuesAnimated?: boolean;
+    /** Called when the edge animation toggle changes */
+    onEdgeValuesAnimatedChange?: (animated: boolean) => void;
+};
+
+/**
+ * Recording of a single step's execution, including timing,
+ * input/output values, and any error that occurred.
+ */
+declare type ExecutionStepRecord = {
+    stepIndex: number;
+    nodeId: string;
+    nodeTypeId: string;
+    nodeTypeName: string;
+    concurrencyLevel: number;
+    /** Time relative to execution start (ms) */
+    startTime: number;
+    /** Time relative to execution start (ms) */
+    endTime: number;
+    /** Duration of this step (ms) */
+    duration: number;
+    /**
+     * Cumulative pause duration (ms) at the moment this step started.
+     * Subtract from startTime/endTime to get execution-only timestamps
+     * (removes user idle time from step-by-step mode).
+     * Always 0 in instant mode.
+     */
+    pauseAdjustment: number;
+    status: ExecutionStepRecordStatus;
+    /** Snapshot of resolved input values at execution time (handleName -> RecordedInputHandleValue) */
+    inputValues: ReadonlyMap<string, RecordedInputHandleValue>;
+    /** Snapshot of computed output values (handleName -> RecordedOutputHandleValue) */
+    outputValues: ReadonlyMap<string, RecordedOutputHandleValue>;
+    /** Error details (only when status === 'errored') */
+    error?: GraphError;
+    /** Loop iteration number (only when inside a loop body) */
+    loopIteration?: number;
+    /** Loop structure identifier (only when inside a loop body) */
+    loopStructureId?: string;
+    /** @deprecated Use hierarchical LoopIterationRecord.nestedLoopRecords instead */
+    parentLoopStructureId?: string;
+    /** @deprecated Use hierarchical LoopIterationRecord.nestedLoopRecords instead */
+    parentLoopIteration?: number;
+    /** Group node instance ID (only when inside a group scope) */
+    groupNodeId?: string;
+    /** Group nesting depth (only when inside a group scope) */
+    groupDepth?: number;
+    /**
+     * True when the step's duration was below timer resolution
+     * (performance.now() returned the same value for start and end).
+     * Displayed as "< 0.1ms" in the UI instead of an exact value.
+     */
+    estimatedTiming?: boolean;
+    /** Position within the loop iteration lifecycle. Determines vertical
+     *  ordering in the timeline and controls edge animation behavior. */
+    loopPhase?: LoopPhase;
+    /** For LoopStart steps: whether the input came from upstream nodes
+     *  (iteration 0) or from LoopStop feedback (iteration N>0).
+     *  Controls which edges animate and what the inspector shows. */
+    inputSource?: 'upstream' | 'feedback';
+};
+
+declare type ExecutionStepRecordStatus = (typeof executionStepRecordStatuses)[number];
+
+declare const executionStepRecordStatuses: readonly ["completed", "errored", "skipped"];
+
+export declare function ExecutionTimeline({ record, currentStepIndex, onScrubTo, onStepClick, selectedStepIndex, onNavigateToNode, }: ExecutionTimelineProps): JSX.Element;
+
+export declare type ExecutionTimelineProps = {
+    record: ExecutionRecord | null;
+    currentStepIndex: number;
+    onScrubTo: (stepIndex: number) => void;
+    onStepClick: (stepRecord: ExecutionStepRecord) => void;
+    selectedStepIndex: number | null;
+    /** Called when the user navigates to a node via prev/next buttons. */
+    onNavigateToNode?: (nodeId: string) => void;
+};
+
+/**
+ * JSON envelope for exported execution records.
+ * All ReadonlyMap fields are converted to plain objects,
+ * errors are serialized, and values are made JSON-safe.
+ */
+export declare type ExportedExecutionRecord = {
+    version: 1;
+    exportedAt: string;
+    record: Record<string, unknown>;
+};
+
+/**
+ * JSON envelope for exported graph state.
+ * The `state` field contains the serialized State with non-serializable
+ * fields stripped (complexSchema, onChange, etc.).
+ */
+export declare type ExportedGraphState = {
+    version: 1;
+    exportedAt: string;
+    state: Record<string, unknown>;
+};
+
+/**
+ * Export an execution record to a JSON string.
+ *
+ * Converts all ReadonlyMap fields to plain objects, serializes
+ * GraphError.originalError to a JSON-safe form, and safely
+ * serializes all unknown values (functions → placeholder strings).
+ *
+ * @param record - The execution record to export
+ * @param options - Export options (pretty-print, etc.)
+ * @returns JSON string of the exported record
+ *
+ * @example
+ * ```ts
+ * const json = exportExecutionRecord(record, { pretty: true });
+ * // Save to file, download, etc.
+ * ```
+ */
+export declare function exportExecutionRecord(record: ExecutionRecord, options?: ExportOptions): string;
+
+/**
+ * Export a graph state to a JSON string.
+ *
+ * Strips non-serializable fields:
+ * - `complexSchema` (Zod class instance) from dataTypes
+ * - `onChange` callbacks from handles
+ * - `complexSchema` from handle `dataType.dataTypeObject`
+ *
+ * @param state - The graph state to export
+ * @param options - Export options (pretty-print, etc.)
+ * @returns JSON string of the exported state
+ *
+ * @example
+ * ```ts
+ * const json = exportGraphState(state, { pretty: true });
+ * // Save to file, download, etc.
+ * ```
+ */
+export declare function exportGraphState<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(state: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>, options?: ExportOptions): string;
+
+/**
+ * Options for export functions.
+ */
+export declare type ExportOptions = {
+    /** Whether to pretty-print the JSON output (2-space indent) */
+    pretty?: boolean;
+};
+
 /**
  * Main graph editor component inspired by Blender's node editor
  *
@@ -1216,10 +1598,16 @@ export declare type Edges = ConfigurableEdgeState[];
  * }
  * ```
  */
-export declare function FullGraph<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>({ state, dispatch, }: FullGraphProps<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): JSX.Element;
+export declare function FullGraph<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>({ state, dispatch, functionImplementations, onStateImported, onRecordingImported, onImportError, executionRecord, onExecutionRecordChange, }: FullGraphProps<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): JSX.Element;
 
 export declare const FullGraphContext: Context<    {
 allProps: FullGraphProps;
+/** Optional map of nodeId -> runner visual state. Provided by useNodeRunner. */
+nodeRunnerStates?: ReadonlyMap<string, NodeRunnerState>;
+/** The currently inspected execution step record (when a timeline block is selected). */
+selectedStepRecord?: ExecutionStepRecord | null;
+/** Whether edge value display is animated (true) or static (false). */
+edgeValuesAnimated?: boolean;
 }>;
 
 /**
@@ -1237,6 +1625,50 @@ export declare type FullGraphProps<DataTypeUniqueId extends string = string, Nod
     dispatch: ActionDispatch<[
     action: Action<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>
     ]>;
+    functionImplementations?: FunctionImplementations<NodeTypeUniqueId>;
+    /** Called when state is successfully imported. Receives the raw parsed state. */
+    onStateImported?: (importedState: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>) => void;
+    /** Called when a recording is successfully imported. Receives the parsed ExecutionRecord. */
+    onRecordingImported?: (record: ExecutionRecord) => void;
+    /** Called when import validation fails. Receives the error messages. */
+    onImportError?: (errors: string[]) => void;
+    /** Controlled execution record. When provided, FullGraph uses this instead of internal state. */
+    executionRecord?: ExecutionRecord | null;
+    /** Called whenever the execution record changes (run completes, reset, load, etc.). */
+    onExecutionRecordChange?: (record: ExecutionRecord | null) => void;
+};
+
+/**
+ * A single node type's execution function.
+ *
+ * Receives resolved input values keyed by handle **name** and output handle
+ * metadata keyed by handle **name**. Returns a Map of output handle **names**
+ * to computed values.
+ *
+ * May return synchronously (Map) or asynchronously (Promise<Map>).
+ *
+ * @example
+ * ```ts
+ * const andGate: FunctionImplementation = (inputs, outputs, ctx) => {
+ *   const a = inputs.get('A')?.connections[0]?.value ?? false;
+ *   const b = inputs.get('B')?.connections[0]?.value ?? false;
+ *   return new Map([['Out', Boolean(a) && Boolean(b)]]);
+ * };
+ * ```
+ */
+declare type FunctionImplementation = (inputs: ReadonlyMap<string, InputHandleValue>, outputs: ReadonlyMap<string, OutputHandleInfo>, context: ExecutionContext) => Map<string, unknown> | Promise<Map<string, unknown>>;
+
+/**
+ * Map of node type IDs to their function implementations.
+ * Standard node types (loopStart, loopEnd, etc.) are excluded
+ * since they have built-in execution logic.
+ *
+ * Implementations are optional — missing implementations
+ * generate warnings at compile time and errors only if the node
+ * is actually reached during execution.
+ */
+declare type FunctionImplementations<NodeTypeUniqueId extends string = string> = {
+    [K in Exclude<NodeTypeUniqueId, (typeof standardNodeTypeNames)[number]>]?: FunctionImplementation;
 };
 
 /**
@@ -1295,11 +1727,80 @@ export declare function getDirectDependenciesOfNodeType<DataTypeUniqueId extends
  */
 export declare function getDirectDependentsOfNodeType<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(stateOrNodeToNodeDependents: Pick<State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>, 'typeOfNodes'> | Partial<Record<NodeTypeUniqueId, Set<NodeTypeUniqueId>>>, nodeType: NodeTypeUniqueId): Set<NodeTypeUniqueId>;
 
-export declare function getResultantDataTypeOfHandleConsideringInferredType<DataTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(handle: ConfigurableNodeInput<UnderlyingType, ComplexSchemaType, DataTypeUniqueId> | ConfigurableNodeOutput<UnderlyingType, ComplexSchemaType, DataTypeUniqueId> | undefined): {
+export declare function getResultantDataTypeOfHandleConsideringInferredType<DataTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(handle: ConfigurableNodeInput<UnderlyingType, ComplexSchemaType, DataTypeUniqueId> | ConfigurableNodeOutput<UnderlyingType, ComplexSchemaType, DataTypeUniqueId> | undefined, fallbackToInferFromConnectionTypeWhenNotInferred?: boolean): {
     dataTypeObject: DataType<UnderlyingType, ComplexSchemaType>;
     dataTypeUniqueId: DataTypeUniqueId;
 } | undefined;
 
+/**
+ * A rich error type capturing the full context of where and
+ * how an error occurred during graph execution.
+ *
+ * Includes the error message, the node that errored, the full
+ * execution path leading to it, and optional loop/group context.
+ */
+declare type GraphError = {
+    /** Human-readable error message */
+    message: string;
+    /** ID of the node where the error occurred */
+    nodeId: string;
+    /** Node type ID */
+    nodeTypeId: string;
+    /** Display name of the node type */
+    nodeTypeName: string;
+    /** Handle ID where the error manifested (if applicable) */
+    handleId?: string;
+    /** Ordered list of nodes in the execution path leading to this error */
+    path: ReadonlyArray<GraphErrorPathEntry>;
+    /** Loop context (if the error occurred inside a loop) */
+    loopContext?: {
+        loopStructureId: string;
+        iteration: number;
+        maxIterations: number;
+    };
+    /** Group context (if the error occurred inside a node group) */
+    groupContext?: {
+        groupNodeId: string;
+        groupNodeTypeId: string;
+        depth: number;
+    };
+    /** Timestamp when the error occurred (performance.now() relative to run start) */
+    timestamp: number;
+    /** Duration of the step before the error (ms) */
+    duration: number;
+    /** The original thrown error value */
+    originalError: unknown;
+};
+
+/**
+ * One entry in the error's execution path trace,
+ * showing the chain of nodes that led to the error.
+ */
+declare type GraphErrorPathEntry = {
+    nodeId: string;
+    nodeTypeId: string;
+    nodeTypeName: string;
+    handleId?: string;
+    concurrencyLevel: number;
+};
+
+export declare const groupNodeContextMenu: {
+    locationInContextMenu: string[];
+    priorityInContextMenu: number;
+};
+
+/**
+ * Recording of a node group's execution, containing
+ * the recursive inner execution record.
+ */
+declare type GroupRecord = {
+    groupNodeId: string;
+    groupNodeTypeId: string;
+    innerRecord: ExecutionRecord;
+    inputMapping: ReadonlyMap<string, unknown>;
+    outputMapping: ReadonlyMap<string, unknown>;
+};
+
 declare type HandleIndices = {
     type: 'input';
     index1: number;
@@ -1330,6 +1831,74 @@ export declare const handleShapesMap: {
     readonly parallelogram: "parallelogram";
 };
 
+/**
+ * Import an execution record from a JSON string.
+ *
+ * Validates the structure, applies any enabled repair strategies,
+ * and deserializes all Record fields back to ReadonlyMaps.
+ *
+ * @param json - The JSON string to import
+ * @param options - Import options (validation callbacks, repair strategies)
+ * @returns ImportResult with the deserialized ExecutionRecord or validation errors
+ *
+ * @example
+ * ```ts
+ * const result = importExecutionRecord(json, {
+ *   onValidationError: (issue) => console.warn(issue),
+ *   repair: { sanitizeNonSerializableValues: true },
+ * });
+ *
+ * if (result.success) {
+ *   // Use result.data as ExecutionRecord
+ * } else {
+ *   // Handle result.errors
+ * }
+ * ```
+ */
+export declare function importExecutionRecord(json: string, options?: RecordImportOptions): ImportResult<ExecutionRecord>;
+
+/**
+ * Import a graph state from a JSON string.
+ *
+ * Validates the structure, applies any enabled repair strategies,
+ * and rehydrates non-serializable fields (complexSchema, dataTypeObject)
+ * from the user-provided `dataTypes` and `typeOfNodes`.
+ *
+ * @param json - The JSON string to import
+ * @param options - Import options including dataTypes/typeOfNodes for rehydration
+ * @returns ImportResult with the rehydrated State or validation errors
+ *
+ * @example
+ * ```ts
+ * const result = importGraphState(json, {
+ *   dataTypes: myDataTypes,
+ *   typeOfNodes: myTypeOfNodes,
+ *   onValidationError: (issue) => console.warn(issue),
+ *   repair: { removeOrphanEdges: true, fillMissingDefaults: true },
+ * });
+ *
+ * if (result.success) {
+ *   // Use result.data as State
+ * } else {
+ *   // Handle result.errors
+ * }
+ * ```
+ */
+export declare function importGraphState<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(json: string, options: StateImportOptions<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): ImportResult<State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>>;
+
+/**
+ * Result of an import operation. Discriminated union on `success`.
+ */
+export declare type ImportResult<T> = {
+    success: true;
+    data: T;
+    warnings: ValidationIssue[];
+} | {
+    success: false;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+};
+
 /**
  * The Input component
  * - Allows the user to input a string or a number, with the ability to only allow numbers
@@ -1338,6 +1907,58 @@ export declare const handleShapesMap: {
  */
 export declare const Input: ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>;
 
+/**
+ * Represents a single incoming connection to an input handle,
+ * carrying the value produced by the source and full metadata
+ * about which node and handle it came from.
+ */
+declare type InputConnectionValue = {
+    /** The value produced by the source output handle */
+    value: unknown;
+    /** Source node instance ID */
+    sourceNodeId: string;
+    /** Source node display name (from typeOfNodes) */
+    sourceNodeName: string;
+    /** Source node type ID (key in typeOfNodes) */
+    sourceNodeTypeId: string;
+    /** Source output handle ID (unique per node instance) */
+    sourceHandleId: string;
+    /** Source output handle display name */
+    sourceHandleName: string;
+    /** Source output handle data type ID */
+    sourceDataTypeId: string;
+    /** Edge ID connecting source to target */
+    edgeId: string;
+};
+
+/**
+ * Represents the resolved connections and metadata for a single input
+ * handle during execution. The map key in `FunctionImplementation` is
+ * the handle's **name** from the node type definition.
+ *
+ * `connections` is **always** an array — even for single connections:
+ * - 1 incoming edge → `connections` has 1 entry
+ * - N incoming edges (fan-in) → `connections` has N entries
+ * - No edges → `connections` is empty, `isDefault` is true
+ *
+ * For default (unconnected) inputs with `allowInput`, the user-entered
+ * value is available in `defaultValue`.
+ */
+declare type InputHandleValue = {
+    /** All incoming connection values — always an array, one entry per edge */
+    connections: ReadonlyArray<InputConnectionValue>;
+    /** Runtime handle ID (unique per node instance) */
+    handleId: string;
+    /** Display name from the node type definition */
+    handleName: string;
+    /** Data type unique ID for this handle */
+    dataTypeId: string;
+    /** True when no edges exist — value comes from user-entered default */
+    isDefault: boolean;
+    /** The user-entered default value (only meaningful when isDefault is true) */
+    defaultValue?: unknown;
+};
+
 /**
  * Props for the Input component
  */
@@ -1454,6 +2075,54 @@ export declare function isSupportedUnderlyingType(type: string): type is Support
  */
 export declare function isValidDataTypeId<DataTypeUniqueId extends string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(id: string, dataTypes: Record<DataTypeUniqueId, DataType<UnderlyingType, ComplexSchemaType>>): id is DataTypeUniqueId;
 
+export declare const loopEndInputInferHandleIndex = 1;
+
+export declare const loopEndOutputInferHandleIndex = 0;
+
+/**
+ * Recording of a single loop iteration.
+ */
+declare type LoopIterationRecord = {
+    iteration: number;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    conditionValue: boolean;
+    stepRecords: ReadonlyArray<ExecutionStepRecord>;
+    /** Loop records for nested loops that executed within this iteration. */
+    nestedLoopRecords: ReadonlyMap<string, LoopRecord>;
+};
+
+/**
+ * Phases within a single loop iteration lifecycle.
+ * Used for deterministic ordering in the timeline and controlling
+ * edge animation behavior.
+ */
+declare type LoopPhase = 'loopStart' | 'preStop' | 'loopStop' | 'postStop' | 'loopEnd';
+
+/**
+ * Complete recording of a loop structure's execution.
+ */
+declare type LoopRecord = {
+    loopStructureId: string;
+    loopStartNodeId: string;
+    loopStopNodeId: string;
+    loopEndNodeId: string;
+    iterations: ReadonlyArray<LoopIterationRecord>;
+    totalIterations: number;
+    startTime: number;
+    endTime: number;
+    duration: number;
+};
+
+export declare const loopStartInputInferHandleIndex = 0;
+
+export declare const loopStartOutputInferHandleIndex = 1;
+
+export declare const loopStopInputInferHandleIndex = 2;
+
+export declare const loopStopOutputInferHandleIndex = 1;
+
 /**
  * Main reducer function for managing graph state
  *
@@ -1665,6 +2334,11 @@ export declare function makeStateWithAutoInfer<DataTypeUniqueId extends string =
  */
 export declare function makeTypeOfNodeWithAutoInfer<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(input: TypeOfNode<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): TypeOfNode<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>;
 
+/**
+ * Convert a ReadonlyMap to a plain Record for JSON serialization.
+ */
+export declare function mapToRecord<T>(map: ReadonlyMap<string, T>): Record<string, T>;
+
 /**
  * Array of node changes for ReactFlow
  */
@@ -1737,15 +2411,80 @@ export declare type NodeResizerWithMoreControlsProps = NodeResizerProps & {
     resizeDirection?: ResizeControlDirection;
 };
 
+/**
+ * Per-node runner state provided via context so the ReactFlow wrapper
+ * can apply visual indicators without prop drilling.
+ */
+export declare type NodeRunnerState = {
+    visualState: NodeVisualState;
+    errors?: ReadonlyArray<GraphError>;
+    warnings?: ReadonlyArray<string>;
+};
+
 /**
  * Array of configurable nodes in the graph
  */
 export declare type Nodes<UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, NodeTypeUniqueId extends string = string, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never, DataTypeUniqueId extends string = string> = Optional<ConfigurableNodeReactFlowWrapperProps<UnderlyingType, NodeTypeUniqueId, ComplexSchemaType, DataTypeUniqueId>, NodeOptionalKeys>[];
 
+/**
+ * Outline overlay and icon indicator for a node's execution state.
+ * Uses CSS `outline` (not `border`) so the indicator never affects
+ * the node's layout or size.
+ *
+ * Visual states:
+ * - `idle`: No visual change
+ * - `running`: Dashed blue outline with breathing glow
+ * - `completed`: Solid green outline (persists)
+ * - `errored`: Solid red outline + AlertCircle icon with error tooltip
+ * - `skipped`: Dimmed opacity, dashed gray outline
+ * - `warning`: Solid orange outline + AlertTriangle icon with warning tooltip
+ */
+export declare function NodeStatusIndicator({ visualState, errors, warnings, children, }: NodeStatusIndicatorProps): JSX.Element;
+
+/**
+ * Props for the NodeStatusIndicator component.
+ *
+ * Renders a border overlay and optional icon on top of a node
+ * to indicate its execution visual state.
+ */
+export declare type NodeStatusIndicatorProps = {
+    /** Current visual state of the node */
+    visualState: NodeVisualState;
+    /** Errors associated with this node (shown on hover when errored) */
+    errors?: ReadonlyArray<GraphError>;
+    /** Warning messages (shown on hover when warning) */
+    warnings?: ReadonlyArray<string>;
+    /** The node content to wrap */
+    children: ReactNode;
+};
+
+declare type NodeVisualState = (typeof nodeVisualStates)[number];
+
+declare const nodeVisualStates: readonly ["idle", "running", "completed", "errored", "skipped", "warning"];
+
 declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
 
 declare type Orientation = 'horizontal' | 'vertical';
 
+/**
+ * Metadata about a single output handle, passed to the function
+ * implementation so it knows what outputs to produce.
+ */
+declare type OutputHandleInfo = {
+    /** Runtime handle ID (unique per node instance) */
+    handleId: string;
+    /** Display name from the node type definition */
+    handleName: string;
+    /** Data type unique ID for this handle */
+    dataTypeId: string;
+    /** All edges consuming this output handle's value */
+    connections: ReadonlyArray<{
+        targetNodeId: string;
+        targetHandleId: string;
+        edgeId: string;
+    }>;
+};
+
 /**
  * ReactFlow-aware input component that automatically updates node data
  *
@@ -1756,7 +2495,7 @@ declare type Orientation = 'horizontal' | 'vertical';
  * @param props - The component props
  * @returns JSX element containing the appropriate input component
  */
-export declare const ReactFlowAwareInput: ({ input }: ReactFlowAwareInputProps) => JSX.Element;
+export declare const ReactFlowAwareInput: ({ input }: ReactFlowAwareInputProps) => JSX.Element | null;
 
 /**
  * Props for the ReactFlowAwareInput component
@@ -1782,6 +2521,114 @@ export declare const ReactFlowAwareOpenButton: ({}: ReactFlowAwareOpenButtonProp
  */
 export declare type ReactFlowAwareOpenButtonProps = {};
 
+export declare const RecordContext: Context<RecordContextValue>;
+
+declare type RecordContextValue = {
+    executionRecord: ExecutionRecord | null;
+    setExecutionRecord: (record: ExecutionRecord | null) => void;
+};
+
+/**
+ * Recorded snapshot of a single incoming connection to an input handle.
+ * Contains the value and source metadata for display in the inspector.
+ */
+declare type RecordedInputConnection = {
+    /** The value that arrived through this connection */
+    value: unknown;
+    /** Source node instance ID */
+    sourceNodeId: string;
+    /** Source node display name */
+    sourceNodeName: string;
+    /** Source output handle ID */
+    sourceHandleId: string;
+    /** Source output handle display name */
+    sourceHandleName: string;
+    /** Source output handle data type ID */
+    sourceDataTypeId: string;
+};
+
+/**
+ * Recorded snapshot of an input handle's resolved state.
+ * Contains per-connection detail for the inspector to display
+ * each connection on its own line with source node/handle names.
+ */
+declare type RecordedInputHandleValue = {
+    /** All incoming connections — always an array, one per edge */
+    connections: ReadonlyArray<RecordedInputConnection>;
+    /** Data type unique ID for this input handle */
+    dataTypeId: string;
+    /** True when no edges exist — value came from user-entered default */
+    isDefault: boolean;
+    /** The user-entered default value (only when isDefault is true) */
+    defaultValue?: unknown;
+};
+
+/**
+ * Recorded snapshot of an output handle's computed value.
+ */
+declare type RecordedOutputHandleValue = {
+    /** The computed value for this output handle */
+    value: unknown;
+    /** Data type unique ID for this output handle */
+    dataTypeId: string;
+    /** Number of target nodes consuming this output (fan-out count) */
+    targetCount: number;
+};
+
+/**
+ * Options for importing execution records.
+ */
+export declare type RecordImportOptions = {
+    /** Called for each validation issue found during import */
+    onValidationError?: (issue: ValidationIssue) => void;
+    /** Repair strategies to apply (all default to false) */
+    repair?: Partial<RecordRepairStrategies>;
+};
+
+/**
+ * Captures the UI state of the timeline and runner panel at the time
+ * a recording is saved. All fields are optional so older recordings
+ * without viewState still load correctly.
+ */
+declare type RecordingViewState = {
+    /** Currently selected step index in the timeline (null = none) */
+    selectedStepIndex?: number | null;
+    /** Whether edge value badges animate along the path */
+    edgeValuesAnimated?: boolean;
+    /** Whether the auto-scroll (timeline + canvas) toggle is on */
+    autoScroll?: boolean;
+    /** Run mode used for this recording */
+    runMode?: 'instant' | 'stepByStep';
+    /** Max loop iterations setting */
+    maxLoopIterations?: number;
+    /** Whether the runner panel drawer is open */
+    panelOpen?: boolean;
+    /** Timeline time-mode toggle */
+    timeMode?: 'execution' | 'wallClock';
+    /** Timeline collapsed state */
+    timelineCollapsed?: boolean;
+    /** Which loop iterations are expanded (loopStructureId → iteration index) */
+    selectedIterations?: Record<string, number>;
+    /** Autoplay interval in seconds */
+    autoplayIntervalSec?: number;
+};
+
+/**
+ * Opt-in repair strategies for execution record import.
+ * All default to `false` — must be explicitly enabled.
+ */
+export declare type RecordRepairStrategies = {
+    /** Replace non-serializable step values with "[non-serializable]" */
+    sanitizeNonSerializableValues: boolean;
+    /** Remove steps referencing nodes not present in the record */
+    removeOrphanSteps: boolean;
+};
+
+/**
+ * Convert a plain Record back to a ReadonlyMap.
+ */
+export declare function recordToReadonlyMap<T>(obj: Record<string, T> | null | undefined): ReadonlyMap<string, T>;
+
 /**
  * Removes an edge between two handles with type checking and inference
  *
@@ -1811,6 +2658,59 @@ export declare function removeEdgeWithTypeChecking<DataTypeUniqueId extends stri
     validation: ConnectionValidationResult;
 };
 
+/**
+ * Control bar for running/debugging the graph.
+ *
+ * Layout:
+ * ```
+ * ● Status | [▶] [⏸] [⏭] [⏹] [↺] | [Instant/Step] | Max loops: [100]
+ * ```
+ */
+export declare function RunControls({ runnerState, onRun, onPause, onStep, onStop, onReset, mode, onModeChange, maxLoopIterations, onMaxLoopIterationsChange, }: RunControlsProps): JSX.Element;
+
+/**
+ * Props for the RunControls component.
+ */
+export declare type RunControlsProps = {
+    /** Current runner state machine state */
+    runnerState: RunnerState;
+    /** Start or resume execution */
+    onRun: () => void;
+    /** Pause a running execution */
+    onPause: () => void;
+    /** Execute one step forward (starts step-by-step if idle) */
+    onStep: () => void;
+    /** Stop and cancel execution */
+    onStop: () => void;
+    /** Reset runner back to idle */
+    onReset: () => void;
+    /** Current execution mode */
+    mode: RunMode;
+    /** Change execution mode */
+    onModeChange: (mode: RunMode) => void;
+    /** Max loop iterations before error */
+    maxLoopIterations: number;
+    /** Update max loop iterations */
+    onMaxLoopIterationsChange: (max: number) => void;
+};
+
+/**
+ * Execution mode: instant runs the whole graph then enables replay,
+ * stepByStep pauses between each execution step.
+ */
+export declare type RunMode = 'instant' | 'stepByStep';
+
+declare type RunnerState = (typeof runnerStates)[number];
+
+declare const runnerStates: readonly ["idle", "compiling", "running", "paused", "completed", "errored"];
+
+/**
+ * Safely serialize a value for JSON. Primitives, plain objects, and arrays
+ * pass through unchanged. Functions, symbols, and other non-serializable
+ * values are replaced with a placeholder string.
+ */
+export declare function safeSerializeValue(value: unknown): unknown;
+
 /**
  * Sanitizes a number to be shown as a text, removing the trailing zeros after the decimal point if the number is an integer
  * @param value - The number to sanitize
@@ -2097,6 +2997,65 @@ export declare const SelectValue: ForwardRefExoticComponent<Omit<SelectPrimitive
  */
 export declare type SelectValueProps = React.ComponentPropsWithoutRef<typeof SelectPrimitive.Value>;
 
+declare type SerializedExecutionRecord = Omit<ExecutionRecord, 'steps' | 'errors' | 'loopRecords' | 'groupRecords' | 'finalValues' | 'concurrencyLevels'> & {
+    steps: ReadonlyArray<SerializedStepRecord>;
+    errors: ReadonlyArray<SerializedGraphError>;
+    concurrencyLevels: ReadonlyArray<ConcurrencyLevelRecord>;
+    loopRecords: Record<string, SerializedLoopRecord>;
+    groupRecords: Record<string, SerializedGroupRecord>;
+    finalValues: Record<string, unknown>;
+};
+
+/** Serialized form of a GraphError (JSON-safe). */
+declare type SerializedGraphError = Omit<GraphError, 'originalError' | 'path'> & {
+    originalError: unknown;
+    path: ReadonlyArray<GraphErrorPathEntry>;
+};
+
+declare type SerializedGroupRecord = Omit<GroupRecord, 'innerRecord' | 'inputMapping' | 'outputMapping'> & {
+    innerRecord: SerializedExecutionRecord;
+    inputMapping: Record<string, unknown>;
+    outputMapping: Record<string, unknown>;
+};
+
+declare type SerializedLoopIterationRecord = Omit<LoopIterationRecord, 'stepRecords' | 'nestedLoopRecords'> & {
+    stepRecords: ReadonlyArray<SerializedStepRecord>;
+    nestedLoopRecords?: Record<string, SerializedLoopRecord>;
+};
+
+declare type SerializedLoopRecord = Omit<LoopRecord, 'iterations'> & {
+    iterations: ReadonlyArray<SerializedLoopIterationRecord>;
+};
+
+declare type SerializedRecordedInputHandleValue = Omit<RecordedInputHandleValue, 'connections'> & {
+    connections: ReadonlyArray<RecordedInputConnection>;
+    defaultValue?: unknown;
+};
+
+declare type SerializedRecordedOutputHandleValue = Omit<RecordedOutputHandleValue, 'value'> & {
+    value: unknown;
+};
+
+declare type SerializedStepRecord = Omit<ExecutionStepRecord, 'inputValues' | 'outputValues' | 'error'> & {
+    inputValues: Record<string, SerializedRecordedInputHandleValue>;
+    outputValues: Record<string, SerializedRecordedOutputHandleValue>;
+    error?: SerializedGraphError;
+};
+
+/**
+ * Serialize an ExecutionRecord to a JSON-safe plain object.
+ * Converts all ReadonlyMap fields to Records, serializes errors,
+ * and safely serializes all values. Handles recursive GroupRecords.
+ */
+export declare function serializeExecutionRecord(record: ExecutionRecord): SerializedExecutionRecord;
+
+/**
+ * Serialize a GraphError to a JSON-safe form.
+ * `originalError` (which can be an Error object or anything) is
+ * converted to a structured JSON-safe representation.
+ */
+export declare function serializeGraphError(err: GraphError): SerializedGraphError;
+
 export declare function setCurrentNodesAndEdgesToStateWithMutatingState<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(state: Pick<State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>, 'nodes' | 'edges' | 'typeOfNodes' | 'openedNodeGroupStack' | 'dataTypes'>, nodes?: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>['nodes'], edges?: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>['edges']): State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>;
 
 /**
@@ -2146,6 +3105,17 @@ export declare function setCurrentNodesAndEdgesToStateWithMutatingState<DataType
  *   min={0}
  *   max={1000}
  * />
+ *
+ * // Small variant for toolbars
+ * <SliderNumberInput
+ *   name="Interval"
+ *   value={1}
+ *   min={0.5}
+ *   max={30}
+ *   step={0.5}
+ *   size="small"
+ *   onChange={(value) => setInterval(value)}
+ * />
  * ```
  */
 export declare const SliderNumberInput: ForwardRefExoticComponent<SliderNumberInputProps & RefAttributes<HTMLInputElement & HTMLDivElement>>;
@@ -2168,44 +3138,81 @@ export declare type SliderNumberInputProps = {
     max?: number;
     /** Step size for value changes */
     step?: number;
+    /** Size variant. "normal" is the canvas-friendly default, "small" is compact for toolbars. */
+    size?: 'normal' | 'small';
+    /** Number of decimal places to display (default: 4 for normal, 1 for small) */
+    decimals?: number;
 };
 
-export declare const standardDataTypeNames: readonly ["newGroupInput", "newGroupOutput"];
+export declare const standardDataTypeNames: readonly ["groupInfer", "loopInfer", "condition", "bindLoopNodes"];
 
 export declare const standardDataTypeNamesMap: {
-    readonly newGroupInput: "newGroupInput";
-    readonly newGroupOutput: "newGroupOutput";
+    readonly groupInfer: "groupInfer";
+    readonly loopInfer: "loopInfer";
+    readonly condition: "condition";
+    readonly bindLoopNodes: "bindLoopNodes";
 };
 
 export declare const standardDataTypes: {
-    newGroupInput: {
+    readonly groupInfer: {
         name: string;
         underlyingType: "inferFromConnection";
         complexSchema?: undefined;
         color: string;
         shape?: HandleShape_2;
         allowInput?: boolean;
+        maxConnections?: number;
     };
-    newGroupOutput: {
+    readonly loopInfer: {
         name: string;
         underlyingType: "inferFromConnection";
         complexSchema?: undefined;
         color: string;
         shape?: HandleShape_2;
         allowInput?: boolean;
+        maxConnections?: number;
+    };
+    readonly condition: {
+        name: string;
+        underlyingType: "boolean";
+        complexSchema?: undefined;
+        color: string;
+        shape?: HandleShape_2;
+        allowInput?: boolean;
+        maxConnections?: number;
     };
+    readonly bindLoopNodes: {
+        name: string;
+        underlyingType: "noEquivalent";
+        complexSchema?: undefined;
+        color: string;
+        shape?: HandleShape_2;
+        allowInput?: boolean;
+        maxConnections?: number;
+    };
+};
+
+export declare const standardNodeContextMenu: {
+    locationInContextMenu: string[];
+    priorityInContextMenu: number;
 };
 
-export declare const standardNodeTypeNames: readonly ["groupInput", "groupOutput"];
+export declare const standardNodeTypeNames: readonly ["groupInput", "groupOutput", "loopStart", "loopEnd", "loopStop"];
 
 export declare const standardNodeTypeNamesMap: {
     readonly groupInput: "groupInput";
     readonly groupOutput: "groupOutput";
+    readonly loopStart: "loopStart";
+    readonly loopEnd: "loopEnd";
+    readonly loopStop: "loopStop";
 };
 
 export declare const standardNodeTypes: {
-    groupInput: TypeOfNode_2<"newGroupInput" | "newGroupOutput", string, "string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", never>;
-    groupOutput: TypeOfNode_2<"newGroupInput" | "newGroupOutput", string, "string" | "number" | "complex" | "noEquivalent" | "inferFromConnection", never>;
+    groupInput: TypeOfNode_2<"groupInfer" | "loopInfer" | "condition" | "bindLoopNodes", "groupInput", "string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never>;
+    groupOutput: TypeOfNode_2<"groupInfer" | "loopInfer" | "condition" | "bindLoopNodes", "groupOutput", "string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never>;
+    loopStart: TypeOfNode_2<"groupInfer" | "loopInfer" | "condition" | "bindLoopNodes", "loopStart", "string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never>;
+    loopStop: TypeOfNode_2<"groupInfer" | "loopInfer" | "condition" | "bindLoopNodes", "loopStop", "string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never>;
+    loopEnd: TypeOfNode_2<"groupInfer" | "loopInfer" | "condition" | "bindLoopNodes", "loopEnd", "string" | "number" | "boolean" | "complex" | "noEquivalent" | "inferFromConnection", never>;
 };
 
 /**
@@ -2295,6 +3302,50 @@ export declare type State<DataTypeUniqueId extends string = string, NodeTypeUniq
      * @default undefined
      */
     enableRecursionChecking?: boolean;
+    /**
+     * Whether to enable debugging mode
+     * - If not provided, is considered disabled
+     * - When disabled, no debug information is displayed in the graph
+     * - When enabled, debug information is displayed in the graph
+     *
+     * @default undefined
+     */
+    enableDebugMode?: boolean;
+};
+
+/**
+ * Options for importing graph state.
+ *
+ * `dataTypes` and `typeOfNodes` are required so the importer can
+ * rehydrate Zod schemas and handle dataTypeObjects that were stripped
+ * during export.
+ */
+export declare type StateImportOptions<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never> = {
+    /** User-provided data type definitions (source of truth for Zod schemas) */
+    dataTypes: Record<DataTypeUniqueId, DataType<UnderlyingType, ComplexSchemaType>>;
+    /** User-provided node type definitions (source of truth for handle structure) */
+    typeOfNodes: Record<NodeTypeUniqueId, TypeOfNode<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>>;
+    /** Called for each validation issue found during import */
+    onValidationError?: (issue: ValidationIssue) => void;
+    /** Repair strategies to apply (all default to false) */
+    repair?: Partial<StateRepairStrategies>;
+};
+
+/**
+ * Opt-in repair strategies for state import.
+ * All default to `false` — must be explicitly enabled.
+ */
+export declare type StateRepairStrategies = {
+    /** Remove edges whose source or target node doesn't exist */
+    removeOrphanEdges: boolean;
+    /** Deduplicate nodes with the same ID (keep first occurrence) */
+    removeDuplicateNodeIds: boolean;
+    /** Deduplicate edges with the same ID (keep first occurrence) */
+    removeDuplicateEdgeIds: boolean;
+    /** Fill missing optional fields (viewport, feature flags) with defaults */
+    fillMissingDefaults: boolean;
+    /** Rebuild handle dataType.dataTypeObject from provided dataTypes */
+    rehydrateDataTypeObjects: boolean;
 };
 
 /**
@@ -2305,7 +3356,7 @@ export declare type SupportedUnderlyingTypes = (typeof supportedUnderlyingTypes)
 /**
  * Array of supported underlying data types
  */
-declare const supportedUnderlyingTypes: readonly ["string", "number", "complex", "noEquivalent", "inferFromConnection"];
+declare const supportedUnderlyingTypes: readonly ["string", "number", "boolean", "complex", "noEquivalent", "inferFromConnection"];
 
 /**
  * Map of supported underlying types for type checking
@@ -2313,11 +3364,35 @@ declare const supportedUnderlyingTypes: readonly ["string", "number", "complex",
 export declare const supportedUnderlyingTypesMap: {
     readonly string: "string";
     readonly number: "number";
+    readonly boolean: "boolean";
     readonly complex: "complex";
     readonly noEquivalent: "noEquivalent";
     readonly inferFromConnection: "inferFromConnection";
 };
 
+export declare function Tooltip({ content, children, infoIcon, placement, maxWidth, className, style, as: Tag, triggerProps, }: TooltipProps): JSX.Element;
+
+export declare type TooltipProps = {
+    /** Tooltip content — string or ReactNode */
+    content: ReactNode;
+    /** Trigger element(s) */
+    children: ReactNode;
+    /** Show an ⓘ icon next to the trigger @default false */
+    infoIcon?: boolean;
+    /** Tooltip placement @default 'bottom' */
+    placement?: Placement;
+    /** Max width of the tooltip @default 240 */
+    maxWidth?: number;
+    /** Additional className for the trigger wrapper */
+    className?: string;
+    /** Inline style for the trigger wrapper (useful for absolute positioning) */
+    style?: CSSProperties;
+    /** Render the wrapper as a different element @default 'span' */
+    as?: 'span' | 'div' | ComponentType<HTMLAttributes<HTMLElement>>;
+    /** Extra props forwarded to the trigger wrapper (e.g. data-*, onClick) */
+    triggerProps?: HTMLAttributes<HTMLElement>;
+};
+
 /**
  * Definition of an input type in a node
  *
@@ -2330,6 +3405,8 @@ export declare type TypeOfInput<DataTypeUniqueId extends string = string> = {
     dataType: DataTypeUniqueId;
     /** Whether this input allows direct user input */
     allowInput?: boolean;
+    /** Maximum number of connections for this input */
+    maxConnections?: number;
 };
 
 /**
@@ -2358,6 +3435,11 @@ export declare type TypeOfNode<DataTypeUniqueId extends string = string, NodeTyp
     inputs: (TypeOfInput<DataTypeUniqueId> | TypeOfInputPanel<DataTypeUniqueId>)[];
     /** Array of outputs */
     outputs: TypeOfInput<DataTypeUniqueId>[];
+    /** Path in the "Add Node" context menu. e.g. ["Math", "Trig"] nests under Math > Trig.
+     * Omit to place at root level of "Add Node". */
+    locationInContextMenu?: string[];
+    /** Ordering priority in the context menu. Higher values appear first. Default: 0. */
+    priorityInContextMenu?: number;
     /** Subtree of the node type (if this exists, this is a node group) */
     subtree?: {
         nodes: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>['nodes'];
@@ -2382,6 +3464,40 @@ export declare type TypeOfNode<DataTypeUniqueId extends string = string, NodeTyp
     };
 };
 
+/**
+ * Manages overflow-scroll state detection and RAF-based auto-scrolling.
+ *
+ * Tracks whether the container can scroll in each direction via
+ * scroll events, ResizeObserver, window resize, and optional
+ * MutationObserver on children. Provides start/stop controls for
+ * continuous scrolling driven by requestAnimationFrame.
+ */
+export declare function useAutoScroll({ orientation, disabled, scrollSpeedPxPerFrame, observeChildren, }?: UseAutoScrollOptions): UseAutoScrollReturn;
+
+export declare type UseAutoScrollOptions = {
+    /** Scroll axis @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical';
+    /** Disable all scroll detection and auto-scrolling @default false */
+    disabled?: boolean;
+    /** Pixels scrolled per animation frame @default 14 */
+    scrollSpeedPxPerFrame?: number;
+    /** Watch for child DOM mutations to recalculate scroll state @default true */
+    observeChildren?: boolean;
+};
+
+export declare type UseAutoScrollReturn = {
+    /** Ref to attach to the scrollable container element */
+    listRef: React.RefObject<HTMLDivElement | null>;
+    /** Whether content overflows at the start (left / top) */
+    canScrollStart: boolean;
+    /** Whether content overflows at the end (right / bottom) */
+    canScrollEnd: boolean;
+    /** Begin continuous scrolling in a direction (call on button press) */
+    startAutoScroll: (direction: 'start' | 'end') => void;
+    /** Stop continuous scrolling (call on button release) */
+    stopAutoScroll: () => void;
+};
+
 /**
  * Custom hook for detecting clicks outside of a specified element
  *
@@ -2480,6 +3596,67 @@ export declare type UseDragReturn = {
     dragRef: (element: HTMLElement | null) => void;
 };
 
+/**
+ * Consolidates the common floating-ui tooltip boilerplate:
+ * useFloating + useHover + useDismiss + useInteractions + useTransitionStyles + arrow.
+ *
+ * This pattern is repeated across NodeStatusIndicator (StatusTooltip),
+ * ExecutionTimeline (BlockTooltip, TimeModeInfoTooltip), and potentially
+ * future tooltip-like components.
+ */
+export declare function useFloatingTooltip({ placement, offsetPx, hoverDelay, transitionDuration, withArrow, initialTransition, }?: UseFloatingTooltipOptions): {
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+    refs: {
+        reference: MutableRefObject<ReferenceType_2 | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: ReferenceType_2 | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & ExtendedRefs<ReferenceType>;
+    floatingStyles: CSSProperties;
+    context: {
+        x: number;
+        y: number;
+        strategy: Strategy;
+        placement: Placement;
+        middlewareData: MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: OpenChangeReason) => void;
+        events: FloatingEvents;
+        dataRef: React.MutableRefObject<ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: ExtendedRefs<ReferenceType>;
+        elements: ExtendedElements<ReferenceType>;
+    };
+    arrowRef: RefObject<SVGSVGElement | null>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    isMounted: boolean;
+    transitionStyles: CSSProperties;
+};
+
+export declare type UseFloatingTooltipOptions = {
+    /** Tooltip placement relative to the reference element @default 'top' */
+    placement?: Placement;
+    /** Offset distance in pixels @default 10 */
+    offsetPx?: number;
+    /** Hover delay in ms @default { open: 150, close: 0 } */
+    hoverDelay?: {
+        open: number;
+        close: number;
+    };
+    /** Enter/exit transition duration in ms @default 150 */
+    transitionDuration?: number;
+    /** Whether to include an arrow element @default true */
+    withArrow?: boolean;
+    /** Initial transition style @default { opacity: 0, transform: 'translateY(4px)' } */
+    initialTransition?: React.CSSProperties;
+};
+
 /**
  * Custom hook for managing the full graph state with reducer
  *
@@ -2548,9 +3725,95 @@ export declare type UseDragReturn = {
  * });
  * ```
  */
-export declare function useFullGraph<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? z.ZodType : never = never>(initialState: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): {
+export declare function useFullGraph<DataTypeUniqueId extends string = string, NodeTypeUniqueId extends string = string, UnderlyingType extends SupportedUnderlyingTypes = SupportedUnderlyingTypes, ComplexSchemaType extends UnderlyingType extends 'complex' ? default_2.ZodType : never = never>(initialState: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>): {
     state: State<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>;
-    dispatch: ActionDispatch<[action: Action<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>]>;
+    dispatch: ActionDispatch<[action: Action_2<DataTypeUniqueId, NodeTypeUniqueId, UnderlyingType, ComplexSchemaType>]>;
+};
+
+export declare function useRecordContext(): RecordContextValue;
+
+/**
+ * Hook for drag-to-resize a panel dimension.
+ *
+ * Handles mousedown → mousemove → mouseup lifecycle with clamping,
+ * cursor override, and user-select prevention during drag.
+ */
+export declare function useResizeHandle({ initialSize, minSize, maxSize, direction, }: UseResizeHandleOptions): UseResizeHandleReturn;
+
+export declare type UseResizeHandleOptions = {
+    /** Starting height/width in pixels */
+    initialSize: number;
+    /** Minimum allowed size */
+    minSize: number;
+    /** Maximum allowed size */
+    maxSize: number;
+    /**
+     * Resize direction.
+     * - 'up': dragging up increases size (bottom panel resized from top edge)
+     * - 'down': dragging down increases size
+     * - 'left': dragging left increases size
+     * - 'right': dragging right increases size
+     * @default 'up'
+     */
+    direction?: 'up' | 'down' | 'left' | 'right';
+};
+
+export declare type UseResizeHandleReturn = {
+    /** Current size in pixels */
+    size: number;
+    /** Attach to onMouseDown of the resize handle element */
+    onMouseDown: (e: React.MouseEvent) => void;
+};
+
+/**
+ * Web Animations API-based mount/unmount lifecycle for slide animations.
+ *
+ * Uses single-keyframe animations so interrupted toggles (e.g. rapid
+ * close→open) smoothly reverse from the current position rather than
+ * snapping. The clip wrapper pattern (overflow:hidden on parent)
+ * prevents layout overflow.
+ *
+ * @param isOpen - Whether the element should be visible
+ * @param options - Animation configuration
+ * @returns mounted state, ref to attach to the animated element, and initial inline style
+ */
+export declare function useSlideAnimation(isOpen: boolean, options?: {
+    durationMs?: number;
+    hiddenTransform?: string;
+    visibleTransform?: string;
+    easing?: string;
+}): {
+    mounted: boolean;
+    ref: RefObject<HTMLDivElement | null>;
+    style: CSSProperties;
+};
+
+/**
+ * Validate the structure of an exported execution record envelope.
+ * Returns all issues found — both errors and warnings.
+ */
+export declare function validateExecutionRecordStructure(data: unknown): ValidationIssue[];
+
+/**
+ * Validate the structure of an exported graph state envelope.
+ * Returns all issues found — both errors and warnings.
+ *
+ * Does NOT check type-level correctness (e.g. whether dataType IDs
+ * in handles match actual dataTypes entries) — that's the importer's job.
+ */
+export declare function validateGraphStateStructure(data: unknown): ValidationIssue[];
+
+/**
+ * A single validation issue found during import.
+ * Includes a dot-path to the problematic field for precise error location.
+ */
+export declare type ValidationIssue = {
+    /** Dot-path to the problematic field, e.g. "state.nodes[2].position.x" */
+    path: string;
+    /** Human-readable description of the issue */
+    message: string;
+    /** Whether this blocks import ('error') or is informational ('warning') */
+    severity: 'error' | 'warning';
 };
 
 /**