@statelyai/graph 0.4.0 → 0.6.0

package/dist/algorithms.d.mts

@@ -1,10 +1,12 @@
-import { C as TraversalOptions, _ as MSTOptions, b as PathOptions, c as Graph, h as GraphPath, p as GraphNode, t as AllPairsShortestPathsOptions, x as SinglePathOptions } from "./types-Bq_fmLwW.mjs";
+import { C as SinglePathOptions, S as PathOptions, T as TraversalOptions, _ as GraphPath, h as GraphNode, n as AllPairsShortestPathsOptions, t as AStarOptions, u as Graph, y as MSTOptions } from "./types-DF-HNw50.mjs";
 
 //#region src/algorithms.d.ts
 
 /**
  * Breadth-first traversal generator yielding nodes level by level.
  *
+ * **O(V + E)** time, **O(V)** space.
+ *
  * @example
  * ```ts
  * import { createGraph, bfs } from '@statelyai/graph';
@@ -23,6 +25,8 @@ declare function bfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N
 /**
  * Depth-first traversal generator yielding nodes as visited.
  *
+ * **O(V + E)** time, **O(V)** space.
+ *
  * @example
  * ```ts
  * import { createGraph, dfs } from '@statelyai/graph';
@@ -41,6 +45,8 @@ declare function dfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N
 /**
  * Checks whether the graph contains no cycles.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isAcyclic } from '@statelyai/graph';
@@ -58,6 +64,8 @@ declare function isAcyclic(graph: Graph): boolean;
  * Returns connected components as arrays of nodes.
  * Treats all edges as undirected for connectivity.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getConnectedComponents } from '@statelyai/graph';
@@ -75,6 +83,8 @@ declare function getConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
 /**
  * Returns a topological ordering of nodes, or `null` if the graph is cyclic.
  *
+ * **O(V + E)** time (Kahn's algorithm).
+ *
  * @example
  * ```ts
  * import { createGraph, getTopologicalSort } from '@statelyai/graph';
@@ -95,6 +105,8 @@ declare function getTopologicalSort<N>(graph: Graph<N>): GraphNode<N>[] | null;
 /**
  * Checks whether a path exists between two nodes.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, hasPath } from '@statelyai/graph';
@@ -112,6 +124,8 @@ declare function hasPath(graph: Graph, sourceId: string, targetId: string): bool
 /**
  * Checks whether the graph is connected (all nodes reachable from any node).
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isConnected } from '@statelyai/graph';
@@ -128,6 +142,8 @@ declare function isConnected(graph: Graph): boolean;
 /**
  * Checks whether the graph is a tree (connected and acyclic).
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isTree } from '@statelyai/graph';
@@ -148,6 +164,9 @@ declare function isTree(graph: Graph): boolean;
  * Lazily yields all shortest paths from a source node.
  * Use `getShortestPaths` for the full array.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted),
+ * plus **O(P)** per path yielded where P is the path length.
+ *
  * @example
  * ```ts
  * import { createGraph, genShortestPaths } from '@statelyai/graph';
@@ -171,6 +190,8 @@ declare function genShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E
  * Returns all shortest paths from a source node as an array.
  * Delegates to `genShortestPaths` internally.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, getShortestPaths } from '@statelyai/graph';
@@ -192,6 +213,8 @@ declare function getShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E
 /**
  * Returns a single shortest path from source to target, or `undefined` if unreachable.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, getShortestPath } from '@statelyai/graph';
@@ -214,6 +237,8 @@ declare function getShortestPath<N, E>(graph: Graph<N, E>, opts: SinglePathOptio
  * Returns all simple (acyclic) paths from a source node as an array.
  * Delegates to `genSimplePaths` internally.
  *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
  * @example
  * ```ts
  * import { createGraph, getSimplePaths } from '@statelyai/graph';
@@ -237,6 +262,8 @@ declare function getSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>)
  * Lazily yields all simple (acyclic) paths from a source node via DFS backtracking.
  * Use `getSimplePaths` for the full array.
  *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
  * @example
  * ```ts
  * import { createGraph, genSimplePaths } from '@statelyai/graph';
@@ -261,6 +288,8 @@ declare function genSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>)
 /**
  * Returns a single simple (acyclic) path from source to target, or `undefined` if unreachable.
  *
+ * **O(V + E)** typical, **O(V!)** worst-case.
+ *
  * @example
  * ```ts
  * import { createGraph, getSimplePath } from '@statelyai/graph';
@@ -283,6 +312,8 @@ declare function getSimplePath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions
  * Returns strongly connected components using Tarjan's algorithm.
  * Only meaningful for directed graphs.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getStronglyConnectedComponents } from '@statelyai/graph';
@@ -305,6 +336,8 @@ declare function getStronglyConnectedComponents<N>(graph: Graph<N>): GraphNode<N
  * Returns all elementary cycles as an array of paths.
  * Delegates to `genCycles` internally.
  *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getCycles } from '@statelyai/graph';
@@ -326,6 +359,8 @@ declare function getCycles<N, E>(graph: Graph<N, E>): GraphPath<N, E>[];
  * Lazily yields elementary cycles one at a time.
  * Use `getCycles` for the full array.
  *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genCycles } from '@statelyai/graph';
@@ -348,6 +383,8 @@ declare function genCycles<N, E>(graph: Graph<N, E>): Generator<GraphPath<N, E>>
  * Returns a single canonical preorder (DFS visit-order) sequence.
  * Visits neighbors in the order they appear in the adjacency list.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getPreorder } from '@statelyai/graph';
@@ -370,6 +407,8 @@ declare function getPreorder<N>(graph: Graph<N>, opts?: TraversalOptions): Graph
  * Returns a single canonical postorder (DFS finish-order) sequence.
  * Visits neighbors in the order they appear in the adjacency list.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getPostorder } from '@statelyai/graph';
@@ -391,6 +430,8 @@ declare function getPostorder<N>(graph: Graph<N>, opts?: TraversalOptions): Grap
 /**
  * Returns all possible preorder sequences as an array. Can be exponential -- prefer `genPreorders`.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getPreorders } from '@statelyai/graph';
@@ -412,6 +453,8 @@ declare function getPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Grap
 /**
  * Returns all possible postorder sequences as an array. Can be exponential -- prefer `genPostorders`.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getPostorders } from '@statelyai/graph';
@@ -435,6 +478,8 @@ declare function getPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gra
  * Different neighbor exploration orders yield different sequences.
  * Use `getPreorder()` for a single canonical ordering.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genPreorders } from '@statelyai/graph';
@@ -460,6 +505,8 @@ declare function genPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gene
  * Different neighbor exploration orders yield different sequences.
  * Use `getPostorder()` for a single canonical ordering.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genPostorders } from '@statelyai/graph';
@@ -485,6 +532,8 @@ declare function genPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gen
  * Only meaningful for connected undirected graphs (or the component reachable
  * from an arbitrary start node in directed graphs).
  *
+ * **O(E log E)** using either edge sorting (Kruskal) or a min-heap (Prim).
+ *
  * @example
  * ```ts
  * import { createGraph, getMinimumSpanningTree } from '@statelyai/graph';
@@ -509,7 +558,9 @@ declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOpti
 /**
  * Returns shortest paths between all pairs of nodes.
  * Algorithm 'dijkstra' (default): runs getShortestPaths per source node.
- * Algorithm 'floyd-warshall': classic O(V^3) dynamic programming.
+ * Algorithm 'floyd-warshall': classic dynamic programming.
+ *
+ * **O(V · (V + E) log V)** (Dijkstra) or **O(V³)** (Floyd-Warshall).
  *
  * @example
  * ```ts
@@ -528,6 +579,43 @@ declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOpti
  * ```
  */
 declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPairsShortestPathsOptions<E>): GraphPath<N, E>[];
