@kiberon-labs/behave-graph-flow 1.0.0 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,2282 @@
+import React$1, { ComponentType, MouseEvent as MouseEvent$1, ReactNode } from "react";
+import * as reactflow0 from "reactflow";
+import { Connection, ConnectionStatus, Edge, EdgeChange, EdgeProps, Node as Node$1, NodeChange, NodeProps, OnConnectStartParams, ReactFlowInstance, Viewport, XYPosition } from "reactflow";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as zustand5 from "zustand";
+import { StoreApi } from "zustand";
+import * as _kiberon_labs_behave_graph0 from "@kiberon-labs/behave-graph";
+import { ChoiceJSON, CustomEventJSON, CustomEventParameterJSON, Engine, GraphJSON, INode, IRegistry, InputSocketSpecJSON, LogSeverity, NodeSpecJSON, OutputSocketSpecJSON, VariableJSON as VariableJSON$1 } from "@kiberon-labs/behave-graph";
+import { Item } from "rc-menu";
+import { LayoutBase, TabBase, TabData } from "rc-dock";
+import { Renderable, Toast } from "react-hot-toast";
+
+//#region src/components/sockets/input/index.d.ts
+type InputSocketProps = {
+  hide: boolean;
+  hideName?: boolean;
+  connected: boolean;
+  value: any | undefined;
+  onChange: (key: string, value: any) => void;
+  specJSON: NodeSpecJSON[];
+} & InputSocketSpecJSON;
+//#endregion
+//#region src/types.d.ts
+interface SocketBase {
+  name: string;
+  key: string;
+  choices?: ChoiceJSON;
+  valueType: string;
+  defaultValue?: any;
+}
+interface DynamicPorts {
+  inputs?: SocketBase[];
+  outputs?: SocketBase[];
+}
+//#endregion
+//#region src/types/nodes.d.ts
+/**
+ * These are the behave nodes in the scene
+ */
+type IBehaveNode = Omit<Node$1, 'data' | 'type'> & {
+  type: 'behaveNode';
+  data: {
+    annotations?: Record<string, any>;
+    type: string;
+    dynamicPorts: DynamicPorts;
+    ports?: Record<string, any>;
+    configuration: Record<string, any>;
+  };
+};
+//#endregion
+//#region src/components/nodes/behave/Node.d.ts
+type BehaveNodeProps = NodeProps<IBehaveNode['data']> & {
+  spec: NodeSpecJSON;
+  allSpecs: NodeSpecJSON[];
+};
+declare const Node: ({
+  id,
+  data,
+  spec,
+  selected,
+  allSpecs
+}: BehaveNodeProps) => react_jsx_runtime0.JSX.Element | null;
+//#endregion
+//#region src/components/Flow.d.ts
+declare const Flow: React$1.FC;
+//#endregion
+//#region src/components/FloatingToolbar/index.d.ts
+declare const FloatingToolbar: React$1.FC;
+//#endregion
+//#region src/store/documentation.d.ts
+/**
+ * Documentation metadata for a node type
+ */
+type NodeDocumentation = {
+  /** The node type this documentation applies to */
+  type: string;
+  /** Optional icon to display for the node */
+  icon?: React$1.ReactNode;
+  /** Short description (one line) */
+  shortDescription?: string;
+  /** Tags for categorization and search */
+  tags?: string[];
+  /** Long rich markdown description */
+  markdownDescription?: string;
+};
+type DocumentationStore = {
+  /** Map of node type to documentation */
+  docs: Map<string, NodeDocumentation>;
+  /** Set documentation for a specific node type */
+  setDocumentation: (type: string, doc: Omit<NodeDocumentation, 'type'>) => void;
+  /** Set documentation for multiple node types at once */
+  setMultipleDocumentation: (docs: NodeDocumentation[]) => void;
+  /** Get documentation for a specific node type */
+  getDocumentation: (type: string) => NodeDocumentation | undefined;
+  /** Clear all documentation */
+  clearDocumentation: () => void;
+  /** Remove documentation for a specific type */
+  removeDocumentation: (type: string) => void;
+};
+declare const documentationStoreFactory: () => zustand5.UseBoundStore<zustand5.StoreApi<DocumentationStore>>;
+//#endregion
+//#region src/components/contextMenus/NodePicker.d.ts
+type NodePickerFilters = {
+  handleType: 'source' | 'target';
+  valueType: string;
+};
+type NodePickerViewMode = 'list' | 'grid' | 'tree';
+type ExtendedNodeSpecJSON = NodeSpecJSON & {
+  nodeType?: string;
+  description?: string;
+  icon?: React$1.ReactNode;
+  tags?: string[];
+  markdownDescription?: string;
+};
+type NodePickerProps = {
+  position: XYPosition;
+  filters?: NodePickerFilters;
+  onPickNode: (node: ExtendedNodeSpecJSON, position: XYPosition) => void;
+  onClose: () => void;
+  specJSON: ExtendedNodeSpecJSON[];
+  documentation?: Map<string, NodeDocumentation>;
+  onShowDocumentation?: (nodeType: string) => void;
+  defaultViewMode?: NodePickerViewMode;
+};
+declare const NodePicker: React$1.FC<NodePickerProps>;
+//#endregion
+//#region src/components/sockets/output/index.d.ts
+type OutputSocketProps = {
+  connected: boolean;
+  hide?: boolean;
+  specJSON: NodeSpecJSON[];
+} & OutputSocketSpecJSON;
+//#endregion
+//#region src/components/menubar/menuItem.d.ts
+type IMenuItemElement = React$1.ComponentProps<typeof Item> & {
+  icon?: React$1.ReactNode;
+  /**
+   * Needed to hack into the inner part of the menu item
+   */
+  inner?: (children: React$1.ReactNode) => React$1.ReactNode;
+};
+/**
+ * You must provide a unique key for each item
+ */
+declare const MenuItemElement: ({
+  inner,
+  children,
+  ...rest
+}: IMenuItemElement) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/useChangeNodeData.d.ts
+declare const useChangeNodeData: (id: string) => (key: string, value: any) => void;
+//#endregion
+//#region src/hooks/useOnPressKey.d.ts
+declare const useOnPressKey: (key: string, callback: (e: KeyboardEvent) => void) => void;
+//#endregion
+//#region src/hooks/useBehaveGraphFlow.d.ts
+/**
+ * Hook that returns the nodes and edges for react-flow, and the graphJson for the behave-graph.
+ * If nodes or edges are changes, the graph json is updated automatically.
+ * The graph json can be set manually, in which case the nodes and edges are updated to match the graph json.
+ * @param param0
+ * @returns
+ */
+declare const useBehaveGraphFlow: ({
+  initialGraphJson,
+  specJson
+}: {
+  initialGraphJson: GraphJSON;
+  specJson: NodeSpecJSON[] | undefined;
+}) => {
+  nodes: reactflow0.Node[];
+  edges: reactflow0.Edge[];
+  onEdgesChange: (changes: reactflow0.EdgeChange[]) => void;
+  onNodesChange: (changes: reactflow0.NodeChange[]) => void;
+  setGraphJson: (graphJson: GraphJSON) => void;
+  graphJson: GraphJSON | undefined;
+};
+//#endregion
+//#region src/hooks/useFlowHandlers.d.ts
+type BehaveGraphFlow = ReturnType<typeof useBehaveGraphFlow>;
+declare const useFlowHandlers: ({
+  onEdgesChange,
+  onNodesChange,
+  nodes,
+  specJSON
+}: Pick<BehaveGraphFlow, "onEdgesChange" | "onNodesChange"> & {
+  nodes: Node$1[];
+  specJSON: NodeSpecJSON[] | undefined;
+}) => {
+  onConnect: (connection: Connection) => void;
+  handleStartConnect: (e: MouseEvent$1, params: OnConnectStartParams) => void;
+  handleStopConnect: (e: MouseEvent, _connectionState: ConnectionStatus) => void;
+  handlePaneClick: () => void;
+  handlePaneContextMenu: (e: MouseEvent$1) => void;
+  lastConnectStart: OnConnectStartParams | undefined;
+  nodePickerVisibility: XYPosition | undefined;
+  handleAddNode: (spec: ExtendedNodeSpecJSON, position: XYPosition) => void;
+  closeNodePicker: () => void;
+  nodePickFilters: NodePickerFilters | undefined;
+};
+//#endregion
+//#region src/transformers/behaveToFlow.d.ts
+declare const behaveToFlow: (graph: GraphJSON) => [Node$1[], Edge[]];
+//#endregion
+//#region src/system/undoRedo.d.ts
+interface Command {
+  name: string;
+  execute(): void;
+  undo(): void;
+  /**
+   * Optional redo method if different from execute
+   */
+  redo?(): void;
+}
+type UndoStackEntry = {
+  name: string;
+};
+type UndoStore = {
+  canUndo: boolean;
+  canRedo: boolean;
+  history: UndoStackEntry[];
+  redoStack: UndoStackEntry[];
+  setSnapshot: (snapshot: {
+    canUndo: boolean;
+    canRedo: boolean;
+    history: UndoStackEntry[];
+    redoStack: UndoStackEntry[];
+  }) => void;
+};
+declare class UndoManager {
+  private history;
+  private stack;
+  private limit;
+  store: zustand5.UseBoundStore<zustand5.StoreApi<UndoStore>>;
+  constructor();
+  private syncStore;
+  execute(command: Command): void;
+  undo(): void;
+  redo(): void;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  clear(): void;
+}
+//#endregion
+//#region src/store/tabs.d.ts
+type TabStore = {
+  currentPanel?: string;
+  layout: LayoutBase;
+  setLayout: (layout: LayoutBase) => void;
+  setCurrentPanel: (currentPanel: string) => void;
+  openTab: (tabId: string, options?: {
+    panelId?: string;
+  }) => void;
+};
+//#endregion
+//#region src/system/tabLoader.d.ts
+declare class TabLoader {
+  readonly tabs: Record<string, () => TabData>;
+  constructor(_system: System);
+  load(tab: TabBase): TabData | undefined;
+  register(id: string, loader: () => TabData): void;
+}
+//#endregion
+//#region src/store/settings.d.ts
+declare const EDGE_TYPE: {
+  readonly bezier: "Bezier";
+  readonly smoothStep: "Smooth step";
+  readonly straight: "Straight";
+  readonly simpleBezier: "Simple Bezier";
+};
+type EdgeType = (typeof EDGE_TYPE)[keyof typeof EDGE_TYPE];
+declare const LAYOUT_TYPE: {
+  readonly dagre: "Dagre";
+  readonly elkForce: "Elk - Force";
+  readonly elkRect: "Elk - Rect";
+  readonly elkLayered: "Elk - Layered";
+};
+type LayoutType = (typeof LAYOUT_TYPE)[keyof typeof LAYOUT_TYPE];
+type GeneratorLocation = 'inline' | 'panel';
+type SystemSettingsStore = {
+  debugMode: boolean;
+  showTimings: boolean;
+  showMinimap: boolean;
+  showGrid: boolean;
+  showSearch: boolean;
+  showMenu: boolean;
+  edgeType: EdgeType;
+  layoutType: LayoutType;
+  delayedUpdate: boolean;
+  inlineTypes: boolean;
+  inlineValues: boolean;
+  connectOnClick: boolean;
+  snapGrid: boolean;
+  gridSize: number;
+  generatorLocation: GeneratorLocation;
+  setDebugMode: (debugMode: boolean) => void;
+  setShowTimings: (showTimings: boolean) => void;
+  setShowMinimap: (showMinimap: boolean) => void;
+  setShowGrid: (showGrid: boolean) => void;
+  setShowSearch: (showSearch: boolean) => void;
+  setEdgeType: (edgeType: EdgeType) => void;
+  setLayoutType: (layoutType: LayoutType) => void;
+  setDelayedUpdate: (delayedUpdate: boolean) => void;
+  setInlineTypes: (inlineTypes: boolean) => void;
+  setInlineValues: (inlineValues: boolean) => void;
+  setConnectOnClick: (connectOnClick: boolean) => void;
+  setSnapGrid: (snapGrid: boolean) => void;
+  setGridSize: (gridSize: number) => void;
+  setGeneratorLocation: (generatorLocation: GeneratorLocation) => void;
+};
+//#endregion
+//#region src/store/logs.d.ts
+interface ILogMessage {
+  message: string;
+}
+interface ILog {
+  data: ILogMessage;
+  time: Date;
+  type: LogSeverity;
+}
+type LogStore = {
+  logs: ILog[];
+  append: (log: ILog) => void;
+  clear: () => void;
+};
+//#endregion
+//#region src/store/legend.d.ts
+type LegendStore = {
+  icons: Record<string, React.ComponentType>;
+  defaultIcon: React.ComponentType;
+  valueTypeColors: Record<string, string>;
+  categoryColors: Record<string, string>;
+  setIcon: (key: string, icon: React.ComponentType) => void;
+  setValueTypeColor: (key: string, color: string) => void;
+  setCategoryColor: (key: string, color: string) => void;
+};
+//#endregion
+//#region src/store/menubar.d.ts
+type IMenuItem = {
+  name: string;
+  render: (rest: {
+    [key: string]: any;
+  }) => React.ReactNode;
+};
+type ISubMenu = {
+  title: string;
+  name: string;
+  items: (IMenuItem | Seperator)[];
+};
+declare class Seperator {}
+type MenuBarStore = {
+  show: boolean;
+  setShow: (show: boolean) => void;
+  items: ISubMenu[];
+  setItems: (items: ISubMenu[]) => void;
+  setSubMenuItems: (menuName: string, items: (IMenuItem | Seperator)[]) => void;
+};
+//#endregion
+//#region src/system/provider.d.ts
+declare const SystemContext: React$1.Context<System | undefined>;
+type SystemProviderProps = {
+  children: ReactNode;
+  value: System;
+};
+declare function SystemProvider({
+  children,
+  value
+}: SystemProviderProps): react_jsx_runtime0.JSX.Element;
+declare function useSystem(): System;
+//#endregion
+//#region src/store/refs.d.ts
+type Refs = {
+  reactflow: ReactFlowInstance;
+  nodePickerPosition?: XYPosition;
+  selectedDocumentationType?: string;
+};
+type RefStore = {
+  refs: Refs;
+  setRef: <T extends keyof Refs>(key: T, ref: Refs[T]) => void;
+  getRef: <T extends keyof Refs>(key: T) => Refs[T] | undefined;
+  removeRef: (key: keyof Refs) => void;
+  hasRef: (key: keyof Refs) => boolean;
+};
+/**
+ * Subscribe to changes of a specific ref
+ * @param store - The ref store
+ * @param key - The key of the ref to watch
+ * @param callback - Callback fired when the ref changes
+ * @returns Unsubscribe function
+ */
+declare function subscribeToRef<T extends keyof Refs>(store: StoreApi<RefStore>, key: T, callback: (ref: Refs[T] | undefined) => void): () => void;
+/**
+ * Hook to access the current value of a ref from the store
+ * @param store - The ref store
+ * @param key - The key of the ref
+ * @returns The current value of the ref or null
+ */
+declare function useRefFromStore<T extends keyof Refs>(store: StoreApi<RefStore>, key: T): Refs[T] | undefined;
+//#endregion
+//#region src/store/hotKeys.d.ts
+type Handler = (e?: KeyboardEvent) => any;
+type HotkeyStore = {
+  keymap: Record<string, string | string[]>;
+  handlers: Record<string, Handler>;
+  descriptions: Record<string, string>;
+  register(val: {
+    action: string;
+    trigger: string | string[];
+    description?: string;
+    handler?: Handler;
+  }): void;
+  registerDescription(action: string, description: string): void;
+  registerHandler(action: string, handler: Handler): void;
+};
+//#endregion
+//#region src/system/pubsub.d.ts
+interface TopicEvents {
+  [topic: string]: any;
+}
+type Subscriber<Events extends TopicEvents, K extends keyof Events> = (message: K, data: Events[K]) => void;
+type AnySubscriber = (message: string, data: any) => void;
+declare class PubSub<Events extends TopicEvents = TopicEvents> {
+  private messages;
+  private lastUid;
+  private static readonly ALL_SUBSCRIBING_MSG;
+  private hasKeys;
+  private throwException;
+  private callSubscriberWithDelayedExceptions;
+  private callSubscriberWithImmediateExceptions;
+  private deliverMessage;
+  private createDeliveryFunction;
+  private hasDirectSubscribersFor;
+  private messageHasSubscribers;
+  private internalPublish;
+  publishHook<K extends keyof Events & string>(message: K, data: Events[K]): boolean;
+  publish<K extends keyof Events & string>(message: K, data: Events[K]): boolean;
+  publishSync<K extends keyof Events & string>(message: K, data: Events[K]): boolean;
+  subscribe<K extends keyof Events & string>(message: K, func: Subscriber<Events, K>): string | false;
+  subscribeAll(func: AnySubscriber): string | false;
+  subscribeOnce<K extends keyof Events & string>(message: K, func: Subscriber<Events, K>): this;
+  clearAllSubscriptions(): void;
+  clearSubscriptions(topic: string): void;
+  countSubscriptions(topic: string): number;
+  getSubscriptions(topic: string): string[];
+  private descendantTopicExists;
+  unsubscribe(value: string | Function): boolean | string;
+}
+//#endregion
+//#region src/store/flow.d.ts
+type FlowStore = {
+  graphJson: GraphJSON | null;
+  setGraph: (graph: GraphJSON, options?: {
+    skipLayout?: boolean;
+  }) => void;
+  getGraph: () => GraphJSON;
+  nodeTypes: Record<string, React.ComponentType<NodeProps>>;
+  edgeTypes: Record<string, React.ComponentType<EdgeProps>>;
+  invalidateCache: () => void;
+  registerNodeType: (type: string, component: React.ComponentType<NodeProps>) => void;
+  registerEdgeType: (type: string, component: React.ComponentType<EdgeProps>) => void;
+};
+type NodeStore = {
+  nodes: Node$1[];
+  addNode: (node: Node$1) => void;
+  setNodes: (nodes: Node$1[] | ((existing: Node$1[]) => Node$1[])) => void;
+  clearNodes: () => void;
+  applyNodeChanges: (changes: NodeChange[]) => void;
+};
+type EdgeStore = {
+  edges: Edge[];
+  addEdge: (edge: Edge) => void;
+  setEdges: (edges: Edge[]) => void;
+  clearEdges: () => void;
+  applyEdgeChanges: (changes: EdgeChange[]) => void;
+};
+//#endregion
+//#region src/store/controls.d.ts
+interface ControlProps<T = any> {
+  value: T;
+  onChange: (value: T) => void;
+  valueType?: string;
+}
+type ControlComponent<T = any> = React.FC<ControlProps<T>>;
+type ControlsStore = {
+  icons: Record<string, React.ComponentType>;
+  controls: Record<string, React.FC<ControlProps>>;
+  defaultControl: React.FC<ControlProps>;
+  registerControl: (name: string, control: React.FC<ControlProps>) => void;
+};
+declare const controlsStoreFactory: () => zustand5.UseBoundStore<zustand5.StoreApi<ControlsStore>>;
+//#endregion
+//#region src/store/variables.d.ts
+type GraphVariables = {
+  [key: string]: VariableJSON$1;
+};
+type VariableStore = {
+  variables: GraphVariables;
+  setVariable: (key: string, value: VariableJSON$1) => void;
+  setVariables: (variables: GraphVariables) => void;
+  removeVariable: (key: string) => void;
+};
+//#endregion
+//#region src/store/selection.d.ts
+type SelectionStore = {
+  selectedNodeId: string | null;
+  setSelectedNodeId: (nodeId: string | null) => void;
+};
+//#endregion
+//#region src/store/layers.d.ts
+type Layer = {
+  id: string;
+  name: string;
+  visible: boolean;
+  opacity: number;
+};
+type SerializedLayers = {
+  defaultLayerId: string;
+  layers: Layer[];
+  nodeLayers: Record<string, string>;
+};
+type LayerStore = {
+  defaultLayerId: string;
+  layers: Record<string, Layer>;
+  nodeLayers: Record<string, string>;
+  createLayer: (name: string) => string;
+  renameLayer: (layerId: string, name: string) => void;
+  setLayerVisibility: (layerId: string, visible: boolean) => void;
+  setLayerOpacity: (layerId: string, opacity: number) => void;
+  removeLayer: (layerId: string) => void;
+  setNodeLayer: (nodeId: string, layerId: string) => void;
+  clearNodeLayer: (nodeId: string) => void;
+  getNodeLayer: (nodeId: string) => Layer;
+  serialize: () => SerializedLayers;
+  deserialize: (serialized?: SerializedLayers) => void;
+  pruneNodeAssignments: (nodeIds: string[]) => void;
+};
+//#endregion
+//#region src/types/graph.d.ts
+type UIGraphData = Record<string, unknown> & {
+  layers?: SerializedLayers;
+};
+type UIGraphJSON = {
+  /**
+   * Version of the graph
+   */
+  v: string;
+  name: string;
+  /**
+   * Graph annotations as metadata
+   */
+  annotations: Record<string, unknown>;
+  /** User specific */
+  user?: {
+    viewport: {
+      x: number;
+      y: number;
+      zoom: number;
+    };
+    /**
+     * Saved viewports for multiple positions
+     */
+    viewports?: {
+      x: number;
+      y: number;
+      zoom: number;
+    }[];
+  };
+  /**
+   * Arbitrary data associated with the graph.
+   * Expected to be used with plugins/extensions. This is seperate from graph annotations
+   */
+  data: UIGraphData;
+  /**
+   * The serialized graph data.
+   * This is currently the embedded JSON format from behave-graph
+   */
+  flow: GraphJSON;
+  nodes: Node$1[];
+  edges: Edge[];
+};
+//#endregion
+//#region src/system/graph.d.ts
+/**
+ * This is our internal graph representation that we use to perform transformations on
+ * It represents the general graph structure, not the underlying behavior graph instance
+ */
+declare class Graph {
+  readonly viewports: Viewport[];
+  private sys;
+  protected annotations: {
+    [key: string]: any;
+  };
+  constructor(system: System);
+  setViewport(index: number, viewport: Viewport): void;
+  /**
+   * Clears the graph
+   */
+  clear(): void;
+  /**
+   * Return all edges that point into the nodes inputs.
+   * O(m) the amount of edges
+   */
+  inEdges(nodeId: string, sourceHandle?: string): Edge[];
+  /**
+   * Return all edges that are pointed out by node v.
+   * O(m) the amount of edges
+   */
+  outEdges(nodeId: string, targetHandle?: string): Edge[];
+  serialize(): UIGraphJSON;
+  getAnnotations(): {
+    [key: string]: any;
+  };
+  setAnnotations(annotations: {
+    [key: string]: any;
+  }): void;
+  deseralize(data: UIGraphJSON): void;
+}
+//#endregion
+//#region src/store/actions.d.ts
+/**
+ * Extend or modify this interface to add more actions as needed.
+ */
+interface Actions {
+  traceUpstream: (nodeId: string) => void;
+  traceDownstream: (nodeId: string) => void;
+  focusNode: (nodeId: string) => void;
+  resetTrace: () => void;
+  addBehaveNode: (nodeType: string, position: XYPosition) => void;
+  copySelectionToClipboard: () => void;
+  pasteFromClipboard: () => Promise<void>;
+  toggleNodeHidden: (nodeId: string) => void;
+  toggleNodePinned: (nodeId: string) => void;
+  groupNodes: () => void;
+  ungroupNodes: (groupId: string) => void;
+  deleteNodes: (nodeIds: string[]) => void;
+  updateGroupColor: (groupId: string, color: string) => void;
+  save: () => Promise<UIGraphJSON>;
+}
+type ActionStore = {
+  actions: Actions;
+  setAction: <K extends keyof Actions>(key: K, action: Actions[K]) => void;
+  getAction: <K extends keyof Actions>(key: K) => Actions[K] | undefined;
+};
+//#endregion
+//#region src/types/NodeMetadata.d.ts
+interface ValueTypeMetadata {
+  name: string;
+  creator: () => any;
+  deserialize?: (value: any) => any;
+  serialize?: (value: any) => any;
+  lerp?: (start: any, end: any, t: number) => any;
+  equals?: (a: any, b: any) => boolean;
+  clone?: (value: any) => any;
+}
+/**
+ * Pure metadata registry - no execution capabilities
+ * Used by the visual graph editor for rendering nodes
+ */
+interface INodeRegistry {
+  readonly values: Record<string, ValueTypeMetadata>;
+  readonly specs: NodeSpecJSON[];
+}
+type NodeMetadata = Record<string, string>;
+//#endregion
+//#region src/store/registry.d.ts
+type RegistryStore = {
+  readonly values: Record<string, ValueTypeMetadata>;
+  readonly specs: NodeSpecJSON[];
+  getRegistry: () => INodeRegistry;
+  updateRegistry: (registry: INodeRegistry) => void;
+  updateValues: (values: Record<string, ValueTypeMetadata>) => void;
+  updateSpecs: (specs: NodeSpecJSON[]) => void;
+};
+//#endregion
+//#region src/store/specs.d.ts
+type SpecsStore = {
+  specs: NodeSpecJSON[];
+  specDict: Record<string, NodeSpecJSON>;
+  setSpecs: (specs: NodeSpecJSON[]) => void;
+};
+//#endregion
+//#region src/store/traces.d.ts
+type TraceSpan = {
+  id: number;
+  nodeId: string;
+  name: string;
+  start: number;
+  end: number;
+  lane: number;
+};
+type SpanCollector = {
+  capacity: number;
+  spans: TraceSpan[];
+  writeIndex: number;
+  size: number;
+  nextId: number;
+  openByNodeId: Map<string, number[]>;
+  laneOpen: boolean[];
+};
+type TraceStore = {
+  version: number;
+  collector: SpanCollector;
+  clear: () => void;
+  connectEngine: (engine?: Engine) => void;
+  recordNodeStart: (node: INode, startTime?: number) => void;
+  recordNodeEnd: (node: INode, endTime?: number) => void;
+  addSpan: (span: Omit<TraceSpan, 'id'>) => void;
+  updateSpan: (nodeId: string, updates: Partial<TraceSpan>) => void;
+};
+//#endregion
+//#region src/store/specific.d.ts
+type SpecificNode = {
+  id: string;
+  data: IBehaveNode['data'];
+  spec: NodeSpecJSON;
+  selected: boolean;
+};
+type SpecificRenderProps = {
+  node: SpecificNode;
+};
+type Specific = {
+  name: string;
+  check: (spec: NodeSpecJSON) => boolean;
+  render: ComponentType<SpecificRenderProps>;
+};
+type SpecificStore = {
+  specifics: Specific[];
+  titleBarActions: Record<string, React.ReactElement>;
+  registerSpecific: (specific: Specific) => void;
+  unregisterSpecific: (name: string) => void;
+  registryTitleBarAction: (name: string, action: React.ReactElement) => void;
+};
+declare const specificStoreFactory: () => zustand5.UseBoundStore<zustand5.StoreApi<SpecificStore>>;
+//#endregion
+//#region src/store/socketGenerator.d.ts
+type SocketGeneratorNode = {
+  id: string;
+  data: IBehaveNode['data'];
+  spec: NodeSpecJSON;
+  selected: boolean;
+};
+type SocketGeneratorRenderProps = {
+  node: SocketGeneratorNode;
+};
+type SocketGenerator = {
+  name: string;
+  check: (spec: NodeSpecJSON) => boolean;
+  render: ComponentType<SocketGeneratorRenderProps>;
+};
+type SocketGeneratorStore = {
+  generators: SocketGenerator[];
+  registerGenerator: (generator: SocketGenerator) => void;
+  unregisterGenerator: (name: string) => void;
+};
+declare const socketGeneratorStoreFactory: () => zustand5.UseBoundStore<zustand5.StoreApi<SocketGeneratorStore>>;
+//#endregion
+//#region src/store/events.d.ts
+type ExtendedCustomEventJSON = CustomEventJSON & {
+  readonly?: boolean;
+};
+type EventsStore = {
+  customEvents: Record<string, ExtendedCustomEventJSON>;
+  setCustomEvents: (customEvents: Record<string, ExtendedCustomEventJSON>) => void;
+  getCustomEvents: () => ExtendedCustomEventJSON[];
+  addCustomEvent: (customEvent: ExtendedCustomEventJSON) => void;
+  removeCustomEvent: (id: string) => void;
+  addParameter: (eventId: string, parameter?: Partial<CustomEventParameterJSON>) => void;
+  updateParameter: (eventId: string, index: number, patch: Partial<CustomEventParameterJSON>) => void;
+  removeParameter: (eventId: string, index: number) => void;
+};
+//#endregion
+//#region src/store/toolbar.d.ts
+type ToolbarButtonGroup = {
+  id: string;
+  label?: string;
+  buttons: (ToolbarButton | React$1.ReactNode)[];
+};
+type ToolbarButton = {
+  id: string;
+  icon: React$1.ReactNode;
+  label: string;
+  onClick: () => void;
+  disabled?: boolean | (() => boolean);
+};
+type ToolbarStore = {
+  visible: boolean;
+  setVisible: (visible: boolean) => void;
+  groups: ToolbarButtonGroup[];
+  setGroups: (groups: ToolbarButtonGroup[]) => void;
+  addGroup: (group: ToolbarButtonGroup) => void;
+  removeGroup: (groupId: string) => void;
+  updateGroup: (groupId: string, group: Partial<ToolbarButtonGroup>) => void;
+};
+declare const toolbarStoreFactory: () => zustand5.StoreApi<ToolbarStore>;
+//#endregion
+//#region src/system/plugin.d.ts
+/**
+ * Plugin initialization function type
+ * @template TOptions - Type of options object passed to the plugin
+ */
+interface Plugin<TOptions = void> {
+  (system: System, options: TOptions): void | Promise<void>;
+}
+type PluginOpts = {
+  name: string;
+};
+type LoadablePlugin<TOptions = void> = {
+  loader: Plugin<TOptions>;
+  opts: PluginOpts;
+};
+declare const plugin: <TOptions = void>(registerfunc: Plugin<TOptions>, opts: PluginOpts) => LoadablePlugin<TOptions>;
+//#endregion
+//#region src/plugin/alignment/index.d.ts
+type AlignmentAxis = 'x' | 'y';
+type AlignmentType = 'start' | 'center' | 'end';
+declare module '@/system/system' {
+  interface PubSys {
+    'alignment:align': {
+      type: AlignmentType;
+      axis: AlignmentAxis;
+    };
+    'alignment:distribute': {
+      type: AlignmentType;
+      axis: AlignmentAxis;
+    };
+  }
+}
+//#endregion
+//#region src/system/notifications.d.ts
+type NotificationType$1 = 'info' | 'success' | 'error' | 'loading';
+interface NotificationOptions {
+  /**
+   * Toast ID for programmatic dismissal
+   */
+  id?: string;
+  /**
+   * Duration in milliseconds. Set to Infinity to persist until manually dismissed
+   */
+  duration?: number;
+  /**
+   * Position on screen
+   */
+  position?: Toast['position'];
+  /**
+   * Custom icon
+   */
+  icon?: Renderable;
+  /**
+   * Custom styles
+   */
+  style?: React.CSSProperties;
+  /**
+   * Custom class name
+   */
+  className?: string;
+  /**
+   * Accessible aria-live value
+   */
+  ariaLive?: Toast['ariaProps'];
+}
+declare class Notifications {
+  private readonly system;
+  constructor(system: System);
+  /**
+   * Dismiss a specific toast or all toasts
+   */
+  dismissNotification(toastId?: string): void;
+  /**
+   * Show a notification toast
+   */
+  notify(message: string, type?: NotificationType$1, options?: NotificationOptions): void;
+  /**
+   * Show a success notification
+   */
+  success(message: string, options?: NotificationOptions): void;
+  /**
+   * Show an error notification
+   */
+  error(message: string, options?: NotificationOptions): void;
+  /**
+   * Show a loading notification
+   */
+  loading(message: string, options?: NotificationOptions): void;
+  /**
+   * Show an info notification
+   */
+  info(message: string, options?: NotificationOptions): void;
+  /**
+   * Dismiss a specific toast or all toasts
+   */
+  dismiss(toastId?: string): void;
+}
+//#endregion
+//#region src/store/chat.d.ts
+interface AgentConfig {
+  model?: string;
+  systemPrompt?: string;
+}
+interface ChatMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: Date;
+  isStreaming?: boolean;
+}
+type ChatStore = {
+  messages: ChatMessage[];
+  agent: AgentConfig | undefined;
+  isStreaming: boolean;
+  inputValue: string;
+  setAgent: (agent: AgentConfig) => void;
+  clearAgent: () => void;
+  addMessage: (message: ChatMessage) => void;
+  updateStreamingMessage: (id: string, content: string) => void;
+  finalizeStreamingMessage: (id: string) => void;
+  setIsStreaming: (streaming: boolean) => void;
+  setInputValue: (value: string) => void;
+  clearMessages: () => void;
+};
+//#endregion
+//#region src/system/system.d.ts
+type NotificationType = 'info' | 'success' | 'error' | 'loading';
+interface NotificationData {
+  type: NotificationType;
+  message: string;
+  options?: {
+    id?: string;
+    duration?: number;
+    position?: any;
+    icon?: Renderable;
+    style?: React.CSSProperties;
+    className?: string;
+    ariaLive?: any;
+  };
+}
+interface PubSys {
+  'edge:added': Edge;
+  'node:added': Node$1;
+  'edge:removed': Edge;
+  'node:removed': Node$1;
+  graphAnnotationsChanged: {
+    [key: string]: any;
+  };
+  'aiNode:trigger': {
+    nodeId: string;
+  };
+  saveViewport: {
+    index: number;
+    viewport: Viewport;
+  };
+  missingViewPort: {
+    index: number;
+  };
+  notification: NotificationData;
+  'notification:dismiss': {
+    toastId?: string;
+  };
+  'layout:saved': LayoutBase;
+  'graph:saved': UIGraphJSON;
+  'graph:inner:saved': GraphJSON;
+  'chat:userMessage': {
+    content: string;
+  };
+}
+/**
+ * Use this to extend the System interface when adding plugins
+ */
+interface ISystem {}
+declare class System implements ISystem {
+  readonly actionStore: StoreApi<ActionStore>;
+  readonly pubsub: PubSub<PubSys>;
+  readonly undoManager: UndoManager;
+  readonly flowStore: StoreApi<FlowStore>;
+  readonly controlStore: StoreApi<ControlsStore>;
+  readonly variableStore: StoreApi<VariableStore>;
+  readonly selectionStore: StoreApi<SelectionStore>;
+  readonly refStore: StoreApi<RefStore>;
+  readonly tabStore: StoreApi<TabStore>;
+  protected deps: Record<string, unknown>;
+  readonly registry: StoreApi<RegistryStore>;
+  readonly tabLoader: TabLoader;
+  readonly systemSettings: StoreApi<SystemSettingsStore>;
+  readonly logsStore: StoreApi<LogStore>;
+  readonly legendStore: StoreApi<LegendStore>;
+  readonly hotKeyStore: StoreApi<HotkeyStore>;
+  readonly edgeStore: StoreApi<EdgeStore>;
+  readonly nodeStore: StoreApi<NodeStore>;
+  readonly specStore: StoreApi<SpecsStore>;
+  readonly specificStore: StoreApi<SpecificStore>;
+  readonly socketGeneratorStore: StoreApi<SocketGeneratorStore>;
+  readonly eventsStore: StoreApi<EventsStore>;
+  readonly documentationStore: StoreApi<DocumentationStore>;
+  readonly toolbarStore: StoreApi<ToolbarStore>;
+  readonly layerStore: StoreApi<LayerStore>;
+  readonly menubarStore: StoreApi<MenuBarStore>;
+  readonly graph: Graph;
+  readonly traceStore: StoreApi<TraceStore>;
+  readonly chatStore: StoreApi<ChatStore>;
+  readonly notifications: Notifications;
+  /**
+   * Create a new System instance
+   * @param registry - INodeRegistry containing nodes and values metadata
+   */
+  constructor(registry?: INodeRegistry);
+  /**
+   * Adds a new dependency to the system
+   * @param name
+   * @param val
+   */
+  decorate(name: keyof System, val: any): void;
+  /**
+   * Load a plugin into the system
+   * @param pluginInit - Plugin initialization function
+   * @param options - Optional configuration options for the plugin
+   * @template TOptions - Type of options object
+   *
+   * @example
+   * // Plugin without options
+   * system.registerPlugin(docsPlugin);
+   *
+   * @example
+   * // Plugin with typed options
+   * interface MyPluginOptions {
+   *   enabled: boolean;
+   *   apiKey: string;
+   * }
+   *
+   * const myPlugin: Plugin<MyPluginOptions> = (system, options) => {
+   *   console.log('Plugin enabled:', options.enabled);
+   * };
+   *
+   * system.registerPlugin(myPlugin, { enabled: true, apiKey: 'secret' });
+   */
+  registerPlugin<TOptions = void>(plugin: LoadablePlugin<TOptions>, options?: TOptions): Promise<void>;
+}
+//#endregion
+//#region src/transformers/flowToBehave.d.ts
+declare const flowToBehave: (system: System, nodes: Node$1[], edges: Edge[], nodeSpecJSON: NodeSpecJSON[]) => GraphJSON;
+//#endregion
+//#region src/util/autoLayout.d.ts
+declare const autoLayout: (nodes: Node$1[], _edges: Edge[]) => void;
+//#endregion
+//#region src/util/calculateNewEdge.d.ts
+declare const calculateNewEdge: (originNode: Node$1, destinationNodeType: string, destinationNodeId: string, connection: OnConnectStartParams, specJSON: NodeSpecJSON[]) => {
+  id: string;
+  source: string;
+  sourceHandle: string | null;
+  target: string;
+  targetHandle: string | undefined;
+} | {
+  id: string;
+  target: string;
+  targetHandle: string | null;
+  source: string;
+  sourceHandle: string | undefined;
+};
+//#endregion
+//#region src/util/colors.d.ts
+declare const categoryColorMap: Record<NodeSpecJSON['category'], string>;
+//#endregion
+//#region src/util/getPickerFilters.d.ts
+declare const getNodePickerFilters: (nodes: Node$1[], params: OnConnectStartParams | undefined, specJSON: NodeSpecJSON[] | undefined) => NodePickerFilters | undefined;
+//#endregion
+//#region src/util/getSocketsByNodeTypeAndHandleType.d.ts
+declare const getSocketsByNodeTypeAndHandleType: (nodes: NodeSpecJSON[], nodeType: string | undefined, handleType: "source" | "target" | null) => _kiberon_labs_behave_graph0.OutputSocketSpecJSON[] | undefined;
+//#endregion
+//#region src/util/hasPositionMetaData.d.ts
+declare const hasPositionMetaData: (graph: GraphJSON) => boolean;
+//#endregion
+//#region src/util/isHandleConnected.d.ts
+declare const isHandleConnected: (edges: Edge[], nodeId: string, handleId: string, type: "source" | "target") => boolean;
+//#endregion
+//#region src/util/isValidConnection.d.ts
+declare const isValidConnection: (connection: Connection, instance: ReactFlowInstance, specJSON: NodeSpecJSON[]) => boolean;
+//#endregion
+//#region src/util/sleep.d.ts
+declare function sleep(durationInSeconds: number): Promise<unknown>;
+//#endregion
+//#region src/util/serializeVariables.d.ts
+interface VariableJSON {
+  id: string;
+  name: string;
+  valueTypeName: string;
+  initialValue: any;
+  label?: string;
+  metadata?: Record<string, any>;
+}
+interface Variable {
+  id: string;
+  name: string;
+  valueTypeName: string;
+  initialValue: any;
+  label?: string;
+  metadata?: Record<string, any>;
+}
+/**
+ * Serialize a single variable to JSON
+ */
+declare function serializeVariable(variable: Variable, registry: INodeRegistry): VariableJSON;
+/**
+ * Serialize multiple variables to JSON array
+ */
+declare function writeVariablesToJSON(registry: INodeRegistry, variables: Record<string, Variable>): VariableJSON[];
+//#endregion
+//#region src/util/downloadJson.d.ts
+/**
+ * Use this on a subscription to the graph:save event to trigger a download of the graph JSON data. This is useful for users who want to keep a local backup of their graphs, or for debugging purposes.
+ * @param filename
+ * @param data
+ */
+declare function downloadJson(filename: string, data: unknown): void;
+//#endregion
+//#region src/util/extractNodeMetadata.d.ts
+/**
+ * Extract pure node metadata from a behave-graph registry.
+ * Used by the visual graph editor to initialize a System without execution dependencies.
+ */
+declare function extractNodeMetadata(registry: IRegistry): INodeRegistry;
+//#endregion
+//#region src/components/layoutController/index.d.ts
+declare const LayoutController: (props: {}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/annotations/index.d.ts
+/**
+ * Indicates that the port can be completely deleted
+ */
+declare const nonDeletable = "ui.nonDeletable";
+/**
+ * Indicates that the port can be reset to its default value / type
+ */
+declare const resetable = "ui.resetable";
+/**
+ * Indicates that the port cannot be edited
+ */
+declare const readonly = "ui.readonly";
+/**
+ * Indicates that the port is hidden from the user
+ */
+declare const hidden = "ui.hidden";
+declare const annotatedTitle = "ui.title";
+declare const description = "ui.description";
+declare const executing = "ui.executing";
+declare const pinned = "ui.pinned";
+declare const layerId = "ui.layerId";
+declare const uiVersion = "ui.version";
+declare const realtime = "ui.realtime";
+declare const AnnotatedOutput = "ui.annotatedOutput";
+//#endregion
+//#region src/plugin/docs/index.d.ts
+/**
+ * This is a plugin that sets up default documentation for core behave-graph nodes.
+ * It uses the documentation store to add rich markdown descriptions,
+ * short descriptions, and tags for various node types.
+ * @param sys
+ */
+declare const docsPluginLoader: (sys: System, _options: void) => void;
+declare const docsPlugin: LoadablePlugin<void>;
+//#endregion
+//#region src/plugin/graphrunner/transport.d.ts
+type TransportState = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface TransportConfig {
+  url: string;
+  reconnectInterval?: number;
+  heartbeatInterval?: number;
+}
+interface ITransport<Send = ServerGraphRunnerMessage | GraphRunnerMessage, Receive = GraphRunnerMessage | ServerGraphRunnerMessage> {
+  /**
+   * Get current connection state
+   */
+  getState(): TransportState;
+  /**
+   * Connect to the server
+   */
+  connect(): Promise<void>;
+  /**
+   * Disconnect from the server
+   */
+  disconnect(): void;
+  /**
+   * Send a message to the server
+   */
+  send(message: Send): void;
+  /**
+   * Register a message handler
+   */
+  onMessage(handler: (message: Receive) => void): void;
+  /**
+   * Register a connection state change handler
+   */
+  onStateChange(handler: (state: TransportState) => void): void;
+  /**
+   * Register an error handler
+   */
+  onError(handler: (error: Error) => void): void;
+  /**
+   * Remove all handlers
+   */
+  removeAllHandlers(): void;
+}
+/**
+ * WebSocket transport implementation
+ */
+declare class WebSocketTransport implements ITransport<GraphRunnerMessage, ServerGraphRunnerMessage> {
+  private ws;
+  private config;
+  private state;
+  private messageHandlers;
+  private stateChangeHandlers;
+  private errorHandlers;
+  private reconnectTimeout;
+  private heartbeatInterval;
+  constructor(config: TransportConfig);
+  getState(): TransportState;
+  connect(): Promise<void>;
+  disconnect(): void;
+  send(message: GraphRunnerMessage): void;
+  onMessage(handler: (message: ServerGraphRunnerMessage) => void): void;
+  onStateChange(handler: (state: TransportState) => void): void;
+  onError(handler: (error: Error) => void): void;
+  removeAllHandlers(): void;
+  private setState;
+  private notifyError;
+  private handleMessage;
+  private handleDisconnect;
+  private reconnect;
+  private startHeartbeat;
+}
+//#endregion
+//#region src/plugin/graphrunner/types.d.ts
+type RunStatus = 'pending' | 'running' | 'completed' | 'stopped' | 'error';
+type ErrorCode = 'PROTOCOL_VERSION_MISMATCH' | 'PROTOCOL_VIOLATION' | 'AUTHENTICATION_FAILED' | 'AUTHENTICATION_REQUIRED' | 'SESSION_NOT_FOUND' | 'SESSION_EXPIRED' | 'INVALID_GRAPH' | 'VALIDATION_FAILED' | 'RUN_NOT_FOUND' | 'NODE_EXECUTION_ERROR' | 'TIMEOUT' | 'CONCURRENT_LIMIT_EXCEEDED' | 'PERMISSION_DENIED';
+interface GraphRunnerCapabilities {
+  trace: boolean;
+  validation?: boolean;
+  graphRegistry?: boolean;
+  eventFiltering?: boolean;
+  batchOperations?: boolean;
+  runHistory?: boolean;
+  runtimeMetadata?: boolean;
+  maxConcurrentRuns?: number;
+  /**
+   * Can the graph be modified in realtime?
+   */
+  realtime?: boolean;
+  maxConcurrentDynamicRuns?: number;
+  updateGranularity?: 'node' | 'socket' | 'full';
+}
+interface RunPerformance {
+  nodesExecuted: number;
+  eventsEmitted: number;
+  variableChanges: number;
+}
+interface EventFilter {
+  eventTypes?: string[];
+  variableNames?: string[];
+  eventNames?: string[];
+}
+interface ServerVariable extends VariableJSON$1 {
+  readonly: boolean;
+  description?: string;
+}
+interface ServerEvent extends CustomEventJSON {
+  readonly: boolean;
+  description?: string;
+  payloadSchema?: unknown;
+}
+interface SocketConstraint {
+  type: 'enum' | 'range' | 'pattern' | 'custom';
+  choices?: Array<{
+    value: unknown;
+    label: string;
+  }>;
+  min?: number;
+  max?: number;
+  pattern?: string;
+  validator?: string;
+}
+interface NodeSocket {
+  name: string;
+  valueType: string;
+  required?: boolean;
+  hasConstraints?: boolean;
+}
+interface AuthCredentials {
+  type: 'bearer' | 'apiKey' | 'none';
+  token?: string;
+  key?: string;
+}
+interface ServerPongMessage {
+  type: 'pong';
+  timestamp: number;
+}
+interface ServerWelcomeMessage {
+  type: 'welcome';
+  protocolVersion: string;
+  serverId: string;
+  authenticated: boolean;
+  userId?: string;
+}
+interface CapabilitiesMessage {
+  type: 'capabilities';
+  capabilities: GraphRunnerCapabilities;
+}
+interface SessionCreatedMessage {
+  type: 'sessionCreated';
+  sessionId: string;
+  expiresAt: number;
+}
+interface SessionResumedMessage {
+  type: 'sessionResumed';
+  sessionId: string;
+  activeRuns: string[];
+}
+interface SessionClosedMessage {
+  type: 'sessionClosed';
+  sessionId: string;
+}
+interface ServerVariablesMessage {
+  type: 'serverVariables';
+  variables: ServerVariable[];
+}
+interface ServerEventsMessage {
+  type: 'serverEvents';
+  events: ServerEvent[];
+}
+interface SocketConstraintsMessage {
+  type: 'socketConstraints';
+  nodeType: string;
+  socketName: string;
+  valueType: string;
+  constraints: SocketConstraint;
+}
+interface NodeTypesMessage {
+  type: 'nodeTypes';
+  nodes: NodeSpecJSON[];
+}
+interface RunStartedMessage {
+  type: 'runStarted';
+  runId: string;
+  graphId: string;
+  startedAt: number;
+}
+interface ServerGraphRegisteredMessage {
+  type: 'graphRegistered';
+  graphId: string;
+}
+interface ServerGraphListMessage {
+  type: 'graphList';
+  graphs: Array<{
+    graphId: string;
+    registeredAt: number;
+  }>;
+}
+interface ValidationResultMessage {
+  type: 'validationResult';
+  graphId: string;
+  valid: boolean;
+  errors: Array<{
+    nodeId: string;
+    message: string;
+    severity: string;
+  }>;
+  warnings: Array<{
+    nodeId: string;
+    message: string;
+    severity: string;
+  }>;
+}
+interface TraceMessage {
+  type: 'trace';
+  runId: string;
+  graphId: string;
+  nodeId: string;
+  event: string;
+  data: unknown;
+  timestamp: number;
+}
+interface LogMessage {
+  type: 'log';
+  runId: string;
+  graphId: string;
+  level: string;
+  message: string;
+  data?: unknown;
+}
+interface VariableChangedMessage {
+  type: 'variableChanged';
+  runId: string;
+  graphId: string;
+  variableName: string;
+  oldValue: unknown;
+  newValue: unknown;
+  nodeId?: string;
+}
+interface CompletedMessage {
+  type: 'completed';
+  runId: string;
+  graphId: string;
+  completedAt: number;
+  elapsedMs: number;
+  result: unknown;
+  performance: RunPerformance;
+}
+interface StoppedMessage {
+  type: 'stopped';
+  runId: string;
+  graphId: string;
+  reason: string;
+}
+interface StatusMessage {
+  type: 'status';
+  runId: string;
+  graphId: string;
+  status: RunStatus;
+  startedAt: number;
+  elapsedMs: number;
+  currentNodeId?: string;
+  startedGraphs: Array<{
+    runId: string;
+    graphId: string;
+    status: RunStatus;
+  }>;
+  performance: RunPerformance;
+}
+interface BatchStatusMessage {
+  type: 'batchStatus';
+  statuses: Array<{
+    runId: string;
+    status: RunStatus;
+    elapsedMs: number;
+  }>;
+}
+interface ErrorMessage {
+  type: 'error';
+  code: ErrorCode;
+  message: string;
+  runId?: string;
+  graphId?: string;
+  nodeId?: string;
+  details?: unknown;
+  supportedVersions?: string[];
+}
+interface RunHistoryMessage {
+  type: 'runHistory';
+  runs: Array<{
+    runId: string;
+    graphId: string;
+    status: RunStatus;
+    startedAt: number;
+    completedAt?: number;
+    elapsedMs: number;
+    result?: unknown;
+  }>;
+}
+type ServerGraphRunnerMessage = ServerPongMessage | ServerWelcomeMessage | CapabilitiesMessage | SessionCreatedMessage | SessionResumedMessage | SessionClosedMessage | ServerVariablesMessage | ServerEventsMessage | SocketConstraintsMessage | NodeTypesMessage | RunStartedMessage | ServerGraphRegisteredMessage | ServerGraphListMessage | ValidationResultMessage | TraceMessage | LogMessage | VariableChangedMessage | CompletedMessage | NodeAddedMessage | StoppedMessage | StatusMessage | BatchStatusMessage | ErrorMessage | NodeRemovedMessage | LinkCreatedMessage | LinkRemovedMessage | NodeParamUpdatedMessage | AffectedNodesMessage | RunHistoryMessage;
+interface HelloMessage {
+  type: 'hello';
+  protocolVersion: string;
+  auth: AuthCredentials;
+}
+interface WelcomeMessage {
+  type: 'welcome';
+  protocolVersion: string;
+  serverId: string;
+  authenticated: boolean;
+  userId?: string;
+}
+interface PingMessage {
+  type: 'ping';
+  timestamp: number;
+}
+interface PongMessage {
+  type: 'pong';
+  timestamp: number;
+}
+interface CreateSessionMessage {
+  type: 'createSession';
+  metadata?: Record<string, unknown>;
+}
+interface ResumeSessionMessage {
+  type: 'resumeSession';
+  sessionId: string;
+}
+interface CloseSessionMessage {
+  type: 'closeSession';
+  sessionId: string;
+}
+interface GetCapabilitiesMessage {
+  type: 'getCapabilities';
+}
+interface GetServerVariablesMessage {
+  type: 'getServerVariables';
+  sessionId: string;
+}
+interface GetServerEventsMessage {
+  type: 'getServerEvents';
+  sessionId: string;
+}
+interface GetSocketConstraintsMessage {
+  type: 'getSocketConstraints';
+  sessionId: string;
+  nodeType: string;
+  socketName: string;
+}
+interface GetNodeTypesMessage {
+  type: 'getNodeTypes';
+  sessionId: string;
+}
+interface RegisterGraphMessage {
+  type: 'registerGraph';
+  sessionId: string;
+  graphId: string;
+  graph: GraphJSON;
+}
+interface GraphRegisteredMessage {
+  type: 'graphRegistered';
+  graphId: string;
+}
+interface GraphListMessage {
+  type: 'graphList';
+  graphs: Array<{
+    graphId: string;
+    registeredAt: number;
+  }>;
+}
+interface ValidateGraphMessage {
+  type: 'validateGraph';
+  sessionId: string;
+  graphId: string;
+  graph: unknown;
+}
+interface RunGraphMessage {
+  type: 'runGraph';
+  sessionId: string;
+  graphId: string;
+  graph: GraphJSON;
+  inputs?: unknown;
+  options?: {
+    autoEnd?: boolean;
+    trace?: boolean;
+    eventFilter?: EventFilter;
+    maxExecutionTimeMs?: number;
+    autoExecMode?: 'new' | 'current';
+    allowDynamicChanges?: boolean;
+    streamDeltas?: boolean;
+  };
+}
+interface ListGraphsMessage {
+  type: 'listGraphs';
+  sessionId: string;
+}
+interface BatchRunStartedMessage {
+  type: 'batchRunStarted';
+  runs: Array<{
+    runId: string;
+    graphId: string;
+  }>;
+}
+interface StopGraphMessage {
+  type: 'stopGraph';
+  sessionId: string;
+  runId: string;
+}
+interface GetStatusMessage {
+  type: 'getStatus';
+  sessionId: string;
+  runId: string;
+}
+interface BatchGetStatusMessage {
+  type: 'batchGetStatus';
+  sessionId: string;
+  runIds: string[];
+}
+interface SubscribeMessage {
+  type: 'subscribe';
+  sessionId: string;
+  runId: string;
+  filter?: EventFilter;
+}
+interface UnsubscribeMessage {
+  type: 'unsubscribe';
+  sessionId: string;
+  runId: string;
+}
+interface EventEmittedMessage {
+  type: 'eventEmitted';
+  runId: string;
+  graphId: string;
+  eventName: string;
+  payload: unknown;
+  nodeId?: string;
+}
+interface NodeAddedMessage {
+  type: 'nodeAdded';
+  runId: string;
+  graphId: string;
+  nodeId: string;
+  nodeType: string;
+  nodeData?: unknown;
+}
+interface GetRunHistoryMessage {
+  type: 'getRunHistory';
+  sessionId: string;
+  limit?: number;
+  graphId?: string;
+}
+interface AddNodeMessage {
+  type: 'addNode';
+  sessionId: string;
+  runId: string;
+  nodeId: string;
+  nodeType: string;
+  nodeData?: Record<string, unknown>;
+  position?: {
+    x: number;
+    y: number;
+  };
+}
+interface RemoveNodeMessage {
+  type: 'removeNode';
+  sessionId: string;
+  runId: string;
+  nodeId: string;
+}
+interface UpdateSocketValueMessage {
+  type: 'updateSocketValue';
+  sessionId: string;
+  runId: string;
+  nodeId: string;
+  socketName: string;
+  value: unknown;
+}
+interface UpdateNodeParamMessage {
+  type: 'updateNodeParam';
+  sessionId: string;
+  runId: string;
+  nodeId: string;
+  paramName: string;
+  value: unknown;
+}
+interface CreateLinkMessage {
+  type: 'createLink';
+  sessionId: string;
+  runId: string;
+  fromNodeId: string;
+  fromSocket: string;
+  toNodeId: string;
+  toSocket: string;
+}
+interface RemoveLinkMessage {
+  type: 'removeLink';
+  sessionId: string;
+  runId: string;
+  fromNodeId: string;
+  fromSocket: string;
+  toNodeId: string;
+  toSocket: string;
+}
+interface DirectExecuteNodeMessage {
+  type: 'directExecuteNode';
+  sessionId: string;
+  runId: string;
+  nodeId: string;
+  inputSocketName: string;
+  inputValue: unknown;
+  autoExecMode?: 'new' | 'current';
+}
+interface NodeRemovedMessage {
+  type: 'nodeRemoved';
+  runId: string;
+  graphId: string;
+  nodeId: string;
+}
+interface LinkCreatedMessage {
+  type: 'linkCreated';
+  runId: string;
+  graphId: string;
+  fromNodeId: string;
+  fromSocket: string;
+  toNodeId: string;
+  toSocket: string;
+}
+interface LinkRemovedMessage {
+  type: 'linkRemoved';
+  runId: string;
+  graphId: string;
+  fromNodeId: string;
+  fromSocket: string;
+  toNodeId: string;
+  toSocket: string;
+}
+interface NodeParamUpdatedMessage {
+  type: 'nodeParamUpdated';
+  runId: string;
+  graphId: string;
+  nodeId: string;
+  paramName: string;
+  oldValue: unknown;
+  newValue: unknown;
+}
+interface AffectedNodesMessage {
+  type: 'affectedNodes';
+  runId: string;
+  graphId: string;
+  nodeIds: string[];
+  reason: 'direct-execution' | 'socket-value-update' | 'param-update' | 'link-change';
+}
+type GraphRunnerMessage = HelloMessage | WelcomeMessage | PingMessage | PongMessage | CreateSessionMessage | ResumeSessionMessage | CloseSessionMessage | GetCapabilitiesMessage | GetServerVariablesMessage | GetServerEventsMessage | GetSocketConstraintsMessage | GetNodeTypesMessage | RegisterGraphMessage | GraphRegisteredMessage | GraphListMessage | ValidateGraphMessage | RunGraphMessage | ListGraphsMessage | BatchRunStartedMessage | StopGraphMessage | GetStatusMessage | BatchGetStatusMessage | SubscribeMessage | UnsubscribeMessage | EventEmittedMessage | NodeAddedMessage | AddNodeMessage | RemoveNodeMessage | UpdateSocketValueMessage | UpdateNodeParamMessage | CreateLinkMessage | RemoveLinkMessage | DirectExecuteNodeMessage | NodeRemovedMessage | LinkCreatedMessage | LinkRemovedMessage | NodeParamUpdatedMessage | AffectedNodesMessage | GetRunHistoryMessage;
+interface GraphRunnerClientConfig {
+  url?: string;
+  auth?: AuthCredentials;
+  protocolVersion?: string;
+  autoReconnect?: boolean;
+  reconnectInterval?: number;
+  heartbeatInterval?: number;
+  metadata?: Record<string, unknown>;
+  transport?: ITransport;
+  trace?: boolean;
+  eventFilter?: EventFilter;
+  maxExecutionTimeMs?: number;
+  allowDynamicChanges?: boolean;
+  autoExecMode?: 'new' | 'current';
+  streamDeltas?: boolean;
+  onMessageActivity?: (direction: 'sent' | 'received', message: GraphRunnerMessage) => void;
+}
+//#endregion
+//#region src/plugin/graphrunner/client.d.ts
+/**
+ * Extract message type by its 'type' field
+ */
+type ExtractMessage<T extends string> = Extract<ServerGraphRunnerMessage, {
+  type: T;
+}>;
+/**
+ * Handler for messages received from the server
+ * Generic type parameter ensures the handler receives the correct message type
+ */
+type ServerMessageHandler<T extends ServerGraphRunnerMessage['type']> = (message: ExtractMessage<T>) => void;
+/**
+ * Client for the Behave-Graph Execution Protocol
+ * Supports multiple transport implementations (WebSocket, HTTP, etc.)
+ */
+declare class GraphRunnerClient {
+  transport: ITransport;
+  private config;
+  private messageHandlers;
+  private sessionId;
+  private capabilities;
+  private serverId;
+  private authenticated;
+  private userId;
+  private pendingRequests;
+  private connectionState;
+  constructor(config: GraphRunnerClientConfig);
+  connect(): Promise<void>;
+  disconnect(): void;
+  createSession(metadata?: Record<string, unknown>): Promise<string>;
+  resumeSession(sessionId: string): Promise<string[]>;
+  closeSession(): Promise<void>;
+  getCapabilities(): Promise<GraphRunnerCapabilities>;
+  getServerVariables(): Promise<ServerVariable[]>;
+  getServerEvents(): Promise<ServerEvent[]>;
+  getSocketConstraints(nodeType: string, socketName: string): Promise<{
+    valueType: string;
+    constraints: SocketConstraint;
+  }>;
+  getNodeTypes(): Promise<NodeSpecJSON[]>;
+  registerGraph(graphId: string, graph: GraphJSON): Promise<void>;
+  listGraphs(): Promise<Array<{
+    graphId: string;
+    registeredAt: number;
+  }>>;
+  validateGraph(graphId: string, graph: unknown): Promise<{
+    valid: boolean;
+    errors: Array<{
+      nodeId: string;
+      message: string;
+      severity: string;
+    }>;
+    warnings: Array<{
+      nodeId: string;
+      message: string;
+      severity: string;
+    }>;
+  }>;
+  runGraph(graphId: string, options?: {
+    graph?: unknown;
+    inputs?: unknown;
+    trace?: boolean;
+  }): Promise<string>;
+  stopGraph(runId: string): Promise<void>;
+  getStatus(runId: string): Promise<StatusMessage>;
+  batchGetStatus(runIds: string[]): Promise<Array<{
+    runId: string;
+    status: RunStatus;
+    elapsedMs: number;
+  }>>;
+  subscribe(runId: string, filter?: EventFilter): Promise<void>;
+  unsubscribe(runId: string): Promise<void>;
+  /**
+   * Send a nodeAdded event
+   * Used to notify the server when a node is added to the graph during execution
+   */
+  sendNodeAdded(runId: string, graphId: string, nodeId: string, nodeType: string, nodeData?: unknown): void;
+  getRunHistory(options?: {
+    limit?: number;
+    graphId?: string;
+  }): Promise<Array<{
+    runId: string;
+    graphId: string;
+    status: RunStatus;
+    startedAt: number;
+    completedAt?: number;
+    elapsedMs: number;
+    result?: unknown;
+  }>>;
+  addNode(runId: string, nodeId: string, nodeType: string, nodeData?: Record<string, unknown>, position?: {
+    x: number;
+    y: number;
+  }): void;
+  removeNode(runId: string, nodeId: string): void;
+  updateSocketValue(runId: string, nodeId: string, socketName: string, value: unknown): void;
+  updateNodeParam(runId: string, nodeId: string, paramName: string, value: unknown): void;
+  createLink(runId: string, fromNodeId: string, fromSocket: string, toNodeId: string, toSocket: string): void;
+  removeLink(runId: string, fromNodeId: string, fromSocket: string, toNodeId: string, toSocket: string): void;
+  directExecuteNode(runId: string, nodeId: string, inputSocketName: string, inputValue: unknown, autoExecMode?: 'new' | 'current'): void;
+  on<T extends ServerGraphRunnerMessage['type']>(messageType: T, handler: ServerMessageHandler<T>): void;
+  off<T extends ServerGraphRunnerMessage['type']>(messageType: T, handler: ServerMessageHandler<T>): void;
+  getConnectionState(): 'disconnected' | 'connecting' | 'authenticating' | 'connected';
+  getSessionId(): string | null;
+  getCachedCapabilities(): GraphRunnerCapabilities | null;
+  isAuthenticated(): boolean;
+  getUserId(): string | null;
+  getServerId(): string | null;
+  isConnected(): boolean;
+  private send;
+  private handleMessage;
+  private handleTransportStateChange;
+  private handleTransportError;
+  private request;
+  private ensureSession;
+  private generateRequestId;
+  private getExpectedResponseType;
+}
+//#endregion
+//#region src/plugin/graphrunner/store.d.ts
+interface MessageActivity {
+  id: string;
+  timestamp: number;
+  direction: 'sent' | 'received';
+  message: GraphRunnerMessage;
+}
+interface ConnectionConfig {
+  url: string;
+  auth: AuthCredentials;
+  autoReconnect: boolean;
+}
+interface ConnectionInfo {
+  serverId: string | null;
+  userId: string | null;
+  sessionId: string | null;
+  authenticated: boolean;
+  capabilities: GraphRunnerCapabilities | null;
+}
+interface GraphRunnerClientStore {
+  connectionState: 'disconnected' | 'connecting' | 'authenticating' | 'connected';
+  connectionConfig: ConnectionConfig;
+  connectionInfo: ConnectionInfo;
+  error: string | null;
+  client: GraphRunnerClient | null;
+  serverVariables: ServerVariable[];
+  serverEvents: ServerEvent[];
+  nodeTypes: NodeSpecJSON[];
+  messageActivity: MessageActivity[];
+  maxActivityMessages: number;
+  currentRunId: string | null;
+  currentGraphId: string | null;
+  isExecuting: boolean;
+  isPaused: boolean;
+  clearLogsOnRun: boolean;
+  clearTracesOnRun: boolean;
+  enableTracing: boolean;
+  setConnectionConfig: (config: Partial<ConnectionConfig>) => void;
+  setClient: (client: GraphRunnerClient | null) => void;
+  setConnectionState: (state: 'disconnected' | 'connecting' | 'authenticating' | 'connected') => void;
+  setConnectionInfo: (info: Partial<ConnectionInfo>) => void;
+  setError: (error: string | null) => void;
+  setServerVariables: (variables: ServerVariable[]) => void;
+  setServerEvents: (events: ServerEvent[]) => void;
+  setNodeTypes: (nodeTypes: NodeSpecJSON[]) => void;
+  clearServerMetadata: () => void;
+  addMessageActivity: (direction: 'sent' | 'received', message: GraphRunnerMessage) => void;
+  clearMessageActivity: () => void;
+  setCurrentRunId: (runId: string | null) => void;
+  setCurrentGraphId: (graphId: string | null) => void;
+  setIsExecuting: (isExecuting: boolean) => void;
+  setIsPaused: (isPaused: boolean) => void;
+  setClearLogsOnRun: (clear: boolean) => void;
+  setClearTracesOnRun: (clear: boolean) => void;
+  setEnableTracing: (enable: boolean) => void;
+}
+declare const graphRunnerClientStoreFactory: (system: System) => StoreApi<GraphRunnerClientStore>;
+//#endregion
+//#region src/plugin/graphrunner/panel.d.ts
+interface GraphRunnerPanelProps {
+  system: System;
+}
+declare const GraphRunnerPanel: React$1.FC<GraphRunnerPanelProps>;
+//#endregion
+//#region src/plugin/graphrunner/runner.d.ts
+declare module '@/system/system' {
+  interface System {
+    runner: GraphRunner;
+  }
+}
+declare class GraphRunner {
+  private system;
+  readonly store: StoreApi<GraphRunnerClientStore>;
+  constructor(system: System, store: StoreApi<GraphRunnerClientStore>);
+  /**
+   * Connect to the graph runner server
+   */
+  connect(): Promise<void>;
+  /**
+   * Disconnect from the graph runner server
+   */
+  disconnect(): Promise<void>;
+  /**
+   * Refresh server metadata (variables, events, node types)
+   */
+  refreshMetadata(): Promise<void>;
+  /**
+   * Run a graph remotely
+   */
+  runRemotely(graphId: string, options?: {
+    graph?: unknown;
+    inputs?: unknown;
+  }): Promise<void>;
+  /**
+   * Stop the current graph execution
+   */
+  stop(): Promise<void>;
+  /**
+   * Play the current graph
+   */
+  play(): Promise<void>;
+  /**
+   * Pause the current graph execution
+   */
+  pause(): Promise<void>;
+  /**
+   * Resume paused execution
+   */
+  resume(): Promise<void>;
+  /**
+   * Execute one step forward
+   */
+  step(): Promise<void>;
+}
+//#endregion
+//#region src/plugin/graphrunner/session.d.ts
+/**
+ * Session configuration for graph execution
+ */
+interface SessionConfig {
+  /** Custom metadata attached to the session */
+  metadata?: Record<string, unknown>;
+  /** Default execution options for all runs in this session */
+  defaultExecutionOptions?: {
+    autoEnd?: boolean;
+    trace?: boolean;
+    eventFilter?: EventFilter;
+    maxExecutionTimeMs?: number;
+  };
+  /** Session-level execution settings */
+  executionSettings?: {
+    /** Delay between execution steps in milliseconds */
+    stepDelay?: number;
+    /** Execution speed multiplier (0.1 to 2.0) */
+    executionSpeed?: number;
+    /** Interval between tick events in milliseconds */
+    tickInterval?: number;
+    /** Maximum number of concurrent runs allowed */
+    maxConcurrentRuns?: number;
+  };
+  /** Custom hook for handling tick timing/delays */
+  tickStrategy?: () => Promise<void>;
+  /** Custom registry overrides for this session */
+  registryOverrides?: Partial<IRegistry>;
+  /** Session lifecycle hooks */
+  hooks?: SessionHooks;
+  /** Session-specific capabilities override */
+  capabilities?: Partial<GraphRunnerCapabilities>;
+}
+/**
+ * Lifecycle hooks for session events
+ */
+interface SessionHooks {
+  /** Called when the session is created */
+  onSessionCreated?: (session: Session) => void | Promise<void>;
+  /** Called when a run starts in this session */
+  onRunStarted?: (session: Session, runId: string, graphId: string) => void | Promise<void>;
+  /** Called when a run completes in this session */
+  onRunCompleted?: (session: Session, runId: string, graphId: string, result: unknown) => void | Promise<void>;
+  /** Called when a run fails in this session */
+  onRunError?: (session: Session, runId: string, graphId: string, error: Error) => void | Promise<void>;
+  /** Called when the session is closed */
+  onSessionClosed?: (session: Session) => void | Promise<void>;
+}
+/**
+ * Session state
+ */
+interface Session {
+  /** Unique session identifier */
+  readonly sessionId: string;
+  /** Session expiration timestamp */
+  readonly expiresAt: number;
+  /** Session creation timestamp */
+  readonly createdAt: number;
+  /** Session configuration */
+  readonly config: SessionConfig;
+  /** Active run IDs in this session */
+  readonly activeRuns: Set<string>;
+  /** Custom session state (user-definable) */
+  state: Record<string, unknown>;
+  /** Session metadata */
+  metadata: Record<string, unknown>;
+}
+/**
+ * Factory for creating sessions with custom configuration
+ */
+interface SessionFactory {
+  /**
+   * Create a new session with optional configuration
+   */
+  createSession(sessionId: string, config?: SessionConfig): Session;
+}
+/**
+ * Default session factory implementation
+ */
+declare class DefaultSessionFactory implements SessionFactory {
+  private defaultConfig?;
+  constructor(defaultConfig?: SessionConfig);
+  createSession(sessionId: string, config?: SessionConfig): Session;
+}
+/**
+ * Session manager to track and manage multiple sessions
+ */
+declare class SessionManager {
+  private sessions;
+  private sessionFactory;
+  constructor(sessionFactory?: SessionFactory);
+  /**
+   * Create a new session
+   */
+  createSession(sessionId: string, config?: SessionConfig): Session;
+  /**
+   * Get an existing session
+   */
+  getSession(sessionId: string): Session | undefined;
+  /**
+   * Check if a session exists
+   */
+  hasSession(sessionId: string): boolean;
+  /**
+   * Close and remove a session
+   */
+  closeSession(sessionId: string): Promise<void>;
+  /**
+   * Add a run to a session
+   */
+  addRunToSession(sessionId: string, runId: string): void;
+  /**
+   * Remove a run from a session
+   */
+  removeRunFromSession(sessionId: string, runId: string): void;
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions(): Session[];
+  /**
+   * Clean up expired sessions
+   */
+  cleanupExpiredSessions(): void;
+}
+//#endregion
+//#region src/plugin/graphrunner/index.d.ts
+/**
+ * Options for the GraphRunner plugin
+ */
+interface GraphRunnerClientPluginOptions {
+  /**
+   * Preconfigured GraphRunner client instance.
+   * If provided, the plugin will use this client instead of creating a new one.
+   * Useful when the client is already connected via a custom transport (e.g., VSCode IPC).
+   */
+  client?: GraphRunnerClient;
+  /**
+   * Preconfigured store instance.
+   * If provided, the plugin will use this store instead of creating a new one.
+   * Useful for sharing state with external components.
+   */
+  store?: StoreApi<GraphRunnerClientStore>;
+  /**
+   * Whether to skip automatic connection.
+   * Default: false (will attempt to connect if client is not provided or not connected)
+   */
+  skipAutoConnect?: boolean;
+  /**
+   * Whether to add the menu item to the Window menu.
+   * Default: true
+   */
+  addMenuItem?: boolean;
+}
+/**
+ * Plugin initialization function
+ * Registers the GraphRunnerClient store and actions with the system
+ */
+declare function graphRunnerClientPluginLoader(system: System, options?: GraphRunnerClientPluginOptions): Promise<void>;
+declare const graphRunnerClientPlugin: LoadablePlugin<GraphRunnerClientPluginOptions | undefined>;
+//#endregion
+//#region src/plugin/graphrunner-local/store.d.ts
+interface LocalGraphRunnerStore {
+  executionSpeed: number;
+  stepDelay: number;
+  tickInterval: number;
+  isExecuting: boolean;
+  isPaused: boolean;
+  activeRuns: number;
+  setExecutionSpeed: (speed: number) => void;
+  setStepDelay: (delay: number) => void;
+  setTickInterval: (interval: number) => void;
+  setIsExecuting: (isExecuting: boolean) => void;
+  setIsPaused: (isPaused: boolean) => void;
+  setActiveRuns: (count: number) => void;
+}
+declare const localGraphRunnerStoreFactory: () => zustand5.StoreApi<LocalGraphRunnerStore>;
+//#endregion
+//#region src/plugin/graphrunner-local/transport.d.ts
+/**
+ * Local transport that executes graphs in the browser using the Engine
+ */
+declare class LocalTransport implements ITransport {
+  private state;
+  private messageHandlers;
+  private stateChangeHandlers;
+  private errorHandlers;
+  private registry;
+  private sessionManager;
+  private activeRuns;
+  private store;
+  private variables;
+  private serverEvents;
+  constructor(registry: IRegistry, options?: {
+    store?: StoreApi<LocalGraphRunnerStore>;
+    variables?: ServerVariable[];
+    serverEvents?: ServerEvent[];
+    sessionFactory?: SessionFactory;
+  });
+  /**
+   * Create a logger that forwards log messages to the client
+   */
+  private createTransportLogger;
+  getState(): TransportState;
+  connect(): Promise<void>;
+  disconnect(): void;
+  send(message: GraphRunnerMessage): void;
+  onMessage(handler: (message: ServerGraphRunnerMessage) => void): void;
+  onStateChange(handler: (state: TransportState) => void): void;
+  onError(handler: (error: Error) => void): void;
+  removeAllHandlers(): void;
+  private setState;
+  private notifyError;
+  private notifyMessage;
+  updateStoreActiveRuns(): void;
+  private updateStoreExecutionState;
+  private getExecutionDelay;
+  private getExecutionStepLimit;
+  private getTickInterval;
+  /**
+   * Get the default sleep-based tick strategy
+   */
+  private createSleepTickStrategy;
+  private generateId;
+  private handleMessage;
+  private handleHello;
+  private handleCreateSession;
+  private handleGetCapabilities;
+  private handleGetServerVariables;
+  private handleGetServerEvents;
+  private handleGetSocketConstraints;
+  private handleGetNodeTypes;
+  private handleRunGraph;
+  private executeGraph;
+  /**
+   * Execute engine with pause support - executes one step at a time with configurable delay
+   */
+  private executeWithPauseSupport;
+  /**
+   * Pause execution of a running graph
+   */
+  pauseExecution(runId: string): void;
+  /**
+   * Resume execution of a paused graph
+   */
+  resumeExecution(runId: string): Promise<void>;
+  /**
+   * Step forward one execution step
+   */
+  stepExecution(runId: string): Promise<void>;
+  /**
+   * Check if a run is currently paused
+   */
+  isPaused(runId: string): boolean;
+  private handleStopGraph;
+  private handleGetStatus;
+  private handleCloseSession;
+  private sendError;
+  private handleAddNode;
+  private handleRemoveNode;
+  private handleUpdateSocketValue;
+  private handleUpdateNodeParam;
+  private handleCreateLink;
+  private handleRemoveLink;
+  private handleDirectExecuteNode;
+  private getDownstreamNodes;
+}
+//#endregion
+//#region src/plugin/graphrunner-local/panel.d.ts
+declare const LocalGraphRunnerPanel: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/plugin/graphrunner-local/types.d.ts
+/**
+ * Extend the System interface to include the local graph runner store
+ */
+declare module '@/system/system' {
+  interface System {
+    localGraphRunnerStore: ReturnType<typeof localGraphRunnerStoreFactory>;
+  }
+}
+//# sourceMappingURL=types.d.ts.map
+
+//#endregion
+//#region src/plugin/graphrunner-local/index.d.ts
+/**
+ * Options for the local graph runner plugin
+ */
+interface LocalGraphRunnerPluginOptions {
+  /**
+   * Node registry with registered nodes, values, and dependencies.
+   * Required for graph execution.
+   */
+  registry: IRegistry;
+  variables?: ServerVariable[];
+  events?: ServerEvent[];
+  sessionFactory?: SessionFactory;
+  /**
+   * Custom tick strategy hook for controlling timing between tick events.
+   * If not provided, defaults to requestAnimationFrame for smooth browser refresh sync.
+   */
+  tickStrategy?: () => Promise<void>;
+  /**
+   * Whether to skip automatic connection.
+   * Default: false (will attempt to connect immediately)
+   */
+  skipAutoConnect?: boolean;
+  /**
+   * Whether to add the menu item to the Window menu.
+   * Default: true
+   */
+  addMenuItem?: boolean;
+}
+/**
+ * Plugin initialization function for local graph execution
+ * Registers a GraphRunnerClient with a local transport that executes graphs in-browser
+ */
+declare function localGraphRunnerPluginLoader(system: System, options: LocalGraphRunnerPluginOptions): Promise<void>;
+declare const localGraphRunnerPlugin: LoadablePlugin<LocalGraphRunnerPluginOptions>;
+//#endregion
+export { AddNodeMessage, AffectedNodesMessage, AnnotatedOutput, AuthCredentials, BatchGetStatusMessage, BatchRunStartedMessage, BatchStatusMessage, BehaveNodeProps, CapabilitiesMessage, CloseSessionMessage, CompletedMessage, ConnectionConfig, ConnectionInfo, ControlComponent, ControlProps, ControlsStore, CreateLinkMessage, CreateSessionMessage, DefaultSessionFactory, DirectExecuteNodeMessage, DocumentationStore, ErrorCode, ErrorMessage, EventEmittedMessage, EventFilter, ExtendedNodeSpecJSON, FloatingToolbar, Flow, GetCapabilitiesMessage, GetNodeTypesMessage, GetRunHistoryMessage, GetServerEventsMessage, GetServerVariablesMessage, GetSocketConstraintsMessage, GetStatusMessage, GraphListMessage, GraphRegisteredMessage, GraphRunner, GraphRunnerCapabilities, GraphRunnerClient, GraphRunnerClientConfig, GraphRunnerClientPluginOptions, GraphRunnerClientStore, GraphRunnerMessage, GraphRunnerPanel, HelloMessage, IMenuItemElement, INodeRegistry, ISystem, ITransport, InputSocketProps, LayoutController, LinkCreatedMessage, LinkRemovedMessage, ListGraphsMessage, LoadablePlugin, LocalGraphRunnerPanel, LocalGraphRunnerPluginOptions, LocalGraphRunnerStore, LocalTransport, LogMessage, MenuItemElement, MessageActivity, Node, NodeAddedMessage, NodeDocumentation, NodeMetadata, NodeParamUpdatedMessage, NodePicker, NodePickerFilters, NodePickerProps, NodePickerViewMode, NodeRemovedMessage, NodeSocket, NodeTypesMessage, NotificationData, NotificationType, OutputSocketProps, PingMessage, Plugin, PluginOpts, PongMessage, PubSys, RegisterGraphMessage, RemoveLinkMessage, RemoveNodeMessage, ResumeSessionMessage, RunGraphMessage, RunHistoryMessage, RunPerformance, RunStartedMessage, RunStatus, ServerEvent, ServerEventsMessage, ServerGraphListMessage, ServerGraphRegisteredMessage, ServerGraphRunnerMessage, ServerPongMessage, ServerVariable, ServerVariablesMessage, ServerWelcomeMessage, Session, SessionClosedMessage, SessionConfig, SessionCreatedMessage, SessionFactory, SessionHooks, SessionManager, SessionResumedMessage, SocketConstraint, SocketConstraintsMessage, SocketGenerator, SocketGeneratorNode, SocketGeneratorRenderProps, SocketGeneratorStore, Specific, SpecificNode, SpecificRenderProps, SpecificStore, StatusMessage, StopGraphMessage, StoppedMessage, SubscribeMessage, System, SystemContext, SystemProvider, SystemProviderProps, ToolbarButton, ToolbarButtonGroup, ToolbarStore, TraceMessage, TransportConfig, TransportState, UIGraphData, UIGraphJSON, UnsubscribeMessage, UpdateNodeParamMessage, UpdateSocketValueMessage, ValidateGraphMessage, ValidationResultMessage, ValueTypeMetadata, Variable, VariableChangedMessage, VariableJSON, WebSocketTransport, WelcomeMessage, annotatedTitle, autoLayout, behaveToFlow, calculateNewEdge, categoryColorMap, controlsStoreFactory, description, docsPlugin, docsPluginLoader, documentationStoreFactory, downloadJson, executing, extractNodeMetadata, flowToBehave, getNodePickerFilters, getSocketsByNodeTypeAndHandleType, graphRunnerClientPlugin, graphRunnerClientPluginLoader, graphRunnerClientStoreFactory, hasPositionMetaData, hidden, isHandleConnected, isValidConnection, layerId, localGraphRunnerPlugin, localGraphRunnerPluginLoader, localGraphRunnerStoreFactory, nonDeletable, pinned, plugin, readonly, realtime, resetable, serializeVariable, sleep, socketGeneratorStoreFactory, specificStoreFactory, subscribeToRef, toolbarStoreFactory, uiVersion, useBehaveGraphFlow, useChangeNodeData, useFlowHandlers, useOnPressKey, useRefFromStore, useSystem, writeVariablesToJSON };
+//# sourceMappingURL=index.d.ts.map