@dschz/solid-flow 0.2.4 → 0.3.0-next.1

package/dist/index/index.d.ts

@@ -1,6 +1,6 @@
-import { Accessor, JSX, ParentComponent, ParentProps } from "solid-js";
+import { JSX } from "@solidjs/web";
+import { Accessor, ParentComponent, ParentProps, Store, StoreSetter } from "solid-js";
 import { Align, Align as Align$1, AriaLabelConfig, AriaLabelConfig as AriaLabelConfig$1, BezierPathOptions, BezierPathOptions as BezierPathOptions$1, Box, ColorMode, ColorMode as ColorMode$1, ColorModeClass, ColorModeClass as ColorModeClass$1, Connection, Connection as Connection$1, ConnectionLineType, ConnectionLineType as ConnectionLineType$1, ConnectionMode, ConnectionMode as ConnectionMode$1, ConnectionState, ControlLinePosition, ControlPosition, ControlPosition as ControlPosition$1, CoordinateExtent, CoordinateExtent as CoordinateExtent$1, DefaultEdgeOptionsBase, Dimensions, EdgeBase, EdgeMarker, EdgeMarkerType, EdgePosition, EdgeToolbarBaseProps, FinalConnectionState, FitBounds, FitBoundsOptions, FitBoundsOptions as FitBoundsOptions$1, FitViewOptionsBase, GetBezierPathParams, GetSmoothStepPathParams, GetStraightPathParams, Handle as Handle$1, HandleConnection, HandleConnection as HandleConnection$1, HandleProps, HandleType, InternalNodeBase, IsValidConnection, MarkerProps, MarkerType, NodeBase, NodeConnection, NodeConnection as NodeConnection$1, NodeOrigin, NodeOrigin as NodeOrigin$1, NodeProps as NodeProps$1, OnBeforeDeleteBase, OnConnect, OnConnectEnd, OnConnectEnd as OnConnectEnd$1, OnConnectStart, OnConnectStart as OnConnectStart$1, OnConnectStartParams, OnError, OnError as OnError$1, OnMove, OnMove as OnMove$1, OnMoveEnd, OnMoveEnd as OnMoveEnd$1, OnMoveStart, OnMoveStart as OnMoveStart$1, OnReconnect, OnReconnect as OnReconnect$1, OnReconnectEnd, OnReconnectEnd as OnReconnectEnd$1, OnReconnectStart, OnReconnectStart as OnReconnectStart$1, OnResize, OnResize as OnResize$1, OnResizeEnd, OnResizeEnd as OnResizeEnd$1, OnResizeStart, OnResizeStart as OnResizeStart$1, OnSelectionDrag, PanOnScrollMode, PanOnScrollMode as PanOnScrollMode$1, PanelPosition, PanelPosition as PanelPosition$1, Position as Position$1, Position as Position$2, ProOptions, ProOptions as ProOptions$1, Rect, Rect as Rect$1, ResizeControlVariant, ResizeControlVariant as ResizeControlVariant$1, ResizeDragEvent, ResizeParams, ResizeParamsWithDirection, SelectionMode, SelectionMode as SelectionMode$1, SelectionRect, SetCenter, SetCenterOptions, SetCenterOptions as SetCenterOptions$1, SetViewport, ShouldResize, ShouldResize as ShouldResize$1, SmoothStepPathOptions, SmoothStepPathOptions as SmoothStepPathOptions$1, SnapGrid, SnapGrid as SnapGrid$1, StepPathOptions, Transform, UpdateNodeInternals, Viewport, Viewport as Viewport$1, ViewportHelperFunctionOptions, ViewportHelperFunctionOptions as ViewportHelperFunctionOptions$1, XYPosition, XYPosition as XYPosition$1, XYZPosition, ZIndexMode, ZoomInOut, addEdge, getBezierEdgeCenter, getBezierPath, getConnectedEdges, getEdgeCenter, getIncomers, getNodesBounds, getOutgoers, getSmoothStepPath, getStraightPath, getViewportForBounds } from "@xyflow/system";