+/**
+ * Returns a shortest path using A* search with an admissible heuristic.
+ * More efficient than Dijkstra when a good heuristic is available.
+ *
+ * **O((V + E) log V)** time with a good heuristic; degrades to Dijkstra
+ * with `heuristic: () => 0`.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getAStarPath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'a', x: 0, y: 0 },
+ *     { id: 'b', x: 1, y: 0 },
+ *     { id: 'c', x: 1, y: 1 },
+ *   ],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b', weight: 1 },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c', weight: 1 },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c', weight: 3 },
+ *   ],
+ * });
+ *
+ * const path = getAStarPath(graph, {
+ *   from: 'a',
+ *   to: 'c',
+ *   heuristic: (nodeId) => {
+ *     const node = graph.nodes.find(n => n.id === nodeId)!;
+ *     const target = graph.nodes.find(n => n.id === 'c')!;
+ *     return Math.abs(node.x! - target.x!) + Math.abs(node.y! - target.y!);
+ *   },
+ * });
+ * // path: a -> b -> c (weight 2, cheaper than direct a -> c)
+ * ```
+ */
+declare function getAStarPath<N, E>(graph: Graph<N, E>, opts: AStarOptions<E>): GraphPath<N, E> | undefined;
 /**
  * Joins two paths end-to-end. The last node of the head path must equal
  * the source of the tail path (the overlap node).
@@ -556,4 +644,4 @@ declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPa
  */
 declare function joinPaths<N, E>(headPath: GraphPath<N, E>, tailPath: GraphPath<N, E>): GraphPath<N, E>;
 //#endregion
