@statelyai/graph 1.0.0 → 2.1.0

package/dist/layout/cytoscape.d.mts

@@ -0,0 +1,66 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutOptions } from "./index.mjs";
+import cytoscape from "cytoscape";
+
+//#region src/layout/cytoscape.d.ts
+
+/**
+ * Minimal interface an injected cytoscape factory must satisfy — the
+ * `cytoscape()` function itself. Inject your own when you've registered
+ * layout extensions via `cytoscape.use(...)` (cola, fcose, dagre, …).
+ */
+type CytoscapeLike = (options: cytoscape.CytoscapeOptions) => cytoscape.Core;
+interface CytoscapeLayoutOptions extends LayoutOptions {
+  /**
+   * Cytoscape layout name. Built-ins: `'grid'`, `'circle'`, `'concentric'`,
+   * `'breadthfirst'`, `'cose'` (default), `'random'`. Extension layouts work
+   * when registered on an injected {@link CytoscapeLayoutOptions.cy} factory.
+   */
+  name?: string;
+  /**
+   * Raw cytoscape layout options, merged into the layout call last (override
+   * everything, including `name`). Engine-specific tuning — spacing knobs,
+   * `boundingBox`, `roots`, iteration counts — goes here; the options vary
+   * too much between cytoscape layouts to map `LayoutOptions.spacing`
+   * generically. See https://js.cytoscape.org/#layouts
+   */
+  layoutOptions?: Record<string, unknown>;
+  /**
+   * Injected cytoscape factory — e.g. one with extensions registered via
+   * `cytoscape.use(...)`. Defaults to the imported `cytoscape`.
+   */
+  cy?: CytoscapeLike;
+}
+/**
+ * Lay out a graph with Cytoscape.js (`cytoscape`, an optional peer
+ * dependency) — one call unlocks its whole layout ecosystem. Pure: returns a
+ * new {@link VisualGraph} with node positions and sizes. Cytoscape layouts
+ * position nodes only; edges keep their fields but gain no route `points`.
+ * Compound graphs are supported via cytoscape `parent`; parent nodes get
+ * cytoscape's computed compound dimensions. All coordinates are absolute
+ * (cytoscape does not produce parent-relative positions).
+ *
+ * Runs headless with `styleEnabled: true` so resolved node sizes
+ * ({@link getNodeSize}) participate in overlap avoidance and spacing.
+ *
+ * Option mapping is deliberately minimal: `measure` resolves sizes,
+ * `isFixed` nodes with an existing `x`/`y` are locked in place (cytoscape
+ * layouts skip locked nodes), and everything else — including `direction`
+ * and `spacing` — is engine-specific and belongs in
+ * {@link CytoscapeLayoutOptions.layoutOptions}. `seed` is ignored: the
+ * discrete layouts (grid, circle, concentric, breadthfirst) are
+ * deterministic, and cose is not seedable.
+ *
+ * @example
+ * ```ts
+ * import { getCytoscapeLayout } from '@statelyai/graph/layout/cytoscape';
+ *
+ * const laidOut = await getCytoscapeLayout(graph, {
+ *   name: 'breadthfirst',
+ *   layoutOptions: { roots: ['start'] },
+ * });
+ * ```
+ */
+declare function getCytoscapeLayout(graph: Graph | VisualGraph, options?: CytoscapeLayoutOptions): Promise<VisualGraph>;
+//#endregion
+export { CytoscapeLayoutOptions, CytoscapeLike, getCytoscapeLayout };

package/dist/layout/cytoscape.mjs

