@statelyai/graph 2.0.0 → 2.1.0

package/dist/layout/d3-hierarchy.d.mts

@@ -0,0 +1,39 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+
+//#region src/layout/d3-hierarchy.d.ts
+interface TidyTreeLayoutOptions extends LayoutOptions {
+  /**
+   * Node to use as the tree root. Defaults to `graph.initialNodeId`, falling
+   * back to the graph's zero-in-degree nodes (multiple → laid out as a
+   * forest).
+   */
+  rootId?: string;
+}
+/**
+ * Lay out a graph as a tidy tree (Reingold–Tilford) with `d3-hierarchy`
+ * (an optional peer dependency). Pure and synchronous: returns a new
+ * {@link VisualGraph} with node positions/sizes.
+ *
+ * Root selection: `options.rootId` → `graph.initialNodeId` → the graph's
+ * zero-in-degree nodes. Multiple zero-in-degree nodes are laid out as a
+ * forest (side by side under an invisible synthetic root that is dropped
+ * from the output). If no root can be found (every node has incoming edges,
+ * i.e. the graph is cyclic), this throws — pass `rootId` to break the tie.
+ *
+ * Graphs that aren't strict trees are handled via a *spanning tree*: BFS
+ * from the root over effective edge direction picks each node's tree parent
+ * (first edge to reach it); only that spanning tree drives positions. All
+ * edges — including the extra cross/forward/back edges — are preserved
+ * untouched in the output. Tidy tree does not route edges (no `points`).
+ *
+ * @example
+ * ```ts
+ * import { getTidyTreeLayout } from '@statelyai/graph/layout/d3-hierarchy';
+ *
+ * const laidOut = getTidyTreeLayout(graph, { direction: 'right' });
+ * ```
+ */
+declare function getTidyTreeLayout(graph: Graph | VisualGraph, options?: TidyTreeLayoutOptions): VisualGraph;
+//#endregion
+export { TidyTreeLayoutOptions, getTidyTreeLayout };

package/dist/layout/d3-hierarchy.mjs