-export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };
+export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAStarPath, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };

package/dist/algorithms.mjs

@@ -1,3 +1,3 @@
-import { C as isAcyclic, E as joinPaths, S as hasPath, T as isTree, _ as getShortestPaths, a as genPreorders, b as getStronglyConnectedComponents, c as getAllPairsShortestPaths, d as getMinimumSpanningTree, f as getPostorder, g as getShortestPath, h as getPreorders, i as genPostorders, l as getConnectedComponents, m as getPreorder, n as dfs, o as genShortestPaths, p as getPostorders, r as genCycles, s as genSimplePaths, t as bfs, u as getCycles, v as getSimplePath, w as isConnected, x as getTopologicalSort, y as getSimplePaths } from "./algorithms-CnTmuX9t.mjs";
+import { C as hasPath, D as joinPaths, E as isTree, S as getTopologicalSort, T as isConnected, _ as getShortestPath, a as genPreorders, b as getSimplePaths, c as getAStarPath, d as getCycles, f as getMinimumSpanningTree, g as getPreorders, h as getPreorder, i as genPostorders, l as getAllPairsShortestPaths, m as getPostorders, n as dfs, o as genShortestPaths, p as getPostorder, r as genCycles, s as genSimplePaths, t as bfs, u as getConnectedComponents, v as getShortestPaths, w as isAcyclic, x as getStronglyConnectedComponents, y as getSimplePath } from "./algorithms-oVD9PYil.mjs";
 
-export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };
+export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAStarPath, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };

package/dist/{converter-C5DlzzHs.mjs → converter-B5CUD0r9.mjs}

@@ -1,5 +1,5 @@
-import { n as toAdjacencyList, t as fromAdjacencyList } from "./adjacency-list-Bv4tfiM3.mjs";
-import { n as toEdgeList, t as fromEdgeList } from "./edge-list-R1SUbHwe.mjs";
+import { n as toAdjacencyList, t as fromAdjacencyList } from "./adjacency-list-fldj-QAL.mjs";
+import { n as toEdgeList, t as fromEdgeList } from "./edge-list-Br05wXMg.mjs";
 
 //#region src/formats/converter/index.ts
 /**

package/dist/formats/adjacency-list/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph } from "../../types-Bq_fmLwW.mjs";
+import { u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/adjacency-list/index.d.ts
 

package/dist/formats/adjacency-list/index.mjs

@@ -1,3 +1,3 @@
-import { n as toAdjacencyList, t as fromAdjacencyList } from "../../adjacency-list-Bv4tfiM3.mjs";
+import { n as toAdjacencyList, t as fromAdjacencyList } from "../../adjacency-list-fldj-QAL.mjs";
 
 export { fromAdjacencyList, toAdjacencyList };

package/dist/formats/converter/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/converter/index.d.ts
 
@@ -18,7 +18,7 @@ import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs"
  * const graph = yamlConverter.from(yaml);
  * ```
  */
