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

package/dist/index.d.ts

@@ -0,0 +1,3597 @@
+import * as react0 from "react";
+import React$1, { ComponentType, FC, 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 zustand5 from "zustand";
+import { StoreApi } from "zustand";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _kiberon_labs_behave_graph0 from "@kiberon-labs/behave-graph";
+import { ChoiceJSON, ContributionSpec, CustomEventJSON, CustomEventParameterJSON, Engine, GraphJSON, INode, IRegistry, InputSocketSpecJSON, LogSeverity, ManifestJSON, NodeSpecJSON, OutputSocketSpecJSON, PackageRequirement, ValueTypeSpecJSON, VariableJSON as VariableJSON$1 } from "@kiberon-labs/behave-graph";
+import { StoreApi as StoreApi$1 } from "zustand/vanilla";
+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;
+  label?: string;
+  onChange: (key: string, value: any) => void;
+  specJSON: NodeSpecJSON[];
+} & InputSocketSpecJSON;
+//#endregion
+//#region src/types.d.ts
+interface SocketBase {
+  name: string;
+  key: string;
+  /** Optional display label; falls back to `name` when absent. */
+  label?: 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>;
+  };
+};
+/**
+ * Presentational markdown note, contributed by the notes plugin
+ * (`@/plugin/notes`). `commentNode` is the legacy type string notes carried
+ * when they lived in the core editor.
+ */
+type INoteNode = Omit<Node$1, 'data' | 'type'> & {
+  type: 'noteNode' | 'commentNode';
+  data: {
+    annotations?: Record<string, any>;
+    text: string;
+    fontSize?: string;
+  };
+};
+//#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;
+  label?: string;
+  specJSON: NodeSpecJSON[];
+} & OutputSocketSpecJSON;
+//#endregion
+//#region src/components/menubar/menuItem.d.ts
+type IMenuItemElement = React$1.ComponentProps<typeof Item> & {
+  icon?: React$1.ReactNode;
+  /**
+   * Explicit shortcut hint (e.g. `'Ctrl+S'`). Overrides the auto-detected one.
+   */
+  keybinding?: string;
+  /**
+   * Command id this item runs. When provided, the shortcut hint is detected
+   * automatically from the live keymap, so a menu item shows its shortcut just
+   * by naming the command it dispatches.
+   */
+  commandId?: string;
+  /**
+   * 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,
+  keybinding,
+  commandId,
+  ...rest
+}: IMenuItemElement) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/panels/base/index.d.ts
+declare const BasePanel: ({
+  children
+}: {
+  children: React.ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/primitives/icon.d.ts
+interface IconProps extends React$1.HTMLAttributes<HTMLButtonElement> {
+  children: React$1.ReactNode;
+  onClick?: (e: React$1.MouseEvent<HTMLButtonElement>) => void;
+  title?: string;
+  disabled?: boolean;
+  className?: string;
+  size?: 'small' | 'medium' | 'large';
+}
+declare const Icon: React$1.FC<IconProps>;
+//#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/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>;
+  private readonly system;
+  constructor(system: System);
+  load(tab: TabBase): TabData | undefined;
+  register(id: string, loader: () => TabData): void;
+  /**
+   * Build the TabData for a graph tab, resolving (or lazily creating) its
+   * session and wrapping the canvas in a {@link GraphProvider} so it stays bound
+   * to its own graph regardless of which tab is focused.
+   */
+  private buildGraphTab;
+}
+//#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];
+type GeneratorLocation = 'inline' | 'panel';
+/**
+ * Single source of truth for editor settings. Each entry's `default` defines the
+ * value (and its type); `persist: false` excludes it from the saved settings.
+ * The store shape, setters, and the persisted-key list are all derived from this
+ * , adding a setting here is the only edit needed (no setter boilerplate, no
+ * separate persist allow-list to keep in sync).
+ */
+declare const SETTINGS: {
+  edgeType: {
+    default: EdgeType;
+  };
+  debugMode: {
+    default: boolean;
+  };
+  showMenu: {
+    default: boolean;
+  };
+  showTimings: {
+    default: boolean;
+  };
+  showMinimap: {
+    default: boolean;
+  };
+  showGrid: {
+    default: boolean;
+  };
+  showSearch: {
+    default: boolean;
+    persist: false;
+  };
+  /** Delay applying a node value change until the user commits it. */
+  delayedUpdate: {
+    default: boolean;
+  };
+  /** Show value types inline on nodes. */
+  inlineTypes: {
+    default: boolean;
+  };
+  /** Show values inline on nodes. */
+  inlineValues: {
+    default: boolean;
+  };
+  connectOnClick: {
+    default: boolean;
+  };
+  /**
+   * When connecting sockets of different-but-convertible value types,
+   * automatically insert a conversion node between them.
+   */
+  autoConvert: {
+    default: boolean;
+  };
+  snapGrid: {
+    default: boolean;
+  };
+  gridSize: {
+    default: number;
+  };
+  generatorLocation: {
+    default: GeneratorLocation;
+  };
+};
+type SettingsSchema = typeof SETTINGS;
+type SettingsState = { [K in keyof SettingsSchema]: SettingsSchema[K]['default'] };
+type SettingsSetters = { [K in keyof SettingsSchema as `set${Capitalize<K & string>}`]: (value: SettingsSchema[K]['default']) => void };
+/**
+ * Generic accessors so plugin-contributed settings (dynamic keys not in the
+ * static {@link SETTINGS} schema) live in the same store as the typed built-ins.
+ * The auto-generated panel writes every row through {@link SystemSettingsStore.setSetting};
+ * the typed per-key setters above remain for existing typed consumers.
+ */
+type SettingsDynamicAccess = {
+  /** Dynamic plugin-contributed setting values, keyed by descriptor key. */
+  [key: string]: unknown;
+  /** Set any setting by key (used by the schema-driven panel + plugins). */
+  setSetting: (key: string, value: unknown) => void;
+};
+type SystemSettingsStore = SettingsState & SettingsSetters & SettingsDynamicAccess;
+//#endregion
+//#region src/store/settingsSchema.d.ts
+/**
+ * Schema-driven settings.
+ *
+ * The Settings panel is auto-generated from a registry of {@link SettingDescriptor}s
+ * rather than hand-coded JSX. Built-in settings are seeded as {@link DEFAULT_SETTINGS};
+ * plugins contribute their own via `system.registerSetting(...)`, and the panel
+ * renders them the same way — so a plugin can surface settings without forking
+ * the panel.
+ *
+ * Descriptors are intentionally plain data (everything except `render`/`when` is
+ * JSON-serializable), so a future declarative manifest `contributes.configuration`
+ * section can feed this same registry.
+ */
+type SettingEnumOption = {
+  value: string;
+  label: string;
+};
+/** Live values bag passed to a descriptor's {@link SettingDescriptorBase.when}. */
+type SettingsValues = Record<string, unknown>;
+/** Props handed to a `type: 'custom'` descriptor's `render` component. */
+type SettingControlProps = {
+  value: unknown;
+  setValue: (value: unknown) => void;
+  descriptor: SettingDescriptor;
+};
+type SettingDescriptorBase = {
+  /**
+   * Unique key. Built-ins are flat (`edgeType`) and match the value-store keys
+   * 1:1; plugin settings should be namespaced (`graphRunner.autoStart`) to avoid
+   * collisions.
+   */
+  key: string;
+  /** Category heading the row is grouped under, e.g. `"Layout"`. */
+  section: string;
+  /** Sort order within the section (falls back to registration order). */
+  order?: number;
+  /** Row label. */
+  title?: string;
+  /** Secondary description text under the label. */
+  description?: string;
+  /** Excluded from persisted settings when `false`. Defaults to `true`. */
+  persist?: boolean;
+  /** Hide the row unless this returns true for the current values. */
+  when?: (values: SettingsValues) => boolean;
+};
+type SettingDescriptor = (SettingDescriptorBase & {
+  type: 'boolean';
+  default: boolean;
+}) | (SettingDescriptorBase & {
+  type: 'number';
+  default: number;
+  min?: number;
+  max?: number;
+  step?: number;
+}) | (SettingDescriptorBase & {
+  type: 'string';
+  default: string;
+  placeholder?: string;
+}) | (SettingDescriptorBase & {
+  type: 'enum';
+  default: string;
+  options: SettingEnumOption[];
+}) | (SettingDescriptorBase & {
+  type: 'custom';
+  default?: unknown;
+  render: FC<SettingControlProps>;
+});
+type SettingsSchemaStore = {
+  /** Registered descriptors, in registration order. */
+  settings: SettingDescriptor[];
+  /** Section names in first-seen order, for stable display grouping. */
+  sectionOrder: string[];
+  registerSetting: (descriptor: SettingDescriptor) => void;
+  registerSettings: (descriptors: SettingDescriptor[]) => void;
+};
+/**
+ * Built-in editor settings, mirroring the previously hand-coded panel. Keys
+ * match the value-store keys in {@link file://./settings.ts} exactly, so typed
+ * consumers (`settings.edgeType`, …) are unaffected.
+ */
+declare const DEFAULT_SETTINGS: SettingDescriptor[];
+declare const settingsSchemaStoreFactory: (initial?: SettingDescriptor[]) => StoreApi$1<SettingsSchemaStore>;
+//#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/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/persistence.d.ts
+/**
+ * Sinks invoked when the editor emits its save events. Each entry maps one
+ * editor-level pubsub topic to the side effect that persists it (write the JSON
+ * somewhere). Override any subset to redirect where saved data goes; sinks left
+ * unspecified keep the built-in file-download behaviour.
+ *
+ * Loading is not represented here: the menubar's "Load" items already read a
+ * file from disk and deserialize it into the focused graph by default, so there
+ * is nothing host-specific to wire for the common case.
+ */
+interface PersistenceAdapter {
+  /** Persist a full UI graph save (`graph:saved`). */
+  saveGraph: (graph: UIGraphJSON) => void;
+  /** Persist a raw inner behave-graph save (`graph:inner:saved`). */
+  saveInnerGraph: (graph: GraphJSON) => void;
+  /** Persist a dock layout save (`layout:saved`). */
+  saveLayout: (layout: LayoutBase) => void;
+}
+/**
+ * The built-in persistence: saving triggers a browser download of the
+ * corresponding JSON file. This is the default so a freshly constructed editor
+ * has working Save actions without any per-host or per-story wiring.
+ */
+declare const defaultPersistenceAdapter: PersistenceAdapter;
+/**
+ * Subscribe the given (or default) persistence sinks to the editor's save
+ * topics. Any sink not provided falls back to {@link defaultPersistenceAdapter}.
+ * Returns a disposer that removes every subscription it added.
+ */
+declare function installPersistence(system: System, adapter?: Partial<PersistenceAdapter>): () => void;
+//#endregion
+//#region src/system/provider.d.ts
+declare const SystemContext: React$1.Context<System | undefined>;
+type SystemProviderProps = {
+  children: ReactNode;
+  value: System;
+};
+/**
+ * Provides the editor-level {@link System} to the React tree.
+ */
+declare function SystemProvider({
+  children,
+  value
+}: SystemProviderProps): react_jsx_runtime0.JSX.Element;
+/** Alias for {@link SystemProvider} expressing its editor-level role. */
+declare const EditorProvider: typeof SystemProvider;
+/**
+ * Access the editor-level {@link System}.
+ */
+declare function useSystem(): System;
+/** Alias for {@link useSystem}. */
+declare const useEditor: typeof useSystem;
+type GraphProviderProps = {
+  children: ReactNode;
+  value: GraphSession;
+};
+/**
+ * Provides a single {@link GraphSession} to the subtree rendered inside a graph
+ * tab. Components within use {@link useGraph} to read per-graph state bound to
+ * their own tab, regardless of which tab is currently focused.
+ */
+declare function GraphProvider({
+  children,
+  value
+}: GraphProviderProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Access the {@link GraphSession} of the surrounding graph tab.
+ */
+declare function useGraph(): GraphSession;
+/**
+ * Access the currently focused {@link GraphSession}, or undefined when no graph
+ * is open. Subscribes to the editor's active-graph store, so panels rendered
+ * outside of a graph tab re-render when the focused graph changes.
+ */
+declare function useActiveGraph(): GraphSession | undefined;
+//#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>;
+}
+/**
+ * Cleanup returned by a {@link SessionExtension}. Run when the session it was
+ * applied to is disposed (its tab closed).
+ */
+type SessionExtensionCleanup = () => void;
+/**
+ * Extends a single {@link GraphSession}. Registered at the editor level via
+ * `system.registerSessionExtension(...)`, it runs against every graph , those
+ * already open at registration time and any created afterwards , so an editor
+ * plugin can attach per-graph state (extra stores, controllers, pubsub
+ * subscriptions) to each new graph instance.
+ *
+ * Return a cleanup to tear that per-graph state down when the session is
+ * disposed.
+ *
+ * @example
+ * system.registerSessionExtension((session) => {
+ *   const controller = new MyController(session);
+ *   session.decorate('myController', controller);
+ *   return () => controller.dispose();
+ * });
+ */
+interface SessionExtension {
+  (session: GraphSession): void | SessionExtensionCleanup;
+}
+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/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>;
+  /** Reverse map: command id -> keymap action, so any UI surface that runs a
+   * command can look up its live shortcut without knowing the action name. */
+  commandToAction: Record<string, string>;
+  register(val: {
+    action: string;
+    trigger: string | string[];
+    description?: string;
+    handler?: Handler;
+    /** Command id this binding invokes; enables shortcut hints in menus. */
+    command?: string;
+  }): void;
+  registerDescription(action: string, description: string): void;
+  registerHandler(action: string, handler: Handler): void;
+  /**
+   * Formatted shortcut hint for a command id (e.g. `'Ctrl+Shift+←'`), derived
+   * live from the keymap, or undefined if the command has no bound key.
+   */
+  getCommandKeybinding(commandId: string): string | undefined;
+};
+//#endregion
+//#region src/system/pubsub.d.ts
+interface TopicEvents {
+  [topic: string]: any;
+}
+type Subscriber<Events extends TopicEvents, K$1 extends keyof Events> = (message: K$1, data: Events[K$1]) => 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$1 extends keyof Events & string>(message: K$1, data: Events[K$1]): boolean;
+  publish<K$1 extends keyof Events & string>(message: K$1, data: Events[K$1]): boolean;
+  publishSync<K$1 extends keyof Events & string>(message: K$1, data: Events[K$1]): boolean;
+  subscribe<K$1 extends keyof Events & string>(message: K$1, func: Subscriber<Events, K$1>): string | false;
+  subscribeAll(func: AnySubscriber): string | false;
+  subscribeOnce<K$1 extends keyof Events & string>(message: K$1, func: Subscriber<Events, K$1>): 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/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/selection.d.ts
+type SelectionStore = {
+  selectedNodeId: string | null;
+  setSelectedNodeId: (nodeId: string | null) => void;
+};
+//#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/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/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/store/conversions.d.ts
+/**
+ * A user/plugin-defined automatic type conversion: "when connecting a `from`
+ * socket to a `to` socket, splice in `nodeType`". `inputKey`/`outputKey` name
+ * the converter's value sockets; when omitted they're resolved from the node
+ * spec (first non-flow input/output).
+ */
+type ConversionRule = {
+  from: string;
+  to: string;
+  nodeType: string;
+  inputKey?: string;
+  outputKey?: string;
+};
+type ConversionStore = {
+  conversions: ConversionRule[];
+  /** Add (or replace the existing rule for the same from→to pair). */
+  registerConversion: (rule: ConversionRule) => void;
+  removeConversion: (from: string, to: string) => void;
+  setConversions: (rules: ConversionRule[]) => void;
+  findConversion: (from: string, to: string) => ConversionRule | undefined;
+};
+declare const conversionStoreFactory: () => StoreApi<ConversionStore>;
+//#endregion
+//#region src/store/commands.d.ts
+/**
+ * Context handed to a command when it runs. Carries the editor + the graph it
+ * acts on, plus optional targets so the same command works from a context menu,
+ * a hotkey, or a toolbar button.
+ */
+type CommandContext = {
+  editor: System;
+  session: GraphSession;
+  nodeId?: string;
+  edgeId?: string;
+  sourceId?: string;
+  targetId?: string;
+  position?: XYPosition;
+};
+/**
+ * A named, dispatchable action. Decouples *what* (id) from *how* (run), so UI
+ * surfaces (context menus, hotkeys, menubar, toolbar) reference commands by id
+ * instead of reaching into concrete stores.
+ */
+type Command = {
+  id: string;
+  title?: string;
+  /** When present and false, the command is treated as unavailable. */
+  isEnabled?: (ctx: CommandContext) => boolean;
+  run: (ctx: CommandContext) => void | Promise<void>;
+};
+type CommandStore = {
+  commands: Map<string, Command>;
+  /** Register (or replace) a command. Returns an unregister disposer. */
+  register: (command: Command) => () => void;
+  unregister: (id: string) => void;
+  get: (id: string) => Command | undefined;
+  list: () => Command[];
+  /** Run a command by id; no-ops (with a warning) if unknown or disabled. */
+  run: (id: string, ctx: CommandContext) => void | Promise<void>;
+};
+declare const commandStoreFactory: () => StoreApi<CommandStore>;
+/**
+ * Register the built-in editor commands. Hosts may override any of them by
+ * re-registering with the same id, or add their own.
+ */
+declare const registerDefaultCommands: (store: StoreApi<CommandStore>) => void;
+//#endregion
+//#region src/store/contextMenu.d.ts
+/** Which canvas target a context-menu item applies to. */
+type ContextMenuTarget = 'node' | 'edge' | 'selection' | 'pane';
+/**
+ * A registrable context-menu entry. Items dispatch either a registered command
+ * (`commandId`) or an inline `onSelect`. `group` controls separator placement;
+ * `order` controls position within a target. `when` hides the item dynamically.
+ */
+type ContextMenuItem = {
+  id: string;
+  target: ContextMenuTarget;
+  /** Static text, or a function for state-dependent labels (e.g. Pin/Unpin). */
+  label: string | ((ctx: CommandContext) => string);
+  keybinding?: string;
+  /** Ascending sort within the target. */
+  order?: number;
+  /** Items with different adjacent groups get a separator between them. */
+  group?: string | number;
+  when?: (ctx: CommandContext) => boolean;
+  /** Dispatch a registered command by id. */
+  commandId?: string;
+  /** Or run inline (takes precedence over commandId). */
+  onSelect?: (ctx: CommandContext) => void;
+};
+type ContextMenuStore = {
+  items: ContextMenuItem[];
+  /** Register (or replace by id) an item. Returns an unregister disposer. */
+  register: (item: ContextMenuItem) => () => void;
+  unregister: (id: string) => void;
+  /** Items for a target, sorted by `order`. Filtering by `when` is the caller's. */
+  getItems: (target: ContextMenuTarget) => ContextMenuItem[];
+};
+declare const contextMenuStoreFactory: () => StoreApi<ContextMenuStore>;
+/**
+ * Register the built-in context-menu items, dispatching the default commands.
+ * Hosts can add/remove/replace items by id without forking the menu components.
+ */
+declare const registerDefaultContextMenu: (store: StoreApi<ContextMenuStore>) => void;
+//#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/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/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$1 extends keyof Actions>(key: K$1, action: Actions[K$1]) => void;
+  getAction: <K$1 extends keyof Actions>(key: K$1) => Actions[K$1] | undefined;
+};
+//#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' | 'lane'> & {
+    lane?: number;
+  }) => void;
+  updateSpan: (nodeId: string, updates: Partial<TraceSpan>) => void;
+};
+//#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/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/system/undoRedo.d.ts
+interface Command$1 {
+  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$1): void;
+  undo(): void;
+  redo(): void;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  clear(): void;
+}
+//#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;
+  constructor(session: GraphSession);
+  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(): {
+    [x: string]: any;
+  };
+  setAnnotations(annotations: {
+    [key: string]: any;
+  }): void;
+  deseralize(data: UIGraphJSON): void;
+}
+//#endregion
+//#region src/system/system.d.ts
+/**
+ * Editor-level pubsub topics. These are global to the editor and shared across
+ * every open graph. Augment this interface (not {@link GraphPubSys}) for events
+ * that are not tied to a specific graph.
+ */
+interface EditorPubSys {
+  notification: NotificationData;
+  'notification:dismiss': {
+    toastId?: string;
+  };
+  'layout:saved': LayoutBase;
+  'graph:saved': UIGraphJSON;
+  'graph:inner:saved': GraphJSON;
+}
+/**
+ * Per-graph pubsub topics. Each {@link GraphSession} owns its own bus typed with
+ * this interface, so events stay isolated to the graph that produced them.
+ * Augment this interface for events that belong to a single graph.
+ */
+interface GraphPubSys {
+  'edge:added': Edge;
+  'node:added': Node$1;
+  'edge:removed': Edge;
+  'node:removed': Node$1;
+  graphAnnotationsChanged: {
+    [key: string]: any;
+  };
+  saveViewport: {
+    index: number;
+    viewport: Viewport;
+  };
+}
+/**
+ * Combined pubsub surface kept for backwards compatibility. Prefer the split
+ * {@link EditorPubSys} / {@link GraphPubSys} interfaces.
+ */
+interface PubSys extends EditorPubSys, GraphPubSys {}
+/**
+ * Use this to extend the System interface when adding plugins
+ */
+interface ISystem {}
+/** Minimal storage adapter for persisting editor settings. */
+type SettingsStorage = {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+};
+/** Serialized editor-level settings (UI toggles + custom type conversions). */
+type EditorSettingsJSON = {
+  settings?: Record<string, any>;
+  conversions?: ConversionRule[];
+};
+/**
+ * Observable registry of open graph sessions plus the currently focused one.
+ * Backed by a zustand store so panels rendered outside of a graph tab can
+ * subscribe and re-render when the active graph changes.
+ */
+type ActiveGraphStore = {
+  activeGraphId: string | null;
+  sessions: Record<string, GraphSession>;
+  setActiveGraph: (id: string | null) => void;
+  addSession: (session: GraphSession) => void;
+  removeSession: (id: string) => void;
+  getActive: () => GraphSession | undefined;
+};
+/**
+ * The editor-level system. Holds state that is shared across every open graph
+ * (settings, registry, specs, menubar, tabs, ...) plus an observable registry of
+ * per-graph {@link GraphSession} instances. Per-graph state itself lives on the
+ * sessions, not here.
+ *
+ * The class is intentionally still named `System` so existing `declare module`
+ * augmentations (`interface System { ... }`) keep merging and the public API is
+ * stable; `EditorSystem` is exported as an alias for new code.
+ */
+declare class System implements ISystem {
+  readonly pubsub: PubSub<EditorPubSys>;
+  readonly tabStore: StoreApi<TabStore>;
+  readonly tabLoader: TabLoader;
+  readonly systemSettings: StoreApi<SystemSettingsStore>;
+  /** Registry of setting descriptors driving the auto-generated Settings panel. */
+  readonly settingsSchema: StoreApi<SettingsSchemaStore>;
+  readonly legendStore: StoreApi<LegendStore>;
+  readonly menubarStore: StoreApi<MenuBarStore>;
+  readonly hotKeyStore: StoreApi<HotkeyStore>;
+  readonly registry: StoreApi<RegistryStore>;
+  readonly specStore: StoreApi<SpecsStore>;
+  readonly specificStore: StoreApi<SpecificStore>;
+  readonly socketGeneratorStore: StoreApi<SocketGeneratorStore>;
+  readonly documentationStore: StoreApi<DocumentationStore>;
+  readonly toolbarStore: StoreApi<ToolbarStore>;
+  readonly controlStore: StoreApi<ControlsStore>;
+  /** User/plugin-defined automatic type conversions for auto-convert. */
+  readonly conversionStore: StoreApi<ConversionStore>;
+  /** Named, dispatchable commands shared across hotkeys/menus/toolbar. */
+  readonly commandStore: StoreApi<CommandStore>;
+  /** Per-target context-menu item registry (node/edge/selection/pane). */
+  readonly contextMenuStore: StoreApi<ContextMenuStore>;
+  readonly notifications: Notifications;
+  /** Observable registry of open graph sessions + the focused one. */
+  readonly activeGraph: StoreApi<ActiveGraphStore>;
+  /** Editor-level extensions applied to every graph session on creation. */
+  private readonly sessionExtensions;
+  /** Disposer for the currently installed graph/layout save handlers. */
+  private persistenceDisposer;
+  protected deps: Record<string, unknown>;
+  /**
+   * Create a new editor System instance
+   * @param registry - INodeRegistry containing nodes and values metadata
+   */
+  constructor(registry?: INodeRegistry);
+  /**
+   * The currently focused graph session, if any.
+   */
+  get session(): GraphSession | undefined;
+  /**
+   * Create a new graph session, register it and (by default) make it active.
+   */
+  createSession(id?: string, options?: {
+    activate?: boolean;
+    name?: string;
+  }): GraphSession;
+  /**
+   * Look up an existing session by id, creating an empty one if missing.
+   */
+  getOrCreateSession(id: string): GraphSession;
+  /**
+   * Create a brand new, empty graph in its own tab and focus it.
+   */
+  newGraph(name?: string): GraphSession;
+  /**
+   * Dispose a graph session and remove it from the registry. Called when its
+   * tab is closed.
+   */
+  disposeSession(id: string): void;
+  get flowStore(): StoreApi<FlowStore>;
+  get nodeStore(): StoreApi<NodeStore>;
+  get edgeStore(): StoreApi<EdgeStore>;
+  get variableStore(): StoreApi<VariableStore>;
+  get selectionStore(): StoreApi<SelectionStore>;
+  get refStore(): StoreApi<RefStore>;
+  get actionStore(): StoreApi<ActionStore>;
+  get traceStore(): StoreApi<TraceStore>;
+  get eventsStore(): StoreApi<EventsStore>;
+  get logsStore(): StoreApi<LogStore>;
+  get layerStore(): StoreApi<LayerStore>;
+  get graph(): Graph;
+  get undoManager(): UndoManager;
+  /**
+   * 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>;
+  /**
+   * Register an extension applied to every {@link GraphSession}. It runs against
+   * each graph already open at registration time and against every graph created
+   * afterwards (via {@link createSession}), so a plugin can attach per-graph
+   * state to new graph instances from a single editor-level registration.
+   *
+   * If the extension returns a cleanup it is wired to the session's
+   * {@link GraphSession.onDispose} and runs when that graph's tab is closed.
+   *
+   * @returns an unregister function that stops the extension from applying to
+   * sessions created later. It does not retroactively tear down sessions already
+   * extended (those clean up on their own dispose).
+   */
+  registerSessionExtension(extension: SessionExtension): () => void;
+  /** Run a single session extension, wiring any returned cleanup to dispose. */
+  private applySessionExtension;
+  /**
+   * Register a custom automatic type conversion (e.g. from a profile plugin) so
+   * auto-convert can splice in the given node for that type pair.
+   */
+  registerConversion(rule: ConversionRule): void;
+  /**
+   * Contribute a setting to the schema-driven Settings panel. The panel
+   * auto-generates a row for it (grouped under `descriptor.section`), and its
+   * default value is seeded into the settings store if not already present.
+   * Built-in settings are registered the same way at construction.
+   *
+   * @example
+   * system.registerSetting({
+   *   key: 'graphRunner.autoStart', section: 'Graph Runner', type: 'boolean',
+   *   default: false, title: 'Auto-start runner'
+   * });
+   */
+  registerSetting(descriptor: SettingDescriptor): void;
+  /** Contribute several settings at once. */
+  registerSettings(descriptors: SettingDescriptor[]): void;
+  /** Read a setting value by key (built-in or plugin-contributed). */
+  getSetting<T = unknown>(key: string): T;
+  /** Set a setting value by key. Persists if the descriptor allows it. */
+  setSetting(key: string, value: unknown): void;
+  /**
+   * Dispatch a registered command against the focused graph (or a supplied
+   * session). Convenience used by hotkeys, the menubar and the toolbar so they
+   * share one dispatch path. No-ops if there is no graph to act on.
+   */
+  runCommand(id: string, ctx?: Partial<CommandContext>): void | Promise<void>;
+  /**
+   * Override where the editor's Save actions send their data. The editor
+   * publishes `graph:saved`, `graph:inner:saved` and `layout:saved`; by default
+   * each triggers a JSON file download. Pass an adapter to redirect any subset
+   * of those to your own sink (write to disk, POST to a backend, ...); topics
+   * you omit keep the file-download default. Replaces any previously installed
+   * handlers and returns a disposer.
+   *
+   * This governs graph/layout saving only; editor *settings* persistence is
+   * separate , see {@link enableSettingsPersistence}.
+   *
+   * @example
+   * // Persist graphs to a backend, keep the default layout download.
+   * system.enablePersistence({
+   *   saveGraph: (graph) => api.put('/graphs/current', graph)
+   * });
+   */
+  enablePersistence(adapter?: Partial<PersistenceAdapter>): () => void;
+  /**
+   * Remove the default (or custom) graph/layout save handlers entirely. Use this
+   * when the host handles saving through a channel of its own and the built-in
+   * file download would be redundant (e.g. the VS Code extension).
+   */
+  disablePersistence(): void;
+  /**
+   * Serialize the persistable editor settings , the UI toggles plus any custom
+   * type conversions , to a plain JSON object.
+   */
+  serializeSettings(): EditorSettingsJSON;
+  /**
+   * Keys round-tripped to persisted storage: the built-in persisted keys plus
+   * every plugin-contributed descriptor that opts in (`persist !== false`).
+   * Custom descriptors carry no backing value, so they are excluded.
+   */
+  private persistedSettingKeys;
+  /**
+   * Apply previously-serialized editor settings (toggles + conversions).
+   * Unknown keys are ignored.
+   */
+  applySettings(json: EditorSettingsJSON | undefined): void;
+  /**
+   * Persist editor settings + conversions to a storage adapter (localStorage by
+   * default). Applies any saved state immediately, then saves (debounced) on
+   * change. Returns a disposer. A host can pass its own storage adapter (e.g.
+   * one backed by VS Code workspace state) instead of localStorage.
+   */
+  enableSettingsPersistence(storage?: SettingsStorage | undefined): () => void;
+}
+//#endregion
+//#region src/system/notifications.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 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, 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/graphMeta.d.ts
+/**
+ * Reactive graph-level properties for a single {@link GraphSession}: the display
+ * name (also the tab title) and an arbitrary metadata bag (the graph
+ * annotations). Backed by a store so the Graph Properties panel, the tab title
+ * and anything else stay in sync.
+ */
+type GraphMetaStore = {
+  name: string;
+  metadata: Record<string, any>;
+  setName: (name: string) => void;
+  /** Replace the whole metadata bag. */
+  setMetadata: (metadata: Record<string, any>) => void;
+  /** Shallow-merge into the metadata bag. */
+  mergeMetadata: (partial: Record<string, any>) => void;
+  setMetadataValue: (key: string, value: any) => void;
+  removeMetadataKey: (key: string) => void;
+};
+//#endregion
+//#region src/system/graphSession.d.ts
+/**
+ * Augmentable surface for per-graph state contributed by plugins. Mirrors
+ * {@link ISystem} at the editor level: a plugin adds typed properties to every
+ * graph by augmenting this interface and assigning them via
+ * {@link GraphSession.decorate} from inside a session extension.
+ *
+ * @example
+ * declare module '@/system/graphSession' {
+ *   interface IGraphSession {
+ *     myController?: MyController;
+ *   }
+ * }
+ */
+interface IGraphSession {}
+/**
+ * Merge the augmentable surface into the class instance type. Declaration
+ * merging (same-named interface + class) makes plugin-added members , set via
+ * {@link GraphSession.decorate} , readable as `session.x`, which `implements`
+ * alone would NOT provide.
+ */
+interface GraphSession extends IGraphSession {}
+/**
+ * A single open graph. Owns all per-graph state , nodes, edges, variables,
+ * selection, traces, layers, logs, undo history and a private pubsub , so that
+ * multiple graphs can be open simultaneously in complete isolation.
+ *
+ * Shared, editor-level resources (registry, specs, settings, notifications, ...)
+ * are reached through {@link GraphSession.editor}.
+ *
+ * Per-graph state contributed by editor plugins is attached on creation via
+ * session extensions (`system.registerSessionExtension`), which may register
+ * teardown through {@link GraphSession.onDispose}.
+ */
+declare class GraphSession {
+  readonly id: string;
+  readonly editor: System;
+  /** Reactive graph-level properties (name + metadata). */
+  readonly metaStore: StoreApi<GraphMetaStore>;
+  readonly pubsub: PubSub<GraphPubSys>;
+  readonly undoManager: UndoManager;
+  /** Display name, used as the graph tab title. Backed by {@link metaStore}. */
+  get name(): string;
+  set name(value: string);
+  readonly controlStore: StoreApi<ControlsStore>;
+  readonly variableStore: StoreApi<VariableStore>;
+  readonly refStore: StoreApi<RefStore>;
+  readonly logsStore: StoreApi<LogStore>;
+  readonly eventsStore: StoreApi<EventsStore>;
+  readonly nodeStore: StoreApi<NodeStore>;
+  readonly edgeStore: StoreApi<EdgeStore>;
+  readonly flowStore: StoreApi<FlowStore>;
+  readonly selectionStore: StoreApi<SelectionStore>;
+  readonly actionStore: StoreApi<ActionStore>;
+  readonly layerStore: StoreApi<LayerStore>;
+  readonly traceStore: StoreApi<TraceStore>;
+  readonly graph: Graph;
+  /** Cleanups registered by session extensions, run (LIFO) on {@link dispose}. */
+  private readonly disposers;
+  constructor(editor: System, id?: string, name?: string);
+  /**
+   * Convenience access to the shared editor notifications service.
+   */
+  get notifications(): Notifications;
+  /**
+   * Attach a plugin-contributed property to this session. The companion to the
+   * {@link IGraphSession} augmentation; mirrors {@link System.decorate}.
+   */
+  decorate<K$1 extends keyof IGraphSession>(name: K$1, val: IGraphSession[K$1]): void;
+  /**
+   * Register a cleanup to run when this session is disposed. Session extensions
+   * use this (via their returned cleanup) to tear down per-graph state they
+   * attached. Cleanups run in reverse registration order.
+   */
+  onDispose(cleanup: () => void): void;
+  serialize(): UIGraphJSON;
+  /**
+   * Tear down this session's reactive wiring. Called when its tab is closed so
+   * its pubsub subscriptions and trace flush loop don't leak. Extension-supplied
+   * cleanups run first (LIFO), then the built-in teardown.
+   */
+  dispose(): void;
+}
+//#endregion
+//#region src/transformers/flowToBehave.d.ts
+declare const flowToBehave: (session: GraphSession, 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[], options?: {
+  autoConvert?: boolean;
+  conversions?: ConversionRule[];
+}) => 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/generators/registerDefaults.d.ts
+/**
+ * Register the editor's built-in content , the default socket generators and the
+ * call-subgraph contract sync , on an editor instance.
+ *
+ * Idempotent per editor: safe to call from every graph-canvas mount (multiple
+ * tabs) without double-registering. The default content is editor-lifetime; the
+ * subgraph sync's per-session subscriptions clean themselves up on session
+ * dispose.
+ *
+ * A host that wants a blank or fully custom editor can simply not rely on the
+ * canvas's auto-call and register its own content instead.
+ */
+declare function registerDefaults(editor: System): void;
+//#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/manifest/passthroughValueType.d.ts
+/**
+ * Build a function-bearing {@link ValueTypeMetadata} from a function-free
+ * {@link ValueTypeSpecJSON} carried in a manifest.
+ *
+ * The editor calls `creator`/`serialize`/`deserialize` at author time (creating
+ * variables, editing events, deserializing a graph's variables). A manifest can
+ * only ship JSON, so we synthesise pass-through behaviour: the value is already
+ * its own JSON form, so (de)serialize are identity and `creator` returns a clone
+ * of the declared default. This keeps every existing UI call site working with
+ * **zero code execution**. When the package is later trusted-loaded, a
+ * `valueType` contribution can replace this with the real implementation.
+ */
+declare function passthroughValueType(spec: ValueTypeSpecJSON): ValueTypeMetadata;
+//#endregion
+//#region src/manifest/contributionRegistry.d.ts
+/**
+ * Registers a single resolved contribution into the right editor store. `value`
+ * is whatever the host's resolver loaded for the contribution's `export` (its
+ * concrete shape depends on the kind).
+ */
+type ContributionApplier = (system: System, contribution: ContributionSpec, value: unknown) => void;
+/** Dispatch table mapping each {@link ContributionKind} to its store action. */
+declare const contributionAppliers: Record<string, ContributionApplier>;
+/** Apply a resolved contribution, warning (not throwing) on an unknown kind. */
+declare function applyContribution(system: System, contribution: ContributionSpec, value: unknown): void;
+//#endregion
+//#region src/manifest/loadManifest.d.ts
+/**
+ * Resolves a contribution's declarative `export` (e.g. `"./ui.js#ImageControl"`)
+ * to its actual value. The host owns this because a bundler must know the
+ * concrete module — so loading code contributions is always host-mediated and
+ * gated behind {@link LoadManifestOptions.trust}.
+ */
+type ContributionResolver = (contribution: ContributionSpec, manifest: ManifestJSON) => unknown | Promise<unknown>;
+type LoadManifestOptions = {
+  /**
+   * Gate for executing code contributions. Default `false`: only nodes and
+   * pass-through value types load (no package code runs). Set true together
+   * with {@link LoadManifestOptions.resolve} once the package is trusted.
+   */
+  trust?: boolean;
+  /** Required to load contributions; without it only the static parts load. */
+  resolve?: ContributionResolver;
+  /**
+   * Called for each declared host requirement (persistent backend, config,
+   * ...). Lets the host surface a badge or run a backend. No code executes here.
+   */
+  onRequirement?: (requirement: PackageRequirement, manifest: ManifestJSON) => void;
+};
+/**
+ * Load a package manifest into the editor.
+ *
+ * Always (no code execution): registers the node specs and pass-through value
+ * types, so the palette is fully populated from JSON alone. Only under explicit
+ * `trust` + a `resolve`r does it import and register the package's code
+ * contributions. Declared host requirements are surfaced via `onRequirement`.
+ */
+declare function loadManifest(system: System, manifest: ManifestJSON, options?: LoadManifestOptions): Promise<void>;
+//#endregion
+//#region src/manifest/manifestPlugin.d.ts
+interface ManifestPluginOptions extends LoadManifestOptions {
+  /** Manifests to load, in order (later ones override earlier node types). */
+  manifests: ManifestJSON[];
+}
+declare function manifestPluginLoader(system: System, options: ManifestPluginOptions): Promise<void>;
+/**
+ * Register one or more package manifests as a single plugin. The static parts
+ * (nodes + value types) always load; code contributions load only under
+ * `trust` + `resolve` (see {@link LoadManifestOptions}).
+ */
+declare const manifestPlugin: LoadablePlugin<ManifestPluginOptions>;
+//#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/alignment/index.d.ts
+type AlignmentAxis = 'x' | 'y';
+type AlignmentType = 'start' | 'center' | 'end';
+declare module '@/system/system' {
+  interface GraphPubSys {
+    'alignment:align': {
+      type: AlignmentType;
+      axis: AlignmentAxis;
+    };
+    'alignment:distribute': {
+      type: AlignmentType;
+      axis: AlignmentAxis;
+    };
+  }
+}
+declare const setupSessionActions: (session: GraphSession) => void;
+/**
+ * Adds node alignment + distribution to the editor. The behaviour is opt-in: it
+ * subscribes each graph's pubsub (via a session extension, so it covers graphs
+ * already open and any opened later) to the `alignment:align` /
+ * `alignment:distribute` events the FloatingToolbar and Alignment panel publish.
+ *
+ * Register it directly or via the kitchen-sink plugin. Without it those events
+ * have no subscriber and the alignment controls simply no-op.
+ */
+declare const alignmentPlugin: LoadablePlugin<void>;
+//#endregion
+//#region src/plugin/layout/dagre.d.ts
+type Direction = 'TB' | 'LR' | 'RL' | 'BT';
+type Options = {
+  direction: Direction;
+};
+declare function applyDagreLayout(system: System, options?: Options | undefined): Promise<void>;
+//#endregion
+//#region src/plugin/layout/elk.d.ts
+type LayoutAlgorithm = 'org.eclipse.elk.layered' | 'org.eclipse.elk.force' | 'org.eclipse.elk.rectpacking';
+declare const applyElkLayout: (sys: System, algorithm: LayoutAlgorithm) => Promise<void>;
+//#endregion
+//#region src/plugin/layout/index.d.ts
+/**
+ * Available auto-layout engines. `Dagre` is a small, synchronous layered layout;
+ * the `Elk - *` options use elkjs (~1.4 MB, loaded lazily on first use) for
+ * higher-quality layouts.
+ */
+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];
+/**
+ * Run the currently-selected auto-layout engine against the focused graph.
+ * Reads the `layoutType` setting (registered by this plugin) to pick the engine.
+ */
+declare const applyAutoLayout: (system: System) => void;
+/**
+ * Adds graph auto-layout (Dagre + ELK) to the editor. elkjs and dagre are heavy
+ * dependencies that not every host needs, so they live here rather than in the
+ * core editor — register this plugin (directly or via the kitchen-sink plugin)
+ * to opt in.
+ *
+ * The plugin:
+ * - registers the `layoutType` setting (the engine picker in the Settings panel);
+ * - registers the `editor.autoLayout` command that the "Auto Layout" hotkey and
+ *   menu dispatch to.
+ *
+ * Without it, `editor.autoLayout` is simply unregistered (the hotkey no-ops).
+ */
+declare const layoutPlugin: LoadablePlugin<void>;
+//#endregion
+//#region src/plugin/notes/note.d.ts
+declare const NoteNode: react0.MemoExoticComponent<(props: NodeProps<INoteNode["data"]>) => react_jsx_runtime0.JSX.Element>;
+//#endregion
+//#region src/plugin/notes/nodeActions.d.ts
+/** Node type registered for notes created by this plugin. */
+declare const NOTE_NODE_TYPE = "noteNode";
+/**
+ * Type string notes used while they lived in the core editor as "comment"
+ * nodes. Registered as an alias so graphs saved before the move still render.
+ */
+declare const LEGACY_COMMENT_NODE_TYPE = "commentNode";
+declare const isNoteNode: (node: Node$1 | undefined) => node is Node$1;
+declare const noteAt: (ctx: CommandContext) => Node$1 | undefined;
+declare const duplicateNote: (session: GraphSession, note: Node$1) => void;
+declare const deleteNote: (session: GraphSession, note: Node$1) => void;
+/**
+ * Move a note within the nodes array: React Flow paints later nodes on top, so
+ * array order is z-order.
+ */
+declare const reorderNote: (session: GraphSession, note: Node$1, to: "front" | "back") => void;
+//#endregion
+//#region src/plugin/notes/index.d.ts
+/**
+ * Adds markdown note nodes to the editor. Notes are purely presentational:
+ * they never appear in the compiled behave graph (only behave nodes do), but
+ * they persist with the UI graph JSON like any other canvas node.
+ *
+ * The note editor embeds tiptap/prosemirror, a heavy dependency most hosts do
+ * not need, so notes live here rather than in the core editor — register this
+ * plugin (directly or via the kitchen-sink plugin) to opt in.
+ *
+ * The plugin:
+ * - registers the `noteNode` component on every graph session (plus the legacy
+ *   `commentNode` alias for graphs saved before notes moved here);
+ * - registers the `notes.addNote` command, an "Add Note" button on the
+ *   floating toolbar, and a `Shift+N` hotkey that dispatch it;
+ * - registers note-specific node commands + context-menu items
+ *   (duplicate / delete / bring to front / send to back).
+ */
+declare const notesPlugin: LoadablePlugin<void>;
+//#endregion
+//#region src/plugin/autosave/storage.d.ts
+/** Single local-storage key holding every graph's backup ring. */
+declare const AUTOSAVE_STORAGE_KEY = "behave-graph:autosave";
+/** A single point-in-time copy of one graph. */
+type BackupSnapshot = {
+  /** Unique id for this snapshot (used by the panel to restore/delete). */
+  id: string;
+  /** Session id of the graph this snapshot came from. */
+  graphId: string;
+  /** Graph display name captured at snapshot time (for the panel list). */
+  name: string;
+  /** Epoch milliseconds when the snapshot was taken. */
+  timestamp: number;
+  /** Node count, shown in the panel without deserializing the whole graph. */
+  nodeCount: number;
+  /** The full, restorable graph document. */
+  graph: UIGraphJSON;
+};
+/**
+ * Thin persistence wrapper over the single backup key. Kept storage-agnostic
+ * (any get/set adapter) so hosts can back it with something other than
+ * localStorage and tests can inject an in-memory map.
+ */
+declare class BackupStorage {
+  private readonly storage;
+  constructor(storage?: SettingsStorage | undefined);
+  /** Whether a backing store is available (false in SSR / sandboxed contexts). */
+  get available(): boolean;
+  /** All snapshots across every graph, newest first. */
+  listAll(): BackupSnapshot[];
+  /** Find one snapshot by id (across all graphs). */
+  find(id: string): BackupSnapshot | undefined;
+  /**
+   * Append a snapshot to its graph's ring and trim to `maxCopies` (oldest
+   * dropped). `name` refreshes the stored graph label so the panel tracks
+   * renames.
+   */
+  append(snapshot: BackupSnapshot, maxCopies: number): void;
+  /** Remove a single snapshot; prunes the graph entry once it is empty. */
+  remove(id: string): void;
+  /** Drop every snapshot for a single graph. */
+  removeGraph(graphId: string): void;
+  /** Wipe all backups. */
+  clear(): void;
+}
+//#endregion
+//#region src/plugin/autosave/controller.d.ts
+/** Reactive slice the backup panel subscribes to. */
+type BackupControllerStore = {
+  /** All snapshots across every graph, newest first. */
+  snapshots: BackupSnapshot[];
+  /** Whether the timer is currently running. */
+  running: boolean;
+  /** Epoch ms of the last successful capture, or null. */
+  lastBackupAt: number | null;
+};
+/**
+ * Drives periodic, consistency-checked backups of every open graph into local
+ * storage, and restores from them. Owned by the autosave plugin and exposed on
+ * the editor as `system.backups` so panels and other plugins can drive it.
+ *
+ * Snapshots are only written when a graph has actually changed, has settled
+ * (see {@link QUIESCE_MS}), is internally consistent, and is not empty , and
+ * never while a caller has the controller suspended. Timer cadence, copy count
+ * and the on/off switch are read live from the editor settings.
+ */
+declare class BackupController {
+  readonly store: StoreApi$1<BackupControllerStore>;
+  private readonly system;
+  private readonly backups;
+  private timer;
+  /** Nesting counter: > 0 means "unsafe to snapshot right now". */
+  private suspendDepth;
+  private readonly watches;
+  private readonly disposers;
+  constructor(system: System, storage?: SettingsStorage);
+  /** Mark the start of a region where a snapshot would be unsafe. */
+  suspend(): void;
+  /** End a region opened by {@link suspend}. */
+  resume(): void;
+  /** Whether snapshots are currently suspended. */
+  get suspended(): boolean;
+  /**
+   * Run `fn` with snapshots suspended, resuming even if it throws. Use this to
+   * bracket bulk mutations (loads, imports, programmatic rewrites) so an
+   * autosave tick can never capture the graph mid-transition.
+   */
+  runExclusive<T>(fn: () => T): T;
+  private intervalMs;
+  private maxCopies;
+  /** (Re)start or stop the timer to match the current settings. */
+  private applySettings;
+  private start;
+  private stop;
+  /** One scheduler pass: try to capture each open, dirty, settled graph. */
+  private tick;
+  /**
+   * Snapshot one graph now if it is worth it: changed, settled, non-empty,
+   * consistent and not a duplicate of the last capture. Returns the snapshot on
+   * success, or null when it was skipped.
+   */
+  captureSession(session: GraphSession, force?: boolean): BackupSnapshot | null;
+  /** Force an immediate backup of the focused graph (the "Back up now" action). */
+  backupNow(): BackupSnapshot | null;
+  /**
+   * Restore a snapshot into a brand-new graph tab, leaving all currently open
+   * graphs untouched , the safe choice when recovering from a bad state.
+   * Returns the new session, or undefined if the snapshot is gone.
+   */
+  restore(snapshotId: string): GraphSession | undefined;
+  /** Delete one snapshot. */
+  deleteSnapshot(id: string): void;
+  /** Delete every snapshot. */
+  clearAll(): void;
+  /** Re-read storage into the reactive store (after an external change). */
+  refresh(): void;
+  /** Add watches for newly opened sessions, drop them for closed ones. */
+  private syncSessions;
+  private watchSession;
+  /** Tear down timers and subscriptions. */
+  dispose(): void;
+}
+//#endregion
+//#region src/plugin/autosave/settings.d.ts
+/**
+ * Setting keys owned by the autosave plugin. Namespaced (`autosave.*`) so they
+ * never collide with the built-in flat setting keys.
+ */
+declare const AUTOSAVE_ENABLED = "autosave.enabled";
+declare const AUTOSAVE_INTERVAL_SECONDS = "autosave.intervalSeconds";
+declare const AUTOSAVE_MAX_COPIES = "autosave.maxCopies";
+/** Shipped defaults, also used by the controller when a value is missing. */
+declare const AUTOSAVE_DEFAULTS: {
+  readonly enabled: false;
+  readonly intervalSeconds: 60;
+  readonly maxCopies: 20;
+};
+/** Lower bound on the timer so a typo can't spin the loop every frame. */
+declare const MIN_INTERVAL_SECONDS = 5;
+/**
+ * The Settings-panel rows this plugin contributes. Registered via
+ * `system.registerSettings(...)`, which also seeds each default into the value
+ * store, so `system.getSetting(AUTOSAVE_*)` is populated the moment the plugin
+ * loads.
+ */
+declare const AUTOSAVE_SETTINGS: SettingDescriptor[];
+//#endregion
+//#region src/plugin/autosave/index.d.ts
+declare module '@/system/system' {
+  interface System {
+    /** Local backup controller, present when the autosave plugin is loaded. */
+    backups?: BackupController;
+  }
+}
+/** Tab id for the backup browser panel. */
+declare const BACKUP_PANEL_TAB_ID = "autosaveBackups";
+/** Options for {@link autosavePlugin}. */
+interface AutosavePluginOptions {
+  /**
+   * Storage adapter for the backups. Defaults to `localStorage`. Provide your
+   * own (e.g. backed by VS Code workspace state) to persist elsewhere; pass a
+   * throwaway map in tests.
+   */
+  storage?: SettingsStorage;
+  /** Add the "Local Backups" item to the Window menu. Default: true. */
+  addMenuItem?: boolean;
+}
+/**
+ * Client-side automatic graph backups.
+ *
+ * Periodically snapshots every open graph into local storage so a crash or a
+ * bad edit during development is recoverable, and adds a panel to browse and
+ * restore those copies. Everything stays in the browser , no backend.
+ *
+ * The plugin:
+ * - contributes the `Autosave` settings (on/off, frequency, copies-to-keep);
+ * - installs a {@link BackupController} on the editor as `system.backups`,
+ *   which runs the consistency-checked capture loop and honours the settings;
+ * - registers the `autosaveBackups` panel plus `autosave.openBackups` /
+ *   `autosave.backupNow` commands and a Window-menu entry.
+ *
+ * Snapshots are only taken when a graph changed, settled, is consistent and is
+ * not empty; callers can bracket bulk mutations with
+ * `system.backups.runExclusive(...)` to guarantee no copy is taken mid-change.
+ */
+declare const autosavePlugin: LoadablePlugin<AutosavePluginOptions | undefined>;
+//#endregion
+//#region src/plugin/kitchen-sink/index.d.ts
+/**
+ * Batteries-included bundle of the standard editor plugins. Register this once
+ * instead of wiring each plugin by hand:
+ *
+ * ```ts
+ * const system = new System(registry);
+ * system.registerPlugin(kitchenSinkPlugin);
+ * ```
+ *
+ * It currently pulls in:
+ * - {@link docsPlugin} — the in-editor node documentation browser;
+ * - {@link alignmentPlugin} — node alignment + distribution;
+ * - {@link layoutPlugin} — Dagre/ELK auto-layout (heavy deps, opt-in);
+ * - {@link notesPlugin} — markdown note nodes (tiptap/prosemirror, opt-in);
+ * - {@link autosavePlugin} — client-side local backups of open graphs.
+ *
+ * It intentionally does **not** register a graph runner: runners
+ * ({@link localGraphRunnerPlugin}, the remote client, ...) need host-specific
+ * options (a node registry, transport, ...) so hosts wire those themselves.
+ */
+declare const kitchenSinkPlugin: 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;
+}
+/**
+ * Optional capability: a transport that can interactively control a run
+ * (pause / resume / step). Remote transports may not support it; the client
+ * detects support via {@link supportsExecutionControl} rather than reaching into
+ * transport internals.
+ */
+interface IExecutionControl {
+  pauseExecution(runId: string): void;
+  resumeExecution(runId: string): Promise<void>;
+  stepExecution(runId: string): Promise<void>;
+  isPaused(runId: string): boolean;
+}
+/** Type guard: does this transport implement {@link IExecutionControl}? */
+declare function supportsExecutionControl(transport: unknown): transport is IExecutionControl;
+/**
+ * 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;
+}
+/** A single node-execution event inside a {@link TraceBatchMessage}. */
+interface TraceBatchEvent {
+  nodeId: string;
+  event: string;
+  data?: unknown;
+  timestamp: number;
+}
+/**
+ * Coalesced trace events for one run. Runners buffer per-node execution events
+ * and flush them roughly once per frame, so a tick that executes hundreds of
+ * nodes costs one message instead of hundreds.
+ */
+interface TraceBatchMessage {
+  type: 'traceBatch';
+  runId: string;
+  graphId: string;
+  events: TraceBatchEvent[];
+}
+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 | TraceBatchMessage | 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;
+  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;
+  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/runController.d.ts
+declare module '@/system/graphSession' {
+  interface IGraphSession {
+    runController?: GraphRunController;
+  }
+}
+/**
+ * Per-run state for a single graph. Each {@link GraphSession} owns one of these,
+ * so multiple graphs can run independently and concurrently.
+ */
+interface RunControllerStore {
+  currentRunId: string | null;
+  currentGraphId: string | null;
+  isExecuting: boolean;
+  isPaused: boolean;
+  setCurrentRunId: (runId: string | null) => void;
+  setCurrentGraphId: (graphId: string | null) => void;
+  setIsExecuting: (isExecuting: boolean) => void;
+  setIsPaused: (isPaused: boolean) => void;
+}
+/**
+ * Drives execution for a single graph session. Run lifecycle and run state are
+ * per-session; the underlying connection/client is shared via {@link GraphRunner}.
+ * Incoming server messages are routed back to the originating controller by run
+ * id (see `GraphRunner.runIndex`).
+ */
+declare class GraphRunController {
+  readonly session: GraphSession;
+  readonly runner: GraphRunner;
+  readonly store: StoreApi<RunControllerStore>;
+  private readonly disposers;
+  constructor(session: GraphSession, runner: GraphRunner);
+  private get notifications();
+  /** Run the graph for this session. */
+  play(): Promise<void>;
+  runRemotely(graphId: string, options?: {
+    graph?: unknown;
+    inputs?: unknown;
+  }): Promise<void>;
+  stop(): Promise<void>;
+  pause(): Promise<void>;
+  resume(): Promise<void>;
+  step(): Promise<void>;
+  /** Reset run state after completion/stop/error and unregister the run. */
+  finishRun(): void;
+  /**
+   * Forward live graph edits to the server while this graph is running, tagged
+   * with this controller's run id so concurrent graphs stay isolated.
+   */
+  private setupRealtimeForwarding;
+  dispose(): void;
+}
+//#endregion
+//#region src/plugin/graphrunner/runner.d.ts
+declare module '@/system/system' {
+  interface System {
+    runner: GraphRunner;
+  }
+}
+/**
+ * Shared connection to the graph runner server. Owns the client, connection
+ * lifecycle and server metadata; per-graph run state and run lifecycle live on
+ * {@link GraphRunController}. Incoming server messages are dispatched back to the
+ * owning controller via {@link GraphRunner.runIndex}, keyed by run id, so
+ * multiple graphs can run concurrently and independently.
+ */
+declare class GraphRunner {
+  private system;
+  readonly store: StoreApi<GraphRunnerClientStore>;
+  /** runId -> the controller that started it. */
+  readonly runIndex: Map<string, GraphRunController>;
+  constructor(system: System, store: StoreApi<GraphRunnerClientStore>);
+  registerRun(runId: string, controller: GraphRunController): void;
+  unregisterRun(runId: string): void;
+  /**
+   * 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>;
+}
+//#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, IExecutionControl {
+  private state;
+  private messageHandlers;
+  private stateChangeHandlers;
+  private errorHandlers;
+  private registry;
+  private sessionManager;
+  private activeRuns;
+  private store;
+  private variables;
+  private serverEvents;
+  private resolveGraph?;
+  constructor(registry: IRegistry, options?: {
+    store?: StoreApi<LocalGraphRunnerStore>;
+    variables?: ServerVariable[];
+    serverEvents?: ServerEvent[];
+    sessionFactory?: SessionFactory;
+    /**
+     * Resolve a referenced graph's JSON by id, enabling Call Subgraph nodes.
+     */
+    resolveGraph?: (id: string) => GraphJSON | undefined;
+  });
+  /**
+   * 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
+//#region src/plugin/graphrunner-webworker/worker-transport.d.ts
+/**
+ * Web Worker transport that delegates graph execution to a worker thread
+ */
+declare class WorkerTransport implements ITransport {
+  private state;
+  private messageHandlers;
+  private stateChangeHandlers;
+  private errorHandlers;
+  private worker;
+  constructor(worker: Worker);
+  getState(): TransportState;
+  connect(): Promise<void>;
+  disconnect(): void;
+  send(message: GraphRunnerMessage): void;
+  onMessage(handler: (message: GraphRunnerMessage) => void): void;
+  onStateChange(handler: (state: TransportState) => void): void;
+  onError(handler: (error: Error) => void): void;
+  removeAllHandlers(): void;
+  private setState;
+  private notifyError;
+  private notifyMessage;
+  private handleWorkerMessage;
+}
+//#endregion
+//#region src/plugin/graphrunner-webworker/store.d.ts
+type WebWorkerGraphRunnerStore = {
+  /**
+   * Number of active graph runs in the worker
+   */
+  activeRuns: number;
+  /**
+   * Whether a graph is currently executing
+   */
+  isExecuting: boolean;
+  /**
+   * Whether execution is paused
+   */
+  isPaused: boolean;
+  /**
+   * Tick interval in milliseconds (for tick events)
+   * Default: 50ms
+   */
+  tickInterval: number;
+  /**
+   * Step delay in milliseconds (between execution steps)
+   * Default: 0ms (no delay)
+   */
+  stepDelay: number;
+  /**
+   * Execution speed multiplier
+   * 1.0 = normal speed, 0.5 = half speed, 2.0 = double speed
+   * Default: 1.0
+   */
+  executionSpeed: number;
+  /**
+   * Set the number of active runs
+   */
+  setActiveRuns: (count: number) => void;
+  /**
+   * Set execution state
+   */
+  setIsExecuting: (isExecuting: boolean) => void;
+  /**
+   * Set pause state
+   */
+  setIsPaused: (isPaused: boolean) => void;
+  /**
+   * Set tick interval
+   */
+  setTickInterval: (interval: number) => void;
+  /**
+   * Set step delay
+   */
+  setStepDelay: (delay: number) => void;
+  /**
+   * Set execution speed
+   */
+  setExecutionSpeed: (speed: number) => void;
+};
+declare const webWorkerGraphRunnerStoreFactory: () => StoreApi<WebWorkerGraphRunnerStore>;
+declare module '@/system/system' {
+  interface System {
+    /**
+     * Web Worker Graph Runner store
+     */
+    webWorkerGraphRunnerStore: StoreApi<WebWorkerGraphRunnerStore>;
+  }
+}
+//# sourceMappingURL=store.d.ts.map
+//#endregion
+//#region src/plugin/graphrunner-webworker/panel.d.ts
+/**
+ * Panel component for Web Worker Graph Runner
+ */
+declare function WebWorkerGraphRunnerPanel(): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/plugin/graphrunner-webworker/index.d.ts
+/**
+ * Options for the Web Worker graph runner plugin
+ */
+interface WebWorkerGraphRunnerPluginOptions {
+  /**
+   * Pre-configured Web Worker instance.
+   * The worker should be set up with the necessary registry and message handlers.
+   * The registry MUST be defined inside the worker file itself.
+   *
+   * Example:
+   * ```ts
+   * const worker = new Worker(new URL('./my-graph-worker.ts', import.meta.url), { type: 'module' });
+   * ```
+   */
+  worker: Worker;
+  /**
+   * 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 Web Worker graph execution
+ * Registers a GraphRunnerClient with a worker transport that executes graphs in a Web Worker
+ */
+declare function webWorkerGraphRunnerPluginLoader(system: System, options: WebWorkerGraphRunnerPluginOptions): Promise<void>;
+declare const webWorkerGraphRunnerPlugin: LoadablePlugin<WebWorkerGraphRunnerPluginOptions>;
+//#endregion
+//#region src/plugin/realtime/realtimeRunner.d.ts
+type RealtimeRunnerStore = {
+  engine?: Engine;
+  /** Live output values published for UI consumers (keyed by nodeId -> outputName) */
+  outputs: Record<string, Record<string, unknown>>;
+  setEngine: (engine?: Engine) => void;
+  setOutputs: (updates: Array<{
+    nodeId: string;
+    outputName: string;
+    value: unknown;
+  }>) => void;
+};
+/**
+ * RealtimeRunner keeps a small preview Engine up-to-date with the current graph.
+ * It is designed for UI previews (e.g. live node output thumbnails) and does not
+ * replace the existing `GraphRunner`.
+ */
+declare class RealtimeRunner {
+  private system;
+  private executionRegistry?;
+  private graphInstance?;
+  private engine?;
+  private scheduled;
+  private tickRafHandle?;
+  private tickTimeoutHandle?;
+  private tickLoopActive;
+  private tickInProgress;
+  private lastTickAtMs;
+  private readonly tickIntervalMs;
+  private unsubscribers;
+  private watched;
+  private lastPublished;
+  private lastGraphSignature?;
+  private annotatedOutputNodeIds;
+  readonly store: StoreApi<RealtimeRunnerStore>;
+  constructor(system: System, executionRegistry?: IRegistry);
+  getEngine(): Engine | undefined;
+  /**
+   * Get a value from a node's output socket, if available.
+   */
+  getNodeOutputValue(nodeId: string, outputName: string): unknown;
+  /**
+   * Register interest in a particular node output. Used to keep the preview runner efficient.
+   */
+  watchNodeOutput(nodeId: string, outputName: string): () => void;
+  start(): void;
+  stop(): void;
+  triggerNode(nodeId: string): void;
+  private ensureTicking;
+  private nowMs;
+  private startTickLoop;
+  private stopTickLoop;
+  private scheduleNextTick;
+  private scheduleEvaluate;
+  private stripNonSemanticMetadata;
+  private computeGraphSignature;
+  private mergeNodeAnnotationsIntoMetadata;
+  private isRealtimeOutputNode;
+  private rebuildAnnotatedOutputNodeCache;
+  private resolveSocketValueForPreview;
+  private recalculateAnnotatedOutputNodes;
+  /**
+   * Evaluate every node that a UI consumer is actively watching.
+   *
+   * Pure function graphs (e.g. the image nodes) never run during
+   * `executeAllSync()` because nothing pushes a flow fiber through them. They
+   * are normally pulled lazily when a downstream flow/event node reads their
+   * value. In the editor preview there is no such consumer, so the act of a
+   * component calling `watchNodeOutput()` is what drives evaluation: we resolve
+   * the node's upstream function graph and execute the node itself so its
+   * sockets hold a fresh value for `publishWatchedOutputs()` to read.
+   *
+   * This intentionally does not depend on the `ui.realtime` annotation , any
+   * watched output is evaluated.
+   */
+  private recalculateWatchedOutputs;
+  /**
+   * Resolve a single function node's inputs (recursively executing its upstream
+   * function graph) and execute it. Non-function nodes keep whatever value their
+   * last real execution produced. Resilient: a failure on one node is logged and
+   * does not abort evaluation of the others.
+   */
+  private evaluateNodeForPreview;
+  private rebuildEngine;
+  private publishWatchedOutputs;
+  private evaluate;
+  private tick;
+}
+//#endregion
+export { AUTOSAVE_DEFAULTS, AUTOSAVE_ENABLED, AUTOSAVE_INTERVAL_SECONDS, AUTOSAVE_MAX_COPIES, AUTOSAVE_SETTINGS, AUTOSAVE_STORAGE_KEY, ActiveGraphStore, AddNodeMessage, AffectedNodesMessage, AlignmentAxis, AlignmentType, AnnotatedOutput, AuthCredentials, AutosavePluginOptions, BACKUP_PANEL_TAB_ID, BackupController, BackupControllerStore, BackupSnapshot, BackupStorage, BasePanel, BatchGetStatusMessage, BatchRunStartedMessage, BatchStatusMessage, BehaveNodeProps, CapabilitiesMessage, CloseSessionMessage, Command, CommandContext, CommandStore, CompletedMessage, ConnectionConfig, ConnectionInfo, ContextMenuItem, ContextMenuStore, ContextMenuTarget, ContributionApplier, ContributionResolver, ControlComponent, ControlProps, ControlsStore, ConversionRule, ConversionStore, CreateLinkMessage, CreateSessionMessage, DEFAULT_SETTINGS, DefaultSessionFactory, DirectExecuteNodeMessage, Direction, DocumentationStore, EditorProvider, EditorPubSys, EditorSettingsJSON, System as EditorSystem, System, ErrorCode, ErrorMessage, EventEmittedMessage, EventFilter, ExtendedNodeSpecJSON, FloatingToolbar, Flow, GetCapabilitiesMessage, GetNodeTypesMessage, GetRunHistoryMessage, GetServerEventsMessage, GetServerVariablesMessage, GetSocketConstraintsMessage, GetStatusMessage, GraphListMessage, GraphProvider, GraphProviderProps, GraphPubSys, GraphRegisteredMessage, GraphRunController, GraphRunner, GraphRunnerCapabilities, GraphRunnerClient, GraphRunnerClientConfig, GraphRunnerClientPluginOptions, GraphRunnerClientStore, GraphRunnerMessage, GraphRunnerPanel, GraphSession, HelloMessage, IExecutionControl, IGraphSession, IMenuItemElement, INodeRegistry, ISystem, ITransport, Icon, InputSocketProps, LAYOUT_TYPE, LEGACY_COMMENT_NODE_TYPE, LayoutAlgorithm, LayoutController, LayoutType, LinkCreatedMessage, LinkRemovedMessage, ListGraphsMessage, LoadManifestOptions, LoadablePlugin, LocalGraphRunnerPanel, LocalGraphRunnerPluginOptions, LocalGraphRunnerStore, LocalTransport, LogMessage, MIN_INTERVAL_SECONDS, ManifestPluginOptions, MenuItemElement, MessageActivity, NOTE_NODE_TYPE, Node, NodeAddedMessage, NodeDocumentation, NodeMetadata, NodeParamUpdatedMessage, NodePicker, NodePickerFilters, NodePickerProps, NodePickerViewMode, NodeRemovedMessage, NodeSocket, NodeTypesMessage, NoteNode, Options, OutputSocketProps, PersistenceAdapter, PingMessage, Plugin, PluginOpts, PongMessage, PubSys, RealtimeRunner, RealtimeRunnerStore, RegisterGraphMessage, RemoveLinkMessage, RemoveNodeMessage, ResumeSessionMessage, RunControllerStore, RunGraphMessage, RunHistoryMessage, RunPerformance, RunStartedMessage, RunStatus, ServerEvent, ServerEventsMessage, ServerGraphListMessage, ServerGraphRegisteredMessage, ServerGraphRunnerMessage, ServerPongMessage, ServerVariable, ServerVariablesMessage, ServerWelcomeMessage, Session, SessionClosedMessage, SessionConfig, SessionCreatedMessage, SessionExtension, SessionExtensionCleanup, SessionFactory, SessionHooks, SessionManager, SessionResumedMessage, SettingControlProps, SettingDescriptor, SettingEnumOption, SettingsSchemaStore, SettingsStorage, SettingsValues, SocketConstraint, SocketConstraintsMessage, SocketGenerator, SocketGeneratorNode, SocketGeneratorRenderProps, SocketGeneratorStore, Specific, SpecificNode, SpecificRenderProps, SpecificStore, StatusMessage, StopGraphMessage, StoppedMessage, SubscribeMessage, SystemContext, SystemProvider, SystemProviderProps, ToolbarButton, ToolbarButtonGroup, ToolbarStore, TraceBatchEvent, TraceBatchMessage, TraceMessage, TransportConfig, TransportState, UIGraphData, UIGraphJSON, UnsubscribeMessage, UpdateNodeParamMessage, UpdateSocketValueMessage, ValidateGraphMessage, ValidationResultMessage, ValueTypeMetadata, Variable, VariableChangedMessage, VariableJSON, WebSocketTransport, WebWorkerGraphRunnerPanel, WebWorkerGraphRunnerPluginOptions, WebWorkerGraphRunnerStore, WelcomeMessage, WorkerTransport, alignmentPlugin, annotatedTitle, applyAutoLayout, applyContribution, applyDagreLayout, applyElkLayout, autoLayout, autosavePlugin, behaveToFlow, calculateNewEdge, categoryColorMap, commandStoreFactory, contextMenuStoreFactory, contributionAppliers, controlsStoreFactory, conversionStoreFactory, defaultPersistenceAdapter, deleteNote, description, docsPlugin, docsPluginLoader, documentationStoreFactory, downloadJson, duplicateNote, executing, extractNodeMetadata, flowToBehave, getNodePickerFilters, getSocketsByNodeTypeAndHandleType, graphRunnerClientPlugin, graphRunnerClientPluginLoader, graphRunnerClientStoreFactory, hasPositionMetaData, hidden, installPersistence, isHandleConnected, isNoteNode, isValidConnection, kitchenSinkPlugin, layerId, layoutPlugin, loadManifest, localGraphRunnerPlugin, localGraphRunnerPluginLoader, localGraphRunnerStoreFactory, manifestPlugin, manifestPluginLoader, nonDeletable, noteAt, notesPlugin, passthroughValueType, pinned, plugin, readonly, realtime, registerDefaultCommands, registerDefaultContextMenu, registerDefaults, reorderNote, resetable, serializeVariable, settingsSchemaStoreFactory, setupSessionActions, sleep, socketGeneratorStoreFactory, specificStoreFactory, subscribeToRef, supportsExecutionControl, toolbarStoreFactory, uiVersion, useActiveGraph, useBehaveGraphFlow, useChangeNodeData, useEditor, useFlowHandlers, useGraph, useOnPressKey, useRefFromStore, useSystem, webWorkerGraphRunnerPlugin, webWorkerGraphRunnerPluginLoader, webWorkerGraphRunnerStoreFactory, writeVariablesToJSON };
+//# sourceMappingURL=index.d.ts.map