@@ -0,0 +1,135 @@
+import { T as getSuccessors, w as getSources } from "../queries-BMM0XAv_.mjs";
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig, y as hasNode } from "../config-Dt5u1gSf.mjs";
+import { getNodeSize } from "./index.mjs";
+import { hierarchy, tree } from "d3-hierarchy";
+
+//#region src/layout/d3-hierarchy.ts
+const DEFAULT_NODE_SPACING = 50;
+const DEFAULT_LAYER_SPACING = 50;
+/**
+* Lay out a graph as a tidy tree (Reingold–Tilford) with `d3-hierarchy`
+* (an optional peer dependency). Pure and synchronous: returns a new
+* {@link VisualGraph} with node positions/sizes.
+*
+* Root selection: `options.rootId` → `graph.initialNodeId` → the graph's
+* zero-in-degree nodes. Multiple zero-in-degree nodes are laid out as a
+* forest (side by side under an invisible synthetic root that is dropped
+* from the output). If no root can be found (every node has incoming edges,
+* i.e. the graph is cyclic), this throws — pass `rootId` to break the tie.
+*
+* Graphs that aren't strict trees are handled via a *spanning tree*: BFS
+* from the root over effective edge direction picks each node's tree parent
+* (first edge to reach it); only that spanning tree drives positions. All
+* edges — including the extra cross/forward/back edges — are preserved
+* untouched in the output. Tidy tree does not route edges (no `points`).
+*
+* @example
+* ```ts
+* import { getTidyTreeLayout } from '@statelyai/graph/layout/d3-hierarchy';
+*
+* const laidOut = getTidyTreeLayout(graph, { direction: 'right' });
+* ```
+*/
+function getTidyTreeLayout(graph, options) {
+	const direction = options?.direction ?? graph.direction ?? "down";
+	if (graph.nodes.length === 0) return createVisualGraph({
+		id: graph.id,
+		mode: graph.mode,
+		direction,
+		data: graph.data,
+		...graph.style !== void 0 && { style: graph.style },
+		nodes: [],
+		edges: graph.edges.map(toEdgeConfig)
+	});
+	let rootIds;
+	if (options?.rootId !== void 0) {
+		if (!hasNode(graph, options.rootId)) throw new Error(`getTidyTreeLayout: rootId "${options.rootId}" does not exist in graph "${graph.id}". Pass the id of an existing node.`);
+		rootIds = [options.rootId];
+	} else if (graph.initialNodeId != null && hasNode(graph, graph.initialNodeId)) rootIds = [graph.initialNodeId];
+	else {
+		rootIds = getSources(graph).map((node) => node.id);
+		if (rootIds.length === 0) throw new Error(`getTidyTreeLayout: no tree root found in graph "${graph.id}" — all ${graph.nodes.length} nodes have incoming edges (the graph is cyclic). Pass options.rootId or set graph.initialNodeId to choose where the tree starts.`);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	const buildSpanningTree = (rootId) => {
+		const root = {
+			id: rootId,
+			children: []
+		};
+		visited.add(rootId);
+		const queue = [root];
+		while (queue.length > 0) {
+			const datum = queue.shift();
+			for (const successor of getSuccessors(graph, datum.id)) {
+				if (visited.has(successor.id)) continue;
+				visited.add(successor.id);
+				const child = {
+					id: successor.id,
+					children: []
+				};
+				datum.children.push(child);
+				queue.push(child);
+			}
+		}
+		return root;
+	};
+	const trees = rootIds.map(buildSpanningTree);
+	for (const node of graph.nodes) if (!visited.has(node.id)) trees.push(buildSpanningTree(node.id));
+	const isHorizontal = direction === "left" || direction === "right";
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	let maxBreadth = 0;
+	let maxDepth = 0;
+	for (const size of sizes.values()) {
+		maxBreadth = Math.max(maxBreadth, isHorizontal ? size.height : size.width);
+		maxDepth = Math.max(maxDepth, isHorizontal ? size.width : size.height);
+	}
+	const breadthStep = maxBreadth + (options?.spacing?.node ?? DEFAULT_NODE_SPACING);
+	const depthStep = maxDepth + (options?.spacing?.layer ?? DEFAULT_LAYER_SPACING);
+	const isForest = trees.length > 1;
+	const rootDatum = isForest ? {
+		id: null,
+		children: trees
+	} : trees[0];
+	const laidOut = tree().nodeSize([breadthStep, depthStep])(hierarchy(rootDatum));
+	const centers = /* @__PURE__ */ new Map();
+	for (const point of laidOut.descendants()) {
+		if (point.data.id === null) continue;
+		const breadth = point.x;
+		const depth = point.y - (isForest ? depthStep : 0);
+		centers.set(point.data.id, direction === "down" ? {
+			x: breadth,
+			y: depth
+		} : direction === "up" ? {
+			x: breadth,
+			y: -depth
+		} : direction === "right" ? {
+			x: depth,
+			y: breadth
+		} : {
+			x: -depth,
+			y: breadth
+		});
+	}
+	return createVisualGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		direction,
+		data: graph.data,
+		...graph.style !== void 0 && { style: graph.style },
+		nodes: graph.nodes.map((node) => {
+			const size = sizes.get(node.id);
+			const center = centers.get(node.id);
+			return {
+				...toNodeConfig(node),
+				...size,
+				x: center.x - size.width / 2,
+				y: center.y - size.height / 2
+			};
+		}),
+		edges: graph.edges.map(toEdgeConfig)
+	});
+}
+
+//#endregion
+export { getTidyTreeLayout };

package/dist/layout/dagre.d.mts

@@ -0,0 +1,32 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+
+//#region src/layout/dagre.d.ts
+interface DagreLayoutOptions extends LayoutOptions {
+  /**
+   * Raw dagre graph options, spread onto `setGraph` last (override
+   * everything). See https://github.com/dagrejs/dagre/wiki#configuring-the-layout
+   */
+  graphOptions?: Record<string, unknown>;
+}
+/**
+ * Lay out a graph with dagre (`@dagrejs/dagre`, an optional peer dependency).
+ * Pure and synchronous: returns a new {@link VisualGraph} with node
+ * positions/sizes, polyline edge `points`, and computed edge label rects
+ * (dagre's own `edge.x/y` label convention maps directly onto ours).
+ * Compound graphs are supported via dagre's `setParent`. All coordinates are
+ * absolute (dagre does not produce parent-relative positions).
+ *
+ * Per-edge `mode` is ignored by dagre (it layers everything by authored
+ * direction) — for mixed graphs prefer {@link getElkLayout}.
+ *
+ * @example
+ * ```ts
+ * import { getDagreLayout } from '@statelyai/graph/layout/dagre';
+ *
+ * const laidOut = getDagreLayout(graph, { direction: 'right' });
+ * ```
+ */
+declare function getDagreLayout(graph: Graph | VisualGraph, options?: DagreLayoutOptions): VisualGraph;
+//#endregion
+export { DagreLayoutOptions, getDagreLayout };