@@ -0,0 +1,114 @@
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig } from "../config-Dt5u1gSf.mjs";
+import { getNodeSize } from "./index.mjs";
+import cytoscape from "cytoscape";
+
+//#region src/layout/cytoscape.ts
+/**
+* Lay out a graph with Cytoscape.js (`cytoscape`, an optional peer
+* dependency) — one call unlocks its whole layout ecosystem. Pure: returns a
+* new {@link VisualGraph} with node positions and sizes. Cytoscape layouts
+* position nodes only; edges keep their fields but gain no route `points`.
+* Compound graphs are supported via cytoscape `parent`; parent nodes get
+* cytoscape's computed compound dimensions. All coordinates are absolute
+* (cytoscape does not produce parent-relative positions).
+*
+* Runs headless with `styleEnabled: true` so resolved node sizes
+* ({@link getNodeSize}) participate in overlap avoidance and spacing.
+*
+* Option mapping is deliberately minimal: `measure` resolves sizes,
+* `isFixed` nodes with an existing `x`/`y` are locked in place (cytoscape
+* layouts skip locked nodes), and everything else — including `direction`
+* and `spacing` — is engine-specific and belongs in
+* {@link CytoscapeLayoutOptions.layoutOptions}. `seed` is ignored: the
+* discrete layouts (grid, circle, concentric, breadthfirst) are
+* deterministic, and cose is not seedable.
+*
+* @example
+* ```ts
+* import { getCytoscapeLayout } from '@statelyai/graph/layout/cytoscape';
+*
+* const laidOut = await getCytoscapeLayout(graph, {
+*   name: 'breadthfirst',
+*   layoutOptions: { roots: ['start'] },
+* });
+* ```
+*/
+async function getCytoscapeLayout(graph, options) {
+	const elements = [];
+	for (const node of graph.nodes) {
+		const size = getNodeSize(node, options);
+		const hasPosition = node.x !== void 0 && node.y !== void 0;
+		elements.push({
+			group: "nodes",
+			data: {
+				id: node.id,
+				...node.parentId != null && { parent: node.parentId },
+				width: size.width,
+				height: size.height
+			},
+			...hasPosition && { position: {
+				x: node.x + size.width / 2,
+				y: node.y + size.height / 2
+			} },
+			...hasPosition && options?.isFixed?.(node) && { locked: true }
+		});
+	}
+	for (const edge of graph.edges) elements.push({
+		group: "edges",
+		data: {
+			id: edge.id,
+			source: edge.sourceId,
+			target: edge.targetId
+		}
+	});
+	const cy = (options?.cy ?? cytoscape)({
+		headless: true,
+		styleEnabled: true,
+		style: [{
+			selector: "node",
+			style: {
+				width: "data(width)",
+				height: "data(height)",
+				shape: "rectangle"
+			}
+		}],
+		elements
+	});
+	try {
+		const layout = cy.layout({
+			name: options?.name ?? "cose",
+			animate: false,
+			...options?.layoutOptions
+		});
+		const stopped = layout.promiseOn("layoutstop");
+		layout.run();
+		await stopped;
+		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 ele = cy.getElementById(node.id);
+				const width = ele.width();
+				const height = ele.height();
+				const position = ele.position();
+				return {
+					...toNodeConfig(node),
+					width,
+					height,
+					x: position.x - width / 2,
+					y: position.y - height / 2
+				};
+			}),
+			edges: graph.edges.map((edge) => toEdgeConfig(edge))
+		});
+	} finally {
+		cy.destroy();
+	}
+}
+
+//#endregion
+export { getCytoscapeLayout };

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

@@ -0,0 +1,52 @@
+import { I as VisualGraph, f as Graph } from "../types-BAEQTwK_.mjs";
+import { LayoutFrame, LayoutOptions } from "./index.mjs";
+
+//#region src/layout/d3-force.d.ts
+interface ForceLayoutOptions extends LayoutOptions {
+  /** Target distance between linked nodes. Default: 80. */
+  linkDistance?: number;
+  /** Many-body charge strength (negative repels). Default: -300. */
+  chargeStrength?: number;
+  /** Number of simulation ticks. Default: 300 (d3's natural cooling span). */
+  iterations?: number;
+}
+/**
+ * Iterative force-directed layout via d3-force (optional peer dependency).
+ * Each `next()` advances one simulation tick and yields a {@link LayoutFrame}
+ * (top-left node positions by id + remaining `alpha`); the caller owns pacing
+ * (e.g. one tick per animation frame via {@link applyLayoutFrame}) and
+ * cancellation (stop iterating). The generator's return value is the settled
+ * {@link VisualGraph}.
+ *
+ * - Deterministic: `options.seed` drives d3's `randomSource`; the same seed
+ *   always produces the same layout.
+ * - `options.isFixed` pins nodes at their current position (d3 `fx`/`fy`).
+ * - Hierarchy is ignored (force layouts are flat); per-edge `mode` is
+ *   irrelevant (forces are symmetric).
+ *
+ * @example
+ * ```ts
+ * import { genForceLayout } from '@statelyai/graph/layout/d3-force';
+ * import { applyLayoutFrame } from '@statelyai/graph/layout';
+ *
+ * for (const frame of genForceLayout(graph, { seed: 42 })) {
+ *   applyLayoutFrame(graph, frame);
+ *   render(graph);
+ * }
+ * ```
+ */
+declare function genForceLayout(graph: Graph | VisualGraph, options?: ForceLayoutOptions): Generator<LayoutFrame, VisualGraph>;
+/**
+ * Run {@link genForceLayout} to completion and return the settled
+ * {@link VisualGraph}. Convenience for non-animated use.
+ *
+ * @example
+ * ```ts
+ * import { getForceLayout } from '@statelyai/graph/layout/d3-force';
+ *
+ * const laidOut = getForceLayout(graph, { seed: 42 });
+ * ```
+ */
+declare function getForceLayout(graph: Graph | VisualGraph, options?: ForceLayoutOptions): VisualGraph;
+//#endregion
+export { ForceLayoutOptions, genForceLayout, getForceLayout };