-declare function createFormatConverter<TSerial>(to: (graph: Graph) => TSerial, from: (input: TSerial) => Graph): GraphFormatConverter<TSerial>;
+declare function createFormatConverter<TSerial, N = any, E = any, G = any>(to: (graph: Graph<N, E, G>) => TSerial, from: (input: TSerial) => Graph<N, E, G>): GraphFormatConverter<TSerial, N, E, G>;
 /**
  * Bidirectional converter for adjacency-list format (`Record<string, string[]>`).
  *

package/dist/formats/converter/index.mjs

@@ -1,3 +1,3 @@
-import { n as createFormatConverter, r as edgeListConverter, t as adjacencyListConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter, r as edgeListConverter, t as adjacencyListConverter } from "../../converter-B5CUD0r9.mjs";
 
 export { adjacencyListConverter, createFormatConverter, edgeListConverter };

package/dist/formats/cytoscape/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/cytoscape/index.d.ts
 interface CytoscapeNode {

package/dist/formats/cytoscape/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter } from "../../converter-B5CUD0r9.mjs";
 
 //#region src/formats/cytoscape/index.ts
 /**

package/dist/formats/d3/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/d3/index.d.ts
 interface D3Node {

package/dist/formats/d3/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter } from "../../converter-B5CUD0r9.mjs";
 
 //#region src/formats/d3/index.ts
 /**

package/dist/formats/dot/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/dot/index.d.ts
 

package/dist/formats/dot/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter } from "../../converter-B5CUD0r9.mjs";
 import parse from "dotparser";
 
 //#region src/formats/dot/index.ts

package/dist/formats/edge-list/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph } from "../../types-Bq_fmLwW.mjs";
+import { u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/edge-list/index.d.ts
 

package/dist/formats/edge-list/index.mjs

@@ -1,3 +1,3 @@
-import { n as toEdgeList, t as fromEdgeList } from "../../edge-list-R1SUbHwe.mjs";
+import { n as toEdgeList, t as fromEdgeList } from "../../edge-list-Br05wXMg.mjs";
 
 export { fromEdgeList, toEdgeList };

package/dist/formats/elk/index.d.mts

@@ -0,0 +1,61 @@
+import { D as VisualGraph, k as VisualGraphFormatConverter } from "../../types-DF-HNw50.mjs";
+import { ElkEdge, ElkEdgeSection, ElkExtendedEdge, ElkGraphElement, ElkLabel, ElkNode, ElkNode as ElkNode$1, ElkPoint, ElkPort, ElkPrimitiveEdge, ElkShape, LayoutOptions } from "elkjs/lib/elk-api";
+
+//#region src/formats/elk/index.d.ts
+
+/**
+ * Converts a visual graph to ELK JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createVisualGraph } from '@statelyai/graph';
+ * import { toELK } from '@statelyai/graph/elk';
+ *
+ * const graph = createVisualGraph({
+ *   nodes: [
+ *     { id: 'a', x: 0, y: 0, width: 100, height: 50 },
+ *     { id: 'b', x: 200, y: 0, width: 100, height: 50 },
+ *   ],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const elk = toELK(graph);
+ * // { id: '', children: [...], edges: [...] }
+ * ```
+ */
+declare function toELK(graph: VisualGraph): ElkNode$1;
+/**
+ * Parses an ELK JSON node into a visual graph.
+ *
+ * @example
+ * ```ts
+ * import { fromELK } from '@statelyai/graph/elk';
+ *
+ * const graph = fromELK({
+ *   id: 'root',
+ *   children: [
+ *     { id: 'a', x: 0, y: 0, width: 100, height: 50 },
+ *     { id: 'b', x: 200, y: 0, width: 100, height: 50 },
+ *   ],
+ *   edges: [{ id: 'e1', sources: ['a'], targets: ['b'] }],
+ * });
+ *
+ * graph.nodes; // [{id: 'a', x: 0, y: 0, ...}, {id: 'b', x: 200, ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}]
+ * ```
+ */
+declare function fromELK(elkRoot: ElkNode$1): VisualGraph;
+/**
+ * Bidirectional converter for ELK JSON format.
+ *
+ * @example
+ * ```ts
+ * import { elkConverter } from '@statelyai/graph/elk';
+ *
+ * const elk = elkConverter.to(graph);
+ * const roundTripped = elkConverter.from(elk);
+ * ```
+ */
+declare const elkConverter: VisualGraphFormatConverter<ElkNode$1>;
+//#endregion
+export { type ElkEdge, type ElkEdgeSection, type ElkExtendedEdge, type ElkGraphElement, type ElkLabel, type ElkNode, type ElkPoint, type ElkPort, type ElkPrimitiveEdge, type ElkShape, type LayoutOptions, elkConverter, fromELK, toELK };