package/dist/layout/dagre.mjs

@@ -0,0 +1,99 @@
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig } from "../config-Dt5u1gSf.mjs";
+import { getNodeSize } from "./index.mjs";
+import dagre from "@dagrejs/dagre";
+
+//#region src/layout/dagre.ts
+const DIRECTION_TO_RANKDIR = {
+	down: "TB",
+	up: "BT",
+	right: "LR",
+	left: "RL"
+};
+/**
+* Lay out a graph with dagre (`@dagrejs/dagre`, an optional peer dependency).
+* Pure and synchronous: returns a new {@link VisualGraph} with node
+* positions/sizes, polyline edge `points`, and computed edge label rects
+* (dagre's own `edge.x/y` label convention maps directly onto ours).
+* Compound graphs are supported via dagre's `setParent`. All coordinates are
+* absolute (dagre does not produce parent-relative positions).
+*
+* Per-edge `mode` is ignored by dagre (it layers everything by authored
+* direction) — for mixed graphs prefer {@link getElkLayout}.
+*
+* @example
+* ```ts
+* import { getDagreLayout } from '@statelyai/graph/layout/dagre';
+*
+* const laidOut = getDagreLayout(graph, { direction: 'right' });
+* ```
+*/
+function getDagreLayout(graph, options) {
+	const g = new dagre.graphlib.Graph({
+		multigraph: true,
+		compound: true
+	});
+	g.setGraph({
+		rankdir: DIRECTION_TO_RANKDIR[options?.direction ?? graph.direction ?? "down"],
+		...options?.spacing?.node !== void 0 && { nodesep: options.spacing.node },
+		...options?.spacing?.layer !== void 0 && { ranksep: options.spacing.layer },
+		...options?.graphOptions
+	});
+	g.setDefaultEdgeLabel(() => ({}));
+	const sizes = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const size = getNodeSize(node, options);
+		sizes.set(node.id, size);
+		g.setNode(node.id, { ...size });
+	}
+	for (const node of graph.nodes) if (node.parentId != null) g.setParent(node.id, node.parentId);
+	for (const edge of graph.edges) {
+		const hasLabelBox = edge.label != null && edge.width !== void 0 && edge.height !== void 0 && edge.width > 0 && edge.height > 0;
+		g.setEdge(edge.sourceId, edge.targetId, hasLabelBox ? {
+			width: edge.width,
+			height: edge.height,
+			labelpos: "c"
+		} : {}, edge.id);
+	}
+	dagre.layout(g);
+	return createVisualGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		direction: options?.direction ?? graph.direction,
+		data: graph.data,
+		...graph.style !== void 0 && { style: graph.style },
+		nodes: graph.nodes.map((node) => {
+			const size = sizes.get(node.id);
+			const positioned = g.node(node.id);
+			return {
+				...toNodeConfig(node),
+				...size,
+				x: positioned.x - size.width / 2,
+				y: positioned.y - size.height / 2
+			};
+		}),
+		edges: graph.edges.map((edge) => {
+			const laidOut = g.edge(edge.sourceId, edge.targetId, edge.id);
+			const config = toEdgeConfig(edge);
+			if (laidOut?.points !== void 0) {
+				config.points = laidOut.points.map((p) => ({
+					x: p.x,
+					y: p.y
+				}));
+				config.routing = "polyline";
+			}
+			if (laidOut?.x !== void 0 && laidOut?.y !== void 0) {
+				const labelWidth = laidOut.width ?? edge.width ?? 0;
+				const labelHeight = laidOut.height ?? edge.height ?? 0;
+				config.x = laidOut.x - labelWidth / 2;
+				config.y = laidOut.y - labelHeight / 2;
+				config.width = labelWidth;
+				config.height = labelHeight;
+			}
+			return config;
+		})
+	});
+}
+
+//#endregion
+export { getDagreLayout };

package/dist/layout/elk.d.mts