package/dist/layout/d3-force.mjs

@@ -0,0 +1,127 @@
+import { f as createVisualGraph, n as toNodeConfig, t as toEdgeConfig } from "../config-Dt5u1gSf.mjs";
+import { getNodeSize } from "./index.mjs";
+import { forceCenter, forceLink, forceManyBody, forceSimulation } from "d3-force";
+
+//#region src/layout/d3-force.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;
+	};
+}
+/**
+* Iterative force-directed layout via d3-force (optional peer dependency).
+* Each `next()` advances one simulation tick and yields a {@link LayoutFrame}
+* (top-left node positions by id + remaining `alpha`); the caller owns pacing
+* (e.g. one tick per animation frame via {@link applyLayoutFrame}) and
+* cancellation (stop iterating). The generator's return value is the settled
+* {@link VisualGraph}.
+*
+* - Deterministic: `options.seed` drives d3's `randomSource`; the same seed
+*   always produces the same layout.
+* - `options.isFixed` pins nodes at their current position (d3 `fx`/`fy`).
+* - Hierarchy is ignored (force layouts are flat); per-edge `mode` is
+*   irrelevant (forces are symmetric).
+*
+* @example
+* ```ts
+* import { genForceLayout } from '@statelyai/graph/layout/d3-force';
+* import { applyLayoutFrame } from '@statelyai/graph/layout';
+*
+* for (const frame of genForceLayout(graph, { seed: 42 })) {
+*   applyLayoutFrame(graph, frame);
+*   render(graph);
+* }
+* ```
+*/
+function* genForceLayout(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 simNodes = graph.nodes.map((node) => {
+		const size = getNodeSize(node, options);
+		sizes.set(node.id, size);
+		const simNode = {
+			id: node.id,
+			...size
+		};
+		if (node.x !== void 0 && node.y !== void 0) {
+			simNode.x = node.x + size.width / 2;
+			simNode.y = node.y + size.height / 2;
+			if (options?.isFixed?.(node)) {
+				simNode.fx = simNode.x;
+				simNode.fy = simNode.y;
+			}
+		} else {
+			const angle = rng() * 2 * Math.PI;
+			const radius = scatterRadius * Math.sqrt(rng());
+			simNode.x = Math.cos(angle) * radius;
+			simNode.y = Math.sin(angle) * radius;
+		}
+		return simNode;
+	});
+	const simLinks = graph.edges.filter((edge) => sizes.has(edge.sourceId) && sizes.has(edge.targetId) && edge.sourceId !== edge.targetId).map((edge) => ({
+		source: edge.sourceId,
+		target: edge.targetId
+	}));
+	const simulation = forceSimulation(simNodes).randomSource(mulberry32(options?.seed ?? 1)).force("link", forceLink(simLinks).id((d) => d.id).distance(options?.linkDistance ?? 80)).force("charge", forceManyBody().strength(options?.chargeStrength ?? -300)).force("center", forceCenter(0, 0)).stop();
+	const iterations = options?.iterations ?? 300;
+	for (let i = 0; i < iterations; i++) {
+		simulation.tick();
+		const positions = {};
+		for (const simNode of simNodes) positions[simNode.id] = {
+			x: (simNode.x ?? 0) - simNode.width / 2,
+			y: (simNode.y ?? 0) - simNode.height / 2
+		};
+		yield {
+			positions,
+			alpha: simulation.alpha()
+		};
+		if (simulation.alpha() < simulation.alphaMin()) break;
+	}
+	const byId = new Map(simNodes.map((simNode) => [simNode.id, simNode]));
+	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 simNode = byId.get(node.id);
+			return {
+				...toNodeConfig(node),
+				...size,
+				x: (simNode.x ?? 0) - size.width / 2,
+				y: (simNode.y ?? 0) - size.height / 2
+			};
+		}),
+		edges: graph.edges.map((edge) => toEdgeConfig(edge))
+	});
+}
+/**
+* Run {@link genForceLayout} to completion and return the settled
+* {@link VisualGraph}. Convenience for non-animated use.
+*
+* @example
+* ```ts
+* import { getForceLayout } from '@statelyai/graph/layout/d3-force';
+*
+* const laidOut = getForceLayout(graph, { seed: 42 });
+* ```
+*/
+function getForceLayout(graph, options) {
+	const generator = genForceLayout(graph, options);
+	for (;;) {
+		const step = generator.next();
+		if (step.done) return step.value;
+	}
+}
+
+//#endregion
+export { genForceLayout, getForceLayout };

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 };