package/dist/formats/elk/index.mjs

@@ -0,0 +1,176 @@
+import { getChildren } from "../../queries.mjs";
+
+//#region src/formats/elk/index.ts
+const DIRECTION_TO_ELK = {
+	down: "DOWN",
+	up: "UP",
+	right: "RIGHT",
+	left: "LEFT"
+};
+const ELK_TO_DIRECTION = {
+	DOWN: "down",
+	UP: "up",
+	RIGHT: "right",
+	LEFT: "left"
+};
+function convertEdge(edge) {
+	const elkEdge = {
+		id: edge.id,
+		sources: [edge.sourceId],
+		targets: [edge.targetId]
+	};
+	if (edge.label) elkEdge.labels = [{ text: edge.label }];
+	return elkEdge;
+}
+function convertNode(graph, node) {
+	const elkNode = {
+		id: node.id,
+		x: node.x,
+		y: node.y,
+		width: node.width,
+		height: node.height
+	};
+	if (node.label) elkNode.labels = [{ text: node.label }];
+	const children = getChildren(graph, node.id);
+	if (children.length > 0) {
+		elkNode.children = children.map((child) => convertNode(graph, child));
+		const descendantIds = /* @__PURE__ */ new Set();
+		collectDescendants(graph, node.id, descendantIds);
+		const innerEdges = graph.edges.filter((e) => descendantIds.has(e.sourceId) && descendantIds.has(e.targetId));
+		if (innerEdges.length > 0) elkNode.edges = innerEdges.map(convertEdge);
+	}
+	return elkNode;
+}
+function collectDescendants(graph, nodeId, set) {
+	const children = getChildren(graph, nodeId);
+	for (const child of children) {
+		set.add(child.id);
+		collectDescendants(graph, child.id, set);
+	}
+}
+/**
+* Converts a visual graph to ELK JSON format.
+*
+* @example
+* ```ts
+* import { createVisualGraph } from '@statelyai/graph';
+* import { toELK } from '@statelyai/graph/elk';
+*
+* const graph = createVisualGraph({
+*   nodes: [
+*     { id: 'a', x: 0, y: 0, width: 100, height: 50 },
+*     { id: 'b', x: 200, y: 0, width: 100, height: 50 },
+*   ],
+*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const elk = toELK(graph);
+* // { id: '', children: [...], edges: [...] }
+* ```
+*/
+function toELK(graph) {
+	const root = { id: graph.id };
+	const elkDir = DIRECTION_TO_ELK[graph.direction];
+	if (elkDir) root.layoutOptions = { "elk.direction": elkDir };
+	const roots = getChildren(graph, null);
+	if (roots.length > 0) root.children = roots.map((node) => convertNode(graph, node));
+	const allInnerEdgeIds = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if (getChildren(graph, node.id).length > 0) {
+		const descendantIds = /* @__PURE__ */ new Set();
+		collectDescendants(graph, node.id, descendantIds);
+		for (const edge of graph.edges) if (descendantIds.has(edge.sourceId) && descendantIds.has(edge.targetId)) allInnerEdgeIds.add(edge.id);
+	}
+	const rootEdges = graph.edges.filter((e) => !allInnerEdgeIds.has(e.id));
+	if (rootEdges.length > 0) root.edges = rootEdges.map(convertEdge);
+	return root;
+}
+function flattenElkNodes(elkNode, parentId, nodes, edges, edgeIdx) {
+	if (elkNode.children) for (const child of elkNode.children) {
+		const label = child.labels?.[0]?.text ?? "";
+		const node = {
+			type: "node",
+			id: child.id,
+			parentId,
+			initialNodeId: null,
+			label,
+			data: void 0,
+			x: child.x ?? 0,
+			y: child.y ?? 0,
+			width: child.width ?? 0,
+			height: child.height ?? 0
+		};
+		nodes.push(node);
+		flattenElkNodes(child, child.id, nodes, edges, edgeIdx);
+	}
+	if (elkNode.edges) for (const elkEdge of elkNode.edges) for (const source of elkEdge.sources) for (const target of elkEdge.targets) {
+		const edge = {
+			type: "edge",
+			id: elkEdge.id ?? `e${edgeIdx.value++}`,
+			sourceId: source,
+			targetId: target,
+			label: elkEdge.labels?.[0]?.text ?? "",
+			data: void 0,
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		edges.push(edge);
+	}
+}
+/**
+* Parses an ELK JSON node into a visual graph.
+*
+* @example
+* ```ts
+* import { fromELK } from '@statelyai/graph/elk';
+*
+* const graph = fromELK({
+*   id: 'root',
+*   children: [
+*     { id: 'a', x: 0, y: 0, width: 100, height: 50 },
+*     { id: 'b', x: 200, y: 0, width: 100, height: 50 },
+*   ],
+*   edges: [{ id: 'e1', sources: ['a'], targets: ['b'] }],
+* });
+*
+* graph.nodes; // [{id: 'a', x: 0, y: 0, ...}, {id: 'b', x: 200, ...}]
+* graph.edges; // [{sourceId: 'a', targetId: 'b', ...}]
+* ```
+*/
+function fromELK(elkRoot) {
+	const nodes = [];
+	const edges = [];
+	flattenElkNodes(elkRoot, null, nodes, edges, { value: 0 });
+	const seenEdges = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (!seenEdges.has(edge.id)) seenEdges.set(edge.id, edge);
+	const elkDir = elkRoot.layoutOptions?.["elk.direction"];
+	const direction = (elkDir ? ELK_TO_DIRECTION[elkDir] : void 0) ?? "down";
+	return {
+		id: elkRoot.id,
+		type: "directed",
+		initialNodeId: null,
+		nodes,
+		edges: [...seenEdges.values()],
+		data: void 0,
+		direction
+	};
+}
+/**
+* Bidirectional converter for ELK JSON format.
+*
+* @example
+* ```ts
+* import { elkConverter } from '@statelyai/graph/elk';
+*
+* const elk = elkConverter.to(graph);
+* const roundTripped = elkConverter.from(elk);
+* ```
+*/
+const elkConverter = {
+	to: toELK,
+	from: fromELK
+};
+
+//#endregion
+export { elkConverter, fromELK, toELK };

package/dist/formats/gexf/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/gexf/index.d.ts
 declare function toGEXF(graph: Graph): string;

package/dist/formats/gexf/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter } from "../../converter-B5CUD0r9.mjs";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 
 //#region src/formats/gexf/index.ts

package/dist/formats/gml/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/gml/index.d.ts
 

package/dist/formats/gml/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-C5DlzzHs.mjs";
+import { n as createFormatConverter } from "../../converter-B5CUD0r9.mjs";
 
 //#region src/formats/gml/index.ts
 /**

package/dist/formats/graphml/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-Bq_fmLwW.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DF-HNw50.mjs";
 
 //#region src/formats/graphml/index.d.ts
 declare function toGraphML(graph: Graph): string;