@@ -0,0 +1,47 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+import { ElkNode } from "elkjs/lib/elk-api";
+
+//#region src/layout/elk.d.ts
+/** Minimal interface an injected ELK instance must satisfy. */
+interface ElkLike {
+  layout(graph: ElkNode): Promise<ElkNode>;
+}
+interface ElkLayoutOptions extends LayoutOptions {
+  /**
+   * ELK algorithm. Common choices: `'layered'` (default), `'mrtree'`,
+   * `'force'`, `'stress'`, `'radial'`, `'rectpacking'`.
+   */
+  algorithm?: string;
+  /**
+   * Raw ELK layout options, spread onto the root last (override everything).
+   * See https://eclipse.dev/elk/reference/options.html
+   */
+  layoutOptions?: Record<string, string>;
+  /**
+   * Injected ELK instance — e.g. one constructed with a web worker factory.
+   * Defaults to `new ELK()` (in-process).
+   */
+  elk?: ElkLike;
+}
+/**
+ * Lay out a graph with ELK (via `elkjs`, an optional peer dependency).
+ * Pure: returns a new {@link VisualGraph} with node positions/sizes, routed
+ * edge `points`, and computed edge label rects (edge `x`/`y`/`width`/`height`).
+ * Hierarchy (`parentId`) and ports are first-class — ELK is the engine of
+ * choice for compound and port-aware graphs. Child node coordinates are
+ * relative to their parent (matching xyflow's convention).
+ *
+ * @example
+ * ```ts
+ * import { getElkLayout } from '@statelyai/graph/layout/elk';
+ *
+ * const laidOut = await getElkLayout(graph, {
+ *   algorithm: 'layered',
+ *   measure: (node) => measureText(node.label),
+ * });
+ * ```
+ */
+declare function getElkLayout(graph: Graph | VisualGraph, options?: ElkLayoutOptions): Promise<VisualGraph>;
+//#endregion
+export { ElkLayoutOptions, ElkLike, getElkLayout };

package/dist/layout/elk.mjs

@@ -0,0 +1,73 @@
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig } from "../config-Dt5u1gSf.mjs";
+import { fromELK, toELK } from "../formats/elk/index.mjs";
+import { getNodeSize } from "./index.mjs";
+import ELK from "elkjs";
+
+//#region src/layout/elk.ts
+let defaultElk;
+/**
+* Lay out a graph with ELK (via `elkjs`, an optional peer dependency).
+* Pure: returns a new {@link VisualGraph} with node positions/sizes, routed
+* edge `points`, and computed edge label rects (edge `x`/`y`/`width`/`height`).
+* Hierarchy (`parentId`) and ports are first-class — ELK is the engine of
+* choice for compound and port-aware graphs. Child node coordinates are
+* relative to their parent (matching xyflow's convention).
+*
+* @example
+* ```ts
+* import { getElkLayout } from '@statelyai/graph/layout/elk';
+*
+* const laidOut = await getElkLayout(graph, {
+*   algorithm: 'layered',
+*   measure: (node) => measureText(node.label),
+* });
+* ```
+*/
+async function getElkLayout(graph, options) {
+	const sized = createVisualGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		direction: options?.direction ?? graph.direction,
+		data: graph.data,
+		...graph.style !== void 0 && { style: graph.style },
+		nodes: graph.nodes.map((node) => ({
+			...toNodeConfig(node),
+			...getNodeSize(node, options)
+		})),
+		edges: graph.edges.map((edge) => toEdgeConfig(edge))
+	});
+	const root = toELK(sized);
+	const layerOf = options?.constraints?.layer;
+	let hasPartitions = false;
+	if (layerOf) {
+		const nodeById = new Map(sized.nodes.map((node) => [node.id, node]));
+		const stack = [...root.children ?? []];
+		while (stack.length > 0) {
+			const child = stack.pop();
+			const node = nodeById.get(child.id);
+			const layer = node === void 0 ? void 0 : layerOf(node);
+			if (layer !== void 0) {
+				hasPartitions = true;
+				child.layoutOptions = {
+					...child.layoutOptions,
+					"elk.partitioning.partition": String(layer)
+				};
+			}
+			stack.push(...child.children ?? []);
+		}
+	}
+	root.layoutOptions = {
+		"elk.algorithm": options?.algorithm ?? "layered",
+		...hasPartitions && { "elk.partitioning.activate": "true" },
+		...options?.spacing?.node !== void 0 && { "elk.spacing.nodeNode": String(options.spacing.node) },
+		...options?.spacing?.layer !== void 0 && { "elk.layered.spacing.nodeNodeBetweenLayers": String(options.spacing.layer) },
+		...options?.seed !== void 0 && { "elk.randomSeed": String(options.seed) },
+		...root.layoutOptions,
+		...options?.layoutOptions
+	};
+	return fromELK(await (options?.elk ?? (defaultElk ??= new ELK())).layout(root));
+}
+
+//#endregion
+export { getElkLayout };

package/dist/layout/forceatlas2.d.mts