-import { SetStoreFunction, Store } from "solid-js/store";
 //#region src/types/node.d.ts
 /**
  * The node data structure that gets used for internal nodes.
@@ -142,6 +142,13 @@ type EdgeTypes = { [K in string]: {
   bivarianceHack(props: EdgeProps<Record<string, unknown>, string | undefined>): JSX.Element;
 }["bivarianceHack"]; };
 type DefaultEdgeOptions = DefaultEdgeOptionsBase<Edge>;
+type EdgeLayouted<EdgeType extends Edge = Edge> = EdgeType & EdgePosition & {
+  sourceNode?: Node;
+  targetNode?: Node;
+  sourceHandleId?: string | null;
+  targetHandleId?: string | null;
+  edge: EdgeType;
+};
 //#endregion
 //#region src/types/events.d.ts
 type NodeEventWithPointer<T = PointerEvent, NodeType extends Node = Node> = ({ node, event }: {
@@ -656,6 +663,7 @@ type ResizeControlProps = NodeResizerSubProps & {
    * @example ResizeControlVariant.Handle, ResizeControlVariant.Line
    */
   readonly variant?: ResizeControlVariant$2;
+  readonly color?: string;
   readonly style?: JSX.CSSProperties;
 } & Omit<JSX.HTMLAttributes<HTMLDivElement>, "onResize" | "style">;
 declare const ResizeControl: <NodeType extends Node = Node>(props: ParentProps<ResizeControlProps>) => JSX.Element;
@@ -1153,6 +1161,158 @@ declare const SolidFlow: <NodeType extends Node = Node, EdgeType extends Edge =
 //#region src/components/SolidFlow/provider.d.ts
 declare const SolidFlowProvider: <NodeType extends Node = Node, EdgeType extends Edge = Edge>(props: ParentProps<SolidFlowProps<NodeType, EdgeType>>) => JSX.Element;
 //#endregion