@@ -0,0 +1,48 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+import { ForceAtlas2Settings } from "graphology-layout-forceatlas2";
+
+//#region src/layout/forceatlas2.d.ts
+interface ForceAtlas2LayoutOptions extends LayoutOptions {
+  /** Number of ForceAtlas2 iterations. Default: 100. */
+  iterations?: number;
+  /**
+   * Pass-through engine settings (`scalingRatio`, `gravity`, `linLogMode`,
+   * `barnesHutOptimize`, …). See graphology-layout-forceatlas2.
+   */
+  settings?: ForceAtlas2Settings;
+}
+/**
+ * One-shot ForceAtlas2 layout via graphology (optional peer dependencies
+ * `graphology` + `graphology-layout-forceatlas2`). Runs the synchronous
+ * engine for `options.iterations` iterations and returns a positioned
+ * {@link VisualGraph}.
+ *
+ * - Deterministic: FA2 itself has no randomness, but it requires initial
+ *   positions. Positioned nodes start from their current centers
+ *   (incremental relayout); unpositioned nodes start in a seeded scatter
+ *   driven by `options.seed` — the same seed always produces the same
+ *   layout.
+ * - `options.isFixed` pins positioned nodes at their current `x`/`y` via
+ *   FA2's `fixed` node attribute (honored natively by the engine).
+ * - Per-edge `weight` feeds FA2's attraction (its default edge-weight
+ *   getter reads the `weight` attribute; tune with
+ *   `settings.edgeWeightInfluence`).
+ * - Self-loops are skipped (zero-distance edges destabilize the forces);
+ *   parallel edges are kept (multigraph). Hierarchy is ignored (force
+ *   layouts are flat).
+ *
+ * @example
+ * ```ts
+ * import { getForceAtlas2Layout } from '@statelyai/graph/layout/forceatlas2';
+ *
+ * const laidOut = getForceAtlas2Layout(graph, {
+ *   seed: 42,
+ *   iterations: 200,
+ *   settings: { gravity: 2 },
+ * });
+ * ```
+ */
+declare function getForceAtlas2Layout(graph: Graph | VisualGraph, options?: ForceAtlas2LayoutOptions): VisualGraph;
+//#endregion
+export { ForceAtlas2LayoutOptions, getForceAtlas2Layout };

package/dist/layout/forceatlas2.mjs

@@ -0,0 +1,100 @@
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig } from "../config-Dt5u1gSf.mjs";
+import { getNodeSize } from "./index.mjs";
+import GraphologyGraph from "graphology";
+import forceAtlas2 from "graphology-layout-forceatlas2";
+
+//#region src/layout/forceatlas2.ts
+/** mulberry32 — same seeded PRNG the rest of the library uses. */
+function mulberry32(seed) {
+	let s = seed | 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = Math.imul(s ^ s >>> 15, 1 | s);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* One-shot ForceAtlas2 layout via graphology (optional peer dependencies
+* `graphology` + `graphology-layout-forceatlas2`). Runs the synchronous
+* engine for `options.iterations` iterations and returns a positioned
+* {@link VisualGraph}.
+*
+* - Deterministic: FA2 itself has no randomness, but it requires initial
+*   positions. Positioned nodes start from their current centers
+*   (incremental relayout); unpositioned nodes start in a seeded scatter
+*   driven by `options.seed` — the same seed always produces the same
+*   layout.
+* - `options.isFixed` pins positioned nodes at their current `x`/`y` via
+*   FA2's `fixed` node attribute (honored natively by the engine).
+* - Per-edge `weight` feeds FA2's attraction (its default edge-weight
+*   getter reads the `weight` attribute; tune with
+*   `settings.edgeWeightInfluence`).
+* - Self-loops are skipped (zero-distance edges destabilize the forces);
+*   parallel edges are kept (multigraph). Hierarchy is ignored (force
+*   layouts are flat).
+*
+* @example
+* ```ts
+* import { getForceAtlas2Layout } from '@statelyai/graph/layout/forceatlas2';
+*
+* const laidOut = getForceAtlas2Layout(graph, {
+*   seed: 42,
+*   iterations: 200,
+*   settings: { gravity: 2 },
+* });
+* ```
+*/
+function getForceAtlas2Layout(graph, options) {
+	const rng = mulberry32(options?.seed ?? 1);
+	const sizes = /* @__PURE__ */ new Map();
+	const scatterRadius = Math.max(80, 30 * Math.sqrt(graph.nodes.length));
+	const engineGraph = new GraphologyGraph({ multi: true });
+	for (const node of graph.nodes) {
+		const size = getNodeSize(node, options);
+		sizes.set(node.id, size);
+		if (node.x !== void 0 && node.y !== void 0) engineGraph.addNode(node.id, {
+			x: node.x + size.width / 2,
+			y: node.y + size.height / 2,
+			...options?.isFixed?.(node) && { fixed: true }
+		});
+		else {
+			const angle = rng() * 2 * Math.PI;
+			const radius = scatterRadius * Math.sqrt(rng());
+			engineGraph.addNode(node.id, {
+				x: Math.cos(angle) * radius,
+				y: Math.sin(angle) * radius
+			});
+		}
+	}
+	for (const edge of graph.edges) {
+		if (!sizes.has(edge.sourceId) || !sizes.has(edge.targetId) || edge.sourceId === edge.targetId) continue;
+		engineGraph.addEdgeWithKey(edge.id, edge.sourceId, edge.targetId, edge.weight !== void 0 ? { weight: edge.weight } : {});
+	}
+	const positions = forceAtlas2(engineGraph, {
+		iterations: options?.iterations ?? 100,
+		...options?.settings !== void 0 && { settings: options.settings }
+	});
+	return createVisualGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		direction: graph.direction,
+		data: graph.data,
+		...graph.style !== void 0 && { style: graph.style },
+		nodes: graph.nodes.map((node) => {
+			const size = sizes.get(node.id);
+			const position = positions[node.id];
+			return {
+				...toNodeConfig(node),
+				...size,
+				x: position.x - size.width / 2,
+				y: position.y - size.height / 2
+			};
+		}),
+		edges: graph.edges.map((edge) => toEdgeConfig(edge))
+	});
+}
+
+//#endregion
+export { getForceAtlas2Layout };

package/dist/layout/graphviz.d.mts

@@ -0,0 +1,50 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+
+//#region src/layout/graphviz.d.ts
+/** Graphviz layout engines supported by the adapter. */
+type GraphvizEngine = 'dot' | 'neato' | 'fdp' | 'sfdp' | 'circo' | 'twopi' | 'osage' | 'patchwork';
+interface GraphvizLayoutOptions extends LayoutOptions {
+  /** Graphviz layout engine. Defaults to `'dot'`. */
+  engine?: GraphvizEngine;
+  /**
+   * Raw Graphviz graph attributes, emitted last (override everything).
+   * See https://graphviz.org/doc/info/attrs.html
+   */
+  graphAttributes?: Record<string, string>;
+}
+/**
+ * Lay out a graph with Graphviz (via `@hpcc-js/wasm-graphviz`, an optional
+ * peer dependency). Pure: returns a new {@link VisualGraph} with node
+ * positions/sizes, routed edge `points` (`routing: 'splines'` — Graphviz
+ * b-spline control points, tail → head, endpoints included), and computed
+ * edge label rects (edge `x`/`y`).
+ *
+ * Node sizes are resolved via {@link getNodeSize} and passed to Graphviz as
+ * fixed sizes, so layout never depends on Graphviz's own text measurement.
+ *
+ * Notes:
+ * - Compound graphs (`parentId`) are not supported — use `getElkLayout`, or
+ *   `getFlattenedGraph()` the graph first. (Graphviz clusters: planned.)
+ * - In a directed graph, edges with `mode: 'undirected'` are laid out as
+ *   directed but drawn without arrowheads (`dir=none`); in an undirected
+ *   graph, per-edge `mode: 'directed'` overrides are ignored (DOT `graph`
+ *   has no directed edge operator).
+ * - `options.seed` maps to the Graphviz `start` attribute (used by the
+ *   randomized engines neato/fdp/sfdp; ignored by deterministic engines).
+ * - `options.constraints.layer` maps to `{ rank=same; … }` groups (`dot`
+ *   engine only — the other engines have no rank concept).
+ *
+ * @example
+ * ```ts
+ * import { getGraphvizLayout } from '@statelyai/graph/layout/graphviz';
+ *
+ * const laidOut = await getGraphvizLayout(graph, {
+ *   engine: 'dot',
+ *   measure: (node) => measureText(node.label),
+ * });
+ * ```
+ */
+declare function getGraphvizLayout(graph: Graph | VisualGraph, options?: GraphvizLayoutOptions): Promise<VisualGraph>;
+//#endregion
+export { GraphvizEngine, GraphvizLayoutOptions, getGraphvizLayout };