+//#region src/core/projections/connections.d.ts
+/**
+ * Lookup keys for the connection index. Each edge is registered under six
+ * keys — for both of its endpoints: the node, the node+handle-type, and (when
+ * a handle id is present) the node+type+handle:
+ *   `${nodeId}` · `${nodeId}-${type}` · `${nodeId}-${type}-${handleId}`
+ */
+declare const connectionKey: (nodeId: string, type?: HandleType, handleId?: string | null) => string;
+type ConnectionsRecord = Record<string, Record<string, HandleConnection$1>>;
+//#endregion
+//#region src/core/flowState.d.ts
+/**
+ * The current selection, as one object: the pair travels together everywhere
+ * it is consumed (selection change callbacks, deletion, toolbars).
+ */
+type FlowSelection<NodeType extends Node = Node, EdgeType extends Edge = Edge> = {
+  readonly nodes: readonly NodeType[];
+  readonly edges: readonly EdgeType[];
+};
+/**
+ * The flow's data graph as one reactive struct — the canonical read surface.
+ *
+ * Every property read in a tracked scope is a live subscription; the struct
+ * itself is a stable identity for the provider's lifetime, so destructuring
+ * `const { flow } = useSolidFlow()` is safe (reactivity lives inside the
+ * property reads, not in the container). Reads in event handlers are
+ * untracked, so `flow.viewport.zoom` inside a handler is already the
+ * "imperative getter" — no extra API needed.
+ *
+ * Keyed lookups are id-keyed records (`flow.internalNodes[id]`) rather than
+ * Maps: reactive property reads, per-key granularity, and the shape the
+ * underlying projections produce natively.
+ */
+type FlowState<NodeType extends Node = Node, EdgeType extends Edge = Edge> = {
+  /** The user node graph. */
+  readonly nodes: readonly NodeType[];
+  /** The user edge graph. */
+  readonly edges: readonly EdgeType[];
+  /** Adopted nodes keyed by id: absolute positions, z order, measured dimensions, handle bounds. */
+  readonly internalNodes: Record<string, InternalNode<NodeType>>;
+  /** Screen-space edge geometry keyed by edge id; edges with missing/unmeasured endpoints have no entry. */
+  readonly layoutedEdges: Record<string, EdgeLayouted<EdgeType>>;
+  /**
+   * The connection index. Keys are built with {@link connectionKey}:
+   * `nodeId`, `nodeId-type`, and `nodeId-type-handleId`; each value maps a
+   * connection pair key to its {@link HandleConnection}.
+   */
+  readonly connections: ConnectionsRecord;
+  /** The currently selected nodes and edges. */
+  readonly selection: FlowSelection<NodeType, EdgeType>;
+  /** True once every non-hidden node has been measured. */
+  readonly nodesInitialized: boolean;
+  /** True once the pan/zoom instance exists. */
+  readonly viewportInitialized: boolean;
+  readonly viewport: Viewport$1;
+  /** The flow container's measured width in px. */
+  readonly width: number;
+  /** The flow container's measured height in px. */
+  readonly height: number;
+  /** The resolved color mode ("system" resolves to the user's preference). */
+  readonly colorMode: ColorModeClass$1;
+  /** The in-progress connection gesture state. */
+  readonly connection: ConnectionState<InternalNode<NodeType>>;
+  /** True while a node drag is in progress. */
+  readonly dragging: boolean;
+  readonly minZoom: number;
+  readonly maxZoom: number;
+  readonly nodesDraggable: boolean;
+  readonly nodesConnectable: boolean;
+  readonly elementsSelectable: boolean;
+  readonly snapGrid: SnapGrid$1 | undefined;
+};
+/**
+ * The flow's write surface: every public mutation, viewport motion, and
+ * geometry helper. Commands are stable identities — destructuring
+ * `const { commands } = useSolidFlow()` is safe.
+ */
+type FlowCommands<NodeType extends Node = Node, EdgeType extends Edge = Edge> = {
+  /** Fits the view to the graph (or to `options.nodes`). */
+  readonly fitView: (options?: FitViewOptions<NodeType>) => Promise<boolean>;
+  /** Fits the view to the given bounds. */
+  readonly fitBounds: (bounds: Rect$1, options?: FitBoundsOptions$1) => Promise<boolean>;
+  /** Zooms in by 1.2. */
+  readonly zoomIn: ZoomInOut;
+  /** Zooms out by 1 / 1.2. */
+  readonly zoomOut: ZoomInOut;
+  /** Sets the zoom level. */
+  readonly setZoom: (zoomLevel: number, options?: ViewportHelperFunctionOptions$1) => Promise<boolean>;
+  /** Centers the view on the given flow position. */
+  readonly setCenter: (x: number, y: number, options?: SetCenterOptions$1) => Promise<boolean>;
+  /** Sets the viewport. */
+  readonly setViewport: (viewport: Viewport$1, options?: ViewportHelperFunctionOptions$1) => Promise<boolean>;
+  /** Pans the viewport by the given delta. */
+  readonly panBy: (delta: XYPosition$1) => Promise<boolean>;
+  /** Converts a screen/client position to a flow position. */
+  readonly screenToFlowPosition: (clientPosition: XYPosition$1, options?: {
+    snapToGrid: boolean;
+  }) => XYPosition$1;
+  /** Converts a flow position to a screen/client position. */
+  readonly flowToScreenPosition: (flowPosition: XYPosition$1) => XYPosition$1;
+  /** Appends one or many nodes. */
+  readonly addNodes: (payload: NodeType[] | NodeType) => void;
+  /** Appends one or many edges. */
+  readonly addEdges: (payload: EdgeType[] | EdgeType) => void;
+  /** Writes the nodes root (canonical Solid store setter — mutate the draft or return a new array). */
+  readonly setNodes: StoreSetter<NodeType[]>;
+  /** Writes the edges root (canonical Solid store setter — mutate the draft or return a new array). */
+  readonly setEdges: StoreSetter<EdgeType[]>;
+  /** Merges (or replaces, with `options.replace`) a node by id. */
+  readonly updateNode: (id: string, nodeUpdate: Partial<NodeType> | ((node: NodeType) => Partial<NodeType>), options?: {
+    replace: boolean;
+  }) => void;
+  /** Merges (or replaces, with `options.replace`) a node's `data` by id. */
+  readonly updateNodeData: (id: string, dataUpdate: Partial<NodeType["data"]> | ((node: NodeType) => Partial<NodeType["data"]>), options?: {
+    replace: boolean;
+  }) => void;
+  /** Merges (or replaces, with `options.replace`) an edge by id. */
+  readonly updateEdge: (id: string, edgeUpdate: Partial<EdgeType> | ((edge: EdgeType) => Partial<EdgeType>), options?: {
+    replace: boolean;
+  }) => void;
+  /** Deletes the given nodes/edges plus connected edges, honoring `onBeforeDelete`. */
+  readonly deleteElements: (params: {
+    nodes?: (Partial<NodeType> & {
+      id: string;
+    })[];
+    edges?: (Partial<EdgeType> & {
+      id: string;
+    })[];
+  }) => Promise<{
+    deletedNodes: NodeType[];
+    deletedEdges: EdgeType[];
+  }>;
+  /** All nodes intersecting the given node or rect. */
+  readonly getIntersectingNodes: (nodeOrRect: NodeType | {
+    id: NodeType["id"];
+  } | Rect$1, partially?: boolean, nodesToIntersect?: NodeType[]) => NodeType[];
+  /** Whether the given node or rect intersects the area. */
+  readonly isNodeIntersecting: (nodeOrRect: NodeType | {
+    id: NodeType["id"];
+  } | Rect$1, area: Rect$1, partially?: boolean) => boolean;
+  /** The bounding rect of the given nodes (or node ids). */
+  readonly getNodesBounds: (nodes: (NodeType | InternalNode<NodeType> | string)[]) => Rect$1;
+  /** Requests a DOM re-measure of the given node id(s). */
+  readonly updateNodeInternals: (id: string | string[]) => void;
+  /** The nodes, edges, and viewport as a plain JSON-safe object. */
+  readonly toObject: () => {
+    nodes: NodeType[];
+    edges: EdgeType[];
+    viewport: Viewport$1;
+  };
+};
+//#endregion
 //#region src/data/createEdgeStore.d.ts
 type ExtractEdgeInfo<T> = T extends ((props: EdgeProps<infer TData, infer TType>) => unknown) ? {
   data: TData;
@@ -1236,7 +1396,7 @@ type EdgesInput<TUserEdgeTypes extends EdgeTypes> = { [K in keyof AllEdgeTypes<T
  * - Works seamlessly with both built-in and custom node types
  * - Type errors prevent invalid type names or incorrect data structures
  */
-declare const createEdgeStore: <TUserEdgeTypes extends EdgeTypes = Record<string, never>>(edges: EdgesInput<TUserEdgeTypes>[]) => readonly [Store<EdgesInput<TUserEdgeTypes>[]>, SetStoreFunction<EdgesInput<TUserEdgeTypes>[]>];
+declare const createEdgeStore: <TUserEdgeTypes extends EdgeTypes = Record<string, never>>(edges: EdgesInput<TUserEdgeTypes>[]) => readonly [Store<EdgesInput<TUserEdgeTypes>[]>, StoreSetter<EdgesInput<TUserEdgeTypes>[]>];
 //#endregion
 //#region src/data/createNodeStore.d.ts
 type ExtractNodeInfo<T> = T extends ((props: NodeProps<infer TData, infer TType>) => unknown) ? {
@@ -1316,7 +1476,7 @@ type NodesInput<TUserNodeTypes extends NodeTypes> = { [K in keyof AllNodeTypes<T
  * - Works seamlessly with both built-in and custom node types
  * - Type errors prevent invalid type names or incorrect data structures
  */
-declare const createNodeStore: <TUserNodeTypes extends NodeTypes = Record<string, never>>(nodes: NodesInput<TUserNodeTypes>[]) => readonly [Store<NodesInput<TUserNodeTypes>[]>, SetStoreFunction<NodesInput<TUserNodeTypes>[]>];
+declare const createNodeStore: <TUserNodeTypes extends NodeTypes = Record<string, never>>(nodes: NodesInput<TUserNodeTypes>[]) => readonly [Store<NodesInput<TUserNodeTypes>[]>, StoreSetter<NodesInput<TUserNodeTypes>[]>];
 //#endregion
 //#region src/hooks/useColorMode.d.ts
 /**
@@ -1428,265 +1588,62 @@ declare function useNodesData<NodeType extends Node = Node>(nodeIds: Accessor<st
 //#endregion
 //#region src/hooks/useSolidFlow.d.ts
 /**
- * Hook for accessing the SvelteFlow instance.
+ * The canonical flow API: the reactive {@link FlowState} struct plus the
+ * {@link FlowCommands} write surface. Every command is also spread onto the
+ * returned object directly for upstream (React Flow / Svelte Flow)
+ * familiarity — `useSolidFlow().fitView()` and
+ * `useSolidFlow().commands.fitView()` are the same function.
  *
- * @public
- * @returns A set of helper functions
+ * The imperative getters are deprecated: event handlers are untracked scopes
+ * in Solid, so reading `flow.viewport.zoom` (or `flow.internalNodes[id]`)
+ * inside one already IS the imperative read — no wrapper needed — while the
+ * same read in a tracked scope subscribes.
  */
-declare function useSolidFlow<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): {
-  /**
-   * Zooms viewport in by 1.2.
-   *
-   * @param options.duration - optional duration. If set, a transition will be applied
-   */
-  zoomIn: ZoomInOut;
-  /**
-   * Zooms viewport out by 1 / 1.2.
-   *
-   * @param options.duration - optional duration. If set, a transition will be applied
-   */
-  zoomOut: ZoomInOut;
-  /**
-   * Returns an internal node by id.
-   *
-   * @param id - the node id
-   * @returns the node or undefined if no node was found
-   */
-  getInternalNode: (id: string) => InternalNode<NodeType> | undefined;
-  /**
-   * Returns a node by id.
-   *
-   * @param id - the node id
-   * @returns the node or undefined if no node was found
-   */
-  getNode: (id: string) => NodeType | undefined;
-  /**
-   * Returns nodes.
-   *
-   * @returns nodes array
-   */
-  getNodes: (ids?: string[]) => NodeType[];
-  /**
-   * Returns an edge by id.
-   *
-   * @param id - the edge id
-   * @returns the edge or undefined if no edge was found
-   */
-  getEdge: (id: string) => EdgeType | undefined;
-  /**
-   * Returns edges.
-   *
-   * @returns edges array
-   */
-  getEdges: (ids?: string[]) => EdgeType[];
-  /**
-   * Add one or many nodes to your existing nodes array.
-   *
-   * @param payload - the nodes to add
-   */
-  addNodes: (payload: NodeType[] | NodeType) => void;
-  /**
-   * Add one or many edges to your existing edges array.
-   *
-   * @param payload - the edges to add
-   */
-  addEdges: (payload: EdgeType[] | EdgeType) => void;
-  /**
-   * Sets the current zoom level.
-   *
-   * @param zoomLevel - the zoom level to set
-   * @param options.duration - optional duration. If set, a transition will be applied
-   */
-  setZoom: (zoomLevel: number, options?: ViewportHelperFunctionOptions$1) => Promise<boolean>;
-  /**
-   * Returns the current zoom level.
-   *
-   * @returns current zoom as a number
-   */
-  getZoom: () => number;
-  /**
-   * Sets the center of the view to the given position.
-   *
-   * @param x - x position
-   * @param y - y position
-   * @param options.zoom - optional zoom
-   */
-  setCenter: (x: number, y: number, options?: SetCenterOptions$1) => Promise<boolean>;
-  /**
-   * Sets the current viewport.
-   *
-   * @param viewport - the viewport to set
-   * @param options.duration - optional duration. If set, a transition will be applied
-   */
-  setViewport: (viewport: Viewport$1, options?: ViewportHelperFunctionOptions$1) => Promise<boolean>;
-  /**
-   * Returns the current viewport.
-   *
-   * @returns Viewport
-   */
-  getViewport: () => Viewport$1;
-  /**
-   * Fits the view.
-   *
-   * @param options.padding - optional padding
-   * @param options.includeHiddenNodes - optional includeHiddenNodes
-   * @param options.minZoom - optional minZoom
-   * @param options.maxZoom - optional maxZoom
-   * @param options.duration - optional duration. If set, a transition will be applied
-   * @param options.nodes - optional nodes to fit the view to
-   */
-  fitView: (options?: FitViewOptions<NodeType>) => Promise<boolean>;
-  /**
-   * Returns all nodes that intersect with the given node or rect.
-   *
-   * @param node - the node or rect to check for intersections
-   * @param partially - if true, the node is considered to be intersecting if it partially overlaps with the passed node or rect
-   * @param nodes - optional nodes array to check for intersections
-   *
-   * @returns an array of intersecting nodes
-   */
-  getIntersectingNodes: (nodeOrRect: NodeType | {
-    id: NodeType["id"];
-  } | Rect$1, partially?: boolean, nodesToIntersect?: NodeType[]) => NodeType[];
-  /**
-   * Checks if the given node or rect intersects with the passed rect.
-   *
-   * @param node - the node or rect to check for intersections
-   * @param area - the rect to check for intersections
-   * @param partially - if true, the node is considered to be intersecting if it partially overlaps with the passed react
-   *
-   * @returns true if the node or rect intersects with the given area
-   */
-  isNodeIntersecting: (nodeOrRect: NodeType | {
-    id: NodeType["id"];
-  } | Rect$1, area: Rect$1, partially?: boolean) => boolean;
-  /**
-   * Fits the view to the given bounds .
-   *
-   * @param bounds - the bounds ({ x: number, y: number, width: number, height: number }) to fit the view to
-   * @param options.padding - optional padding
-   */
-  fitBounds: (bounds: Rect$1, options?: FitBoundsOptions$1) => Promise<boolean>;
-  /**
-   * Deletes nodes and edges.
-   *
-   * @param params.nodes - optional nodes array to delete
-   * @param params.edges - optional edges array to delete
-   *
-   * @returns a promise that resolves with the deleted nodes and edges
-   */
-  deleteElements: ({ nodes, edges }: {
-    nodes?: (Partial<NodeType> & {
-      id: string;
-    })[];
-    edges?: (Partial<EdgeType> & {
-      id: string;
-    })[];
-  }) => Promise<{
-    deletedNodes: NodeType[];
-    deletedEdges: EdgeType[];
-  }>;
-  /**
-   * Converts a screen / client position to a flow position.
-   *
-   * @param clientPosition - the screen / client position. When you are working with events you can use event.clientX and event.clientY
-   * @param options.snapToGrid - if true, the converted position will be snapped to the grid
-   * @returns position as { x: number, y: number }
-   *
-   * @example
-   * const flowPosition = screenToFlowPosition({ x: event.clientX, y: event.clientY })
-   */
-  screenToFlowPosition: (clientPosition: XYPosition$1, options?: {
-    snapToGrid: boolean;
-  }) => XYPosition$1;
-  /**
-   * Converts a flow position to a screen / client position.
-   *
-   * @param flowPosition - the screen / client position. When you are working with events you can use event.clientX and event.clientY
-   * @returns position as { x: number, y: number }
-   *
-   * @example
-   * const clientPosition = flowToScreenPosition({ x: node.position.x, y: node.position.y })
-   */
-  flowToScreenPosition: (flowPosition: XYPosition$1) => XYPosition$1;
-  /**
-   * Updates a node.
-   *
-   * @param id - id of the node to update
-   * @param nodeUpdate - the node update as an object or a function that receives the current node and returns the node update
-   * @param options.replace - if true, the node is replaced with the node update, otherwise the changes get merged
-   *
-   * @example
-   * updateNode('node-1', (node) => ({ position: { x: node.position.x + 10, y: node.position.y } }));
-   */
-  updateNode: (id: string, nodeUpdate: Partial<NodeType> | ((node: NodeType) => Partial<NodeType>), options?: {
-    replace: boolean;
-  }) => void;
-  /**
-   * Updates the data attribute of a node.
-   *
-   * @param id - id of the node to update
-   * @param dataUpdate - the data update as an object or a function that receives the current data and returns the data update
-   * @param options.replace - if true, the data is replaced with the data update, otherwise the changes get merged
-   *
-   * @example
-   * updateNodeData('node-1', { label: 'A new label' });
-   */
-  updateNodeData: (id: string, dataUpdate: Partial<NodeType["data"]> | ((node: NodeType) => Partial<NodeType["data"]>), options?: {
-    replace: boolean;
-  }) => void;
-  /**
-   * Returns the nodes, edges and the viewport as a JSON object.
-   *
-   * @returns the nodes, edges and the viewport as a JSON object
-   */
-  /**
-   * Updates an edge.
-   *
-   * @param id - id of the edge to update
-   * @param edgeUpdate - the edge update as an object or a function that receives the current edge and returns the edge update
-   * @param options.replace - if true, the edge is replaced with the edge update, otherwise the changes get merged
-   *
-   * @example
-   * updateNode('node-1', (node) => ({ position: { x: node.position.x + 10, y: node.position.y } }));
-   */
-  updateEdge: (id: string, edgeUpdate: Partial<EdgeType> | ((edge: EdgeType) => Partial<EdgeType>), options?: {
-    replace: boolean;
-  }) => void;
-  toObject: () => {
-    nodes: NodeType[];
-    edges: EdgeType[];
-    viewport: Viewport$1;
-  };
-  /**
-   * Returns the bounds of the given nodes or node ids.
-   *
-   * @param nodes - the nodes or node ids to calculate the bounds for
-   *
-   * @returns the bounds of the given nodes
-   */
-  getNodesBounds: (nodes: (NodeType | InternalNode<NodeType> | string)[]) => Rect$1;
-  /** Gets all connections for a given handle belonging to a specific node.
-   *
-   * @param type - handle type 'source' or 'target'
-   * @param id - the handle id (this is only needed if you have multiple handles of the same type, meaning you have to provide a unique id for each handle)
-   * @param nodeId - the node id the handle belongs to
-   * @returns an array with handle connections
-   */
-  getHandleConnections: ({ type, id, nodeId }: {
+type UseSolidFlowReturn<NodeType extends Node = Node, EdgeType extends Edge = Edge> = FlowCommands<NodeType, EdgeType> & {
+  /** The flow's data graph as one reactive struct — the canonical read surface. */
+  readonly flow: FlowState<NodeType, EdgeType>;
+  /** The flow's write surface (same functions as the spread members). */
+  readonly commands: FlowCommands<NodeType, EdgeType>;
+  /** @deprecated Read `flow.internalNodes[id]` instead. */
+  readonly getInternalNode: (id: string) => InternalNode<NodeType> | undefined;
+  /** @deprecated Read `flow.internalNodes[id]?.internals.userNode` (or find in `flow.nodes`) instead. */
+  readonly getNode: (id: string) => NodeType | undefined;
+  /** @deprecated Read `flow.nodes` (or map ids over `flow.internalNodes`) instead. */
+  readonly getNodes: (ids?: string[]) => NodeType[];
+  /** @deprecated Read `flow.edges` (or find by id) instead. */
+  readonly getEdge: (id: string) => EdgeType | undefined;
+  /** @deprecated Read `flow.edges` (or filter by ids) instead. */
+  readonly getEdges: (ids?: string[]) => EdgeType[];
+  /** @deprecated Read `flow.viewport` instead. */
+  readonly getViewport: () => Viewport$1;
+  /** @deprecated Read `flow.viewport.zoom` instead. */
+  readonly getZoom: () => number;
+  /** @deprecated Read `flow.connections[connectionKey(nodeId, type, id)]` (or use `useNodeConnections`) instead. */
+  readonly getHandleConnections: (params: {
     type: HandleType;
     nodeId: string;
     id?: string | null;
   }) => HandleConnection$1[];
 };
+/**
+ * Hook for accessing the flow instance: `{ flow, commands }` plus the
+ * commands spread at the top level for upstream familiarity.
+ *
+ * `flow` and `commands` are stable identities, so destructuring them is safe:
+ * `const { flow, commands } = useSolidFlow()`.
+ *
+ * @public
+ * @returns the flow's read struct, write surface, and deprecated aliases
+ */
+declare function useSolidFlow<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): UseSolidFlowReturn<NodeType, EdgeType>;
 //#endregion
 //#region src/hooks/useUpdateNodeInternals.d.ts
 /**
- * Hook for updating node internals.
+ * Hook for updating node internals. Sugar for `commands.updateNodeInternals`.
  *
  * @public
  * @returns function for updating node internals
  */
 declare function useUpdateNodeInternals(): UpdateNodeInternals;
 //#endregion
-export { type Align, type AriaLabelConfig, Background, type BackgroundProps, type BackgroundVariant, BaseEdge, BezierEdge, BezierEdgeInternal, type BezierEdgeProps, type BezierPathOptions, type Box, type BuiltInEdge, type BuiltInNode, type BuiltInNodeTypes, type ColorMode, type ColorModeClass, type Connection, ConnectionData, ConnectionLine, type ConnectionLineComponentProps, ConnectionLineType, ConnectionMode, ControlButton, type ControlLinePosition, type ControlPosition, Controls, type CoordinateExtent, type DefaultEdgeOptions, DefaultNode, DeleteEvents, type Dimensions, type Edge, EdgeConnection, EdgeEvents, EdgeLabel, EdgeLabelRenderer, type EdgeMarker, type EdgeMarkerType, type EdgeProps, EdgeReconnectAnchor, EdgeReconnectEvents, EdgeRenderer, EdgeToolbar, EdgeToolbarProps, type EdgeTypes, EdgeWrapper, type FitBounds, type FitBoundsOptions, FitViewOptions, type GetBezierPathParams, type GetSmoothStepPathParams, type GetStraightPathParams, GroupNode, Handle, type HandleConnection, InputNode, type InternalNode, IsValidConnection, KeyDefinition, KeyDefinitionObject, KeyModifier, Marker, MarkerDefinition, MarkerType, MiniMap, type Node, type NodeConnection, NodeEvents, NodeGraph, type NodeOrigin, type NodeProps, NodeRenderer, NodeResizer, NodeSelection, NodeSelectionEvents, NodeToolbar, NodeToolbarProps, type NodeTypes, NodeWrapper, OnBeforeDelete, OnBeforeEdgeConnect, OnBeforeReconnect, type OnConnect, type OnConnectEnd, type OnConnectStart, type OnConnectStartParams, OnDelete, OnEdgeConnect, OnEdgeCreate, type OnError, type OnMove, type OnMoveEnd, type OnMoveStart, type OnReconnect, type OnReconnectEnd, type OnReconnectStart, type OnResize, type OnResizeEnd, type OnResizeStart, OnSelectionChange, OnSelectionDrag, OutputNode, PanOnScrollMode, Pane, PaneEvents, Panel, type PanelPosition, Position$1 as Position, type ProOptions, type Rect, ResizeControl, ResizeControlVariant, type ResizeDragEvent, type ResizeParams, type ResizeParamsWithDirection, Selection, SelectionMode, type SelectionRect, type SetCenter, type SetCenterOptions, type SetViewport, ShortcutModifier, ShortcutModifierDefinition, type ShouldResize, SmoothStepEdge, SmoothStepEdgeInternal, type SmoothStepEdgeProps, type SmoothStepPathOptions, type SnapGrid, SolidFlow, SolidFlowProvider, StepEdge, StepEdgeInternal, type StepEdgeProps, StraightEdge, StraightEdgeInternal, type StraightEdgeProps, type Transform, Viewport, type ViewportHelperFunctionOptions, ViewportPortal, type XYPosition, type XYZPosition, Zoom, addEdge, createEdgeStore, createNodeStore, getBezierEdgeCenter, getBezierPath, getConnectedEdges, getEdgeCenter, getIncomers, getNodesBounds, getOutgoers, getSmoothStepPath, getStraightPath, getViewportForBounds, useColorMode, useConnection, useEdges, useHandleEdgeSelect, useInternalNode, useNodeConnections, useNodes, useNodesData, useNodesInitialized, useSolidFlow, useUpdateNodeInternals, useViewport, useViewportInitialized };
+export { type Align, type AriaLabelConfig, Background, type BackgroundProps, type BackgroundVariant, BaseEdge, BezierEdge, BezierEdgeInternal, type BezierEdgeProps, type BezierPathOptions, type Box, type BuiltInEdge, type BuiltInNode, type BuiltInNodeTypes, type ColorMode, type ColorModeClass, type Connection, ConnectionData, ConnectionLine, type ConnectionLineComponentProps, ConnectionLineType, ConnectionMode, type ConnectionsRecord, ControlButton, type ControlLinePosition, type ControlPosition, Controls, type CoordinateExtent, type DefaultEdgeOptions, DefaultNode, DeleteEvents, type Dimensions, type Edge, EdgeConnection, EdgeEvents, EdgeLabel, EdgeLabelRenderer, type EdgeMarker, type EdgeMarkerType, type EdgeProps, EdgeReconnectAnchor, EdgeReconnectEvents, EdgeRenderer, EdgeToolbar, EdgeToolbarProps, type EdgeTypes, EdgeWrapper, type FitBounds, type FitBoundsOptions, FitViewOptions, type FlowCommands, type FlowSelection, type FlowState, type GetBezierPathParams, type GetSmoothStepPathParams, type GetStraightPathParams, GroupNode, Handle, type HandleConnection, InputNode, type InternalNode, IsValidConnection, KeyDefinition, KeyDefinitionObject, KeyModifier, Marker, MarkerDefinition, MarkerType, MiniMap, type Node, type NodeConnection, NodeEvents, NodeGraph, type NodeOrigin, type NodeProps, NodeRenderer, NodeResizer, NodeSelection, NodeSelectionEvents, NodeToolbar, NodeToolbarProps, type NodeTypes, NodeWrapper, OnBeforeDelete, OnBeforeEdgeConnect, OnBeforeReconnect, type OnConnect, type OnConnectEnd, type OnConnectStart, type OnConnectStartParams, OnDelete, OnEdgeConnect, OnEdgeCreate, type OnError, type OnMove, type OnMoveEnd, type OnMoveStart, type OnReconnect, type OnReconnectEnd, type OnReconnectStart, type OnResize, type OnResizeEnd, type OnResizeStart, OnSelectionChange, OnSelectionDrag, OutputNode, PanOnScrollMode, Pane, PaneEvents, Panel, type PanelPosition, Position$1 as Position, type ProOptions, type Rect, ResizeControl, ResizeControlVariant, type ResizeDragEvent, type ResizeParams, type ResizeParamsWithDirection, Selection, SelectionMode, type SelectionRect, type SetCenter, type SetCenterOptions, type SetViewport, ShortcutModifier, ShortcutModifierDefinition, type ShouldResize, SmoothStepEdge, SmoothStepEdgeInternal, type SmoothStepEdgeProps, type SmoothStepPathOptions, type SnapGrid, SolidFlow, SolidFlowProvider, StepEdge, StepEdgeInternal, type StepEdgeProps, StraightEdge, StraightEdgeInternal, type StraightEdgeProps, type Transform, UseSolidFlowReturn, Viewport, type ViewportHelperFunctionOptions, ViewportPortal, type XYPosition, type XYZPosition, Zoom, addEdge, connectionKey, createEdgeStore, createNodeStore, getBezierEdgeCenter, getBezierPath, getConnectedEdges, getEdgeCenter, getIncomers, getNodesBounds, getOutgoers, getSmoothStepPath, getStraightPath, getViewportForBounds, useColorMode, useConnection, useEdges, useHandleEdgeSelect, useInternalNode, useNodeConnections, useNodes, useNodesData, useNodesInitialized, useSolidFlow, useUpdateNodeInternals, useViewport, useViewportInitialized };