@statelyai/layout 0.0.0

package/dist/index.mjs

@@ -0,0 +1,139 @@
+import { d as UnsupportedLayoutError, i as breakCyclesWithDepthFirstSearch, l as routeEdgesOrthogonally, n as layeredAlgorithm, o as minimizeCrossingsWithBarycenter, r as assignLayersByLongestPath, s as placeNodesInLayers, t as getLayeredLayout, u as LayoutError } from "./layered-ByNCZQgJ.mjs";
+import { a as getRandomLayout, c as rectanglePackingAlgorithm, d as fixedAlgorithm, f as getFixedLayout, i as sporeOverlapRemovalAlgorithm, l as boxAlgorithm, n as getSporeOverlapRemovalLayout, o as randomAlgorithm, r as sporeCompactionAlgorithm, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "./spore-cihb_Aht.mjs";
+import { getGraphIssues } from "@statelyai/graph";
+
+//#region src/layout.ts
+const algorithms = new Map([
+	["box", boxAlgorithm],
+	["layered", layeredAlgorithm],
+	["fixed", fixedAlgorithm],
+	["rectpacking", rectanglePackingAlgorithm],
+	["random", randomAlgorithm],
+	["sporeCompaction", sporeCompactionAlgorithm],
+	["sporeOverlap", sporeOverlapRemovalAlgorithm]
+]);
+function supportsScope(algorithm, scope) {
+	switch (scope.mode) {
+		case "full": return algorithm.capabilities.full;
+		case "incremental": return algorithm.capabilities.incremental;
+		case "partial": return algorithm.capabilities.partial;
+		case "route-only": return algorithm.capabilities.routeOnly;
+	}
+}
+function samePoints(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a.length !== b.length) return false;
+	return a.every((point, index) => {
+		const other = b[index];
+		return other !== void 0 && point.x === other.x && point.y === other.y;
+	});
+}
+function getLayoutPatches(input, output) {
+	const patches = [];
+	const outputNodes = new Map(output.nodes.map((node) => [node.id, node]));
+	const outputEdges = new Map(output.edges.map((edge) => [edge.id, edge]));
+	for (const node of input.nodes) {
+		const next = outputNodes.get(node.id);
+		if (!next) continue;
+		if (node.x !== next.x || node.y !== next.y || node.width !== next.width || node.height !== next.height || node.ports !== next.ports) patches.push({
+			op: "updateNode",
+			id: node.id,
+			data: {
+				x: next.x,
+				y: next.y,
+				width: next.width,
+				height: next.height,
+				...next.ports === void 0 ? {} : { ports: next.ports }
+			},
+			description: "Apply layout geometry"
+		});
+	}
+	for (const edge of input.edges) {
+		const next = outputEdges.get(edge.id);
+		if (!next) continue;
+		if (edge.x !== next.x || edge.y !== next.y || edge.width !== next.width || edge.height !== next.height || edge.routing !== next.routing || !samePoints(edge.points, next.points)) patches.push({
+			op: "updateEdge",
+			id: edge.id,
+			data: {
+				x: next.x,
+				y: next.y,
+				width: next.width,
+				height: next.height,
+				...next.routing === void 0 ? {} : { routing: next.routing },
+				...next.points === void 0 ? {} : { points: next.points }
+			},
+			description: "Apply layout geometry"
+		});
+	}
+	return patches;
+}
+/** Register or replace a layout algorithm for subsequent `getLayout` calls. */
+function registerLayoutAlgorithm(algorithm) {
+	const previous = algorithms.get(algorithm.id);
+	algorithms.set(algorithm.id, algorithm);
+	return () => {
+		if (previous) algorithms.set(algorithm.id, previous);
+		else algorithms.delete(algorithm.id);
+	};
+}
+function getLayoutAlgorithm(id) {
+	return algorithms.get(id);
+}
+/**
+* Run a registered or inline algorithm against an `@statelyai/graph` graph.
+* The input is not mutated.
+*/
+async function getLayout(request) {
+	const startedAt = performance.now();
+	const scope = request.scope ?? { mode: "full" };
+	const diagnostics = [];
+	const phases = [];
+	const algorithm = typeof request.algorithm === "object" ? request.algorithm : getLayoutAlgorithm(request.algorithm ?? "layered");
+	if (!algorithm) throw new LayoutError(`Unknown layout algorithm: ${request.algorithm ?? "layered"}`, "UNKNOWN_ALGORITHM");
+	if (!supportsScope(algorithm, scope)) throw new UnsupportedLayoutError(`${algorithm.id} does not support ${scope.mode} layout yet`);
+	const issues = getGraphIssues(request.graph);
+	if (issues.length > 0) throw new LayoutError(issues.map((issue) => issue.message).join("; "), "INVALID_GRAPH");
+	const context = {
+		scope,
+		diagnostics,
+		...request.signal === void 0 ? {} : { signal: request.signal },
+		measurePhase(id, run) {
+			const phaseStartedAt = performance.now();
+			const record = () => {
+				phases.push({
+					id,
+					durationMs: performance.now() - phaseStartedAt
+				});
+			};
+			try {
+				const result = run();
+				if (result instanceof Promise) return result.finally(record);
+				record();
+				return result;
+			} catch (error) {
+				record();
+				throw error;
+			}
+		},
+		throwIfAborted() {
+			if (request.signal?.aborted) throw request.signal.reason ?? /* @__PURE__ */ new Error("Layout aborted");
+		}
+	};
+	context.throwIfAborted();
+	const graph = await algorithm.layout(request.graph, request.options, context);
+	context.throwIfAborted();
+	return {
+		graph,
+		patches: getLayoutPatches(request.graph, graph),
+		diagnostics,
+		metrics: {
+			durationMs: performance.now() - startedAt,
+			nodeCount: graph.nodes.length,
+			edgeCount: graph.edges.length,
+			phases
+		}
+	};
+}
+
+//#endregion
+export { LayoutError, UnsupportedLayoutError, assignLayersByLongestPath, boxAlgorithm, breakCyclesWithDepthFirstSearch, fixedAlgorithm, getBoxLayout, getFixedLayout, getLayeredLayout, getLayout, getLayoutAlgorithm, getRandomLayout, getRectanglePackingLayout, getSporeCompactionLayout, getSporeOverlapRemovalLayout, layeredAlgorithm, minimizeCrossingsWithBarycenter, placeNodesInLayers, randomAlgorithm, rectanglePackingAlgorithm, registerLayoutAlgorithm, routeEdgesOrthogonally, sporeCompactionAlgorithm, sporeOverlapRemovalAlgorithm };

package/dist/layered/index.d.mts

@@ -0,0 +1,2 @@
+import { C as NodeSize, S as NodePlacer, _ as LayeredPhaseInput, a as minimizeCrossingsWithBarycenter, b as LayoutPadding, c as AcyclicOrientation, d as EdgeRouter, f as EdgeRoutes, g as LayeredLayoutOptions, h as LayerOrder, i as breakCyclesWithDepthFirstSearch, l as CrossingMinimizer, m as LayerAssignment, n as layeredAlgorithm, o as placeNodesInLayers, p as LayerAssigner, r as assignLayersByLongestPath, s as routeEdgesOrthogonally, t as getLayeredLayout, u as CycleBreaker, v as LayeredSpacing, x as NodePlacement, y as LayeredStrategies } from "../index-v0P1Ake8.mjs";
+export { AcyclicOrientation, CrossingMinimizer, CycleBreaker, EdgeRouter, EdgeRoutes, LayerAssigner, LayerAssignment, LayerOrder, LayeredLayoutOptions, LayeredPhaseInput, LayeredSpacing, LayeredStrategies, LayoutPadding, NodePlacement, NodePlacer, NodeSize, assignLayersByLongestPath, breakCyclesWithDepthFirstSearch, getLayeredLayout, layeredAlgorithm, minimizeCrossingsWithBarycenter, placeNodesInLayers, routeEdgesOrthogonally };

package/dist/layered/index.mjs

@@ -0,0 +1,3 @@
+import { i as breakCyclesWithDepthFirstSearch, l as routeEdgesOrthogonally, n as layeredAlgorithm, o as minimizeCrossingsWithBarycenter, r as assignLayersByLongestPath, s as placeNodesInLayers, t as getLayeredLayout } from "../layered-ByNCZQgJ.mjs";
+
+export { assignLayersByLongestPath, breakCyclesWithDepthFirstSearch, getLayeredLayout, layeredAlgorithm, minimizeCrossingsWithBarycenter, placeNodesInLayers, routeEdgesOrthogonally };

package/dist/layered-ByNCZQgJ.mjs

@@ -0,0 +1,439 @@
+//#region src/errors.ts
+var LayoutError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "LayoutError";
+	}
+};
+var UnsupportedLayoutError = class extends LayoutError {
+	constructor(message) {
+		super(message, "UNSUPPORTED_LAYOUT");
+		this.name = "UnsupportedLayoutError";
+	}
+};
+
+//#endregion
+//#region src/layered/strategies.ts
+function getOrientedEndpoints(edge, orientation) {
+	return orientation.reversedEdgeIds.has(edge.id) ? [edge.targetId, edge.sourceId] : [edge.sourceId, edge.targetId];
+}
+const breakCyclesWithDepthFirstSearch = (input) => {
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const node of input.graph.nodes) outgoing.set(node.id, []);
+	for (const edge of input.graph.edges) outgoing.get(edge.sourceId)?.push(edge);
+	const state = /* @__PURE__ */ new Map();
+	const reversedEdgeIds = /* @__PURE__ */ new Set();
+	for (const node of input.graph.nodes) {
+		if (state.get(node.id) !== void 0) continue;
+		state.set(node.id, "active");
+		const stack = [{
+			nodeId: node.id,
+			edgeIndex: 0
+		}];
+		while (stack.length > 0) {
+			const frame = stack.at(-1);
+			if (!frame) break;
+			const edge = (outgoing.get(frame.nodeId) ?? [])[frame.edgeIndex];
+			if (!edge) {
+				state.set(frame.nodeId, "done");
+				stack.pop();
+				continue;
+			}
+			frame.edgeIndex++;
+			if (edge.sourceId === edge.targetId) continue;
+			const targetState = state.get(edge.targetId);
+			if (targetState === "active") reversedEdgeIds.add(edge.id);
+			else if (targetState === void 0) {
+				state.set(edge.targetId, "active");
+				stack.push({
+					nodeId: edge.targetId,
+					edgeIndex: 0
+				});
+			}
+		}
+	}
+	return { reversedEdgeIds };
+};
+const assignLayersByLongestPath = (input, orientation) => {
+	const indegree = /* @__PURE__ */ new Map();
+	const successors = /* @__PURE__ */ new Map();
+	const layerByNodeId = /* @__PURE__ */ new Map();
+	for (const node of input.graph.nodes) {
+		indegree.set(node.id, 0);
+		successors.set(node.id, []);
+		layerByNodeId.set(node.id, input.constrainedLayerByNodeId.get(node.id) ?? 0);
+	}
+	for (const edge of input.graph.edges) {
+		const [sourceId, targetId] = getOrientedEndpoints(edge, orientation);
+		if (sourceId === targetId) continue;
+		const sourceConstraint = input.constrainedLayerByNodeId.get(sourceId);
+		const targetConstraint = input.constrainedLayerByNodeId.get(targetId);
+		if (sourceConstraint !== void 0 && targetConstraint !== void 0 && targetConstraint <= sourceConstraint) throw new LayoutError(`Layer constraints conflict on edge ${edge.id}`, "UNSATISFIABLE_CONSTRAINTS");
+		successors.get(sourceId)?.push(targetId);
+		indegree.set(targetId, (indegree.get(targetId) ?? 0) + 1);
+	}
+	const queue = input.graph.nodes.filter((node) => indegree.get(node.id) === 0).map((node) => node.id);
+	for (let index = 0; index < queue.length; index++) {
+		const sourceId = queue[index];
+		if (sourceId === void 0) continue;
+		const sourceLayer = layerByNodeId.get(sourceId) ?? 0;
+		for (const targetId of successors.get(sourceId) ?? []) {
+			const targetConstraint = input.constrainedLayerByNodeId.get(targetId);
+			if (targetConstraint !== void 0 && targetConstraint < sourceLayer + 1) throw new LayoutError(`Layer constraint conflicts at node ${targetId}`, "UNSATISFIABLE_CONSTRAINTS");
+			layerByNodeId.set(targetId, targetConstraint ?? Math.max(layerByNodeId.get(targetId) ?? 0, sourceLayer + 1));
+			const nextIndegree = (indegree.get(targetId) ?? 1) - 1;
+			indegree.set(targetId, nextIndegree);
+			if (nextIndegree === 0) queue.push(targetId);
+		}
+	}
+	return { layerByNodeId };
+};
+function sortLayerByBarycenter(layer, adjacentLayer, neighbors) {
+	const adjacentIndex = new Map(adjacentLayer.map((nodeId, index) => [nodeId, index]));
+	const originalIndex = new Map(layer.map((nodeId, index) => [nodeId, index]));
+	layer.sort((a, b) => {
+		const barycenter = (nodeId) => {
+			const positions = (neighbors.get(nodeId) ?? []).map((id) => adjacentIndex.get(id)).filter((value) => value !== void 0);
+			if (positions.length === 0) return originalIndex.get(nodeId) ?? 0;
+			return positions.reduce((sum, value) => sum + value, 0) / positions.length;
+		};
+		return barycenter(a) - barycenter(b) || (originalIndex.get(a) ?? 0) - (originalIndex.get(b) ?? 0);
+	});
+}
+function minimizeCrossingsWithBarycenter(sweeps = 4) {
+	return (input, orientation, assignment) => {
+		let maximumLayer = 0;
+		for (const layer of assignment.layerByNodeId.values()) maximumLayer = Math.max(maximumLayer, layer);
+		const layerCount = maximumLayer + 1;
+		const layers = Array.from({ length: layerCount }, () => []);
+		for (const node of input.graph.nodes) layers[assignment.layerByNodeId.get(node.id) ?? 0]?.push(node.id);
+		const predecessors = /* @__PURE__ */ new Map();
+		const successors = /* @__PURE__ */ new Map();
+		for (const node of input.graph.nodes) {
+			predecessors.set(node.id, []);
+			successors.set(node.id, []);
+		}
+		for (const edge of input.graph.edges) {
+			const [sourceId, targetId] = getOrientedEndpoints(edge, orientation);
+			if (sourceId === targetId) continue;
+			successors.get(sourceId)?.push(targetId);
+			predecessors.get(targetId)?.push(sourceId);
+		}
+		for (let sweep = 0; sweep < sweeps; sweep++) {
+			for (let layer = 1; layer < layers.length; layer++) {
+				const current = layers[layer];
+				const previous = layers[layer - 1];
+				if (current && previous) sortLayerByBarycenter(current, previous, predecessors);
+			}
+			for (let layer = layers.length - 2; layer >= 0; layer--) {
+				const current = layers[layer];
+				const next = layers[layer + 1];
+				if (current && next) sortLayerByBarycenter(current, next, successors);
+			}
+		}
+		return { layers };
+	};
+}
+function sumWithSpacing(ids, input, axis) {
+	return ids.reduce((total, id, index) => total + (input.sizes.get(id)?.[axis] ?? 0) + (index === 0 ? 0 : input.spacing.node), 0);
+}
+const placeNodesInLayers = (input, order) => {
+	const horizontal = input.direction === "left" || input.direction === "right";
+	const layerFlowSizes = order.layers.map((layer) => Math.max(0, ...layer.map((id) => horizontal ? input.sizes.get(id)?.width ?? 0 : input.sizes.get(id)?.height ?? 0)));
+	const layerCrossSizes = order.layers.map((layer) => sumWithSpacing(layer, input, horizontal ? "height" : "width"));
+	let maxCrossSize = 0;
+	for (const size of layerCrossSizes) maxCrossSize = Math.max(maxCrossSize, size);
+	const rectByNodeId = /* @__PURE__ */ new Map();
+	let flow = horizontal ? input.padding.left : input.padding.top;
+	order.layers.forEach((layer, layerIndex) => {
+		let cross = (horizontal ? input.padding.top : input.padding.left) + (maxCrossSize - (layerCrossSizes[layerIndex] ?? 0)) / 2;
+		for (const id of layer) {
+			const size = input.sizes.get(id) ?? {
+				width: 0,
+				height: 0
+			};
+			const rect = horizontal ? {
+				x: flow,
+				y: cross,
+				...size
+			} : {
+				x: cross,
+				y: flow,
+				...size
+			};
+			rectByNodeId.set(id, rect);
+			cross += (horizontal ? size.height : size.width) + input.spacing.node;
+		}
+		flow += (layerFlowSizes[layerIndex] ?? 0) + input.spacing.layer;
+	});
+	if (input.direction === "up" || input.direction === "left") {
+		let contentEnd = 0;
+		for (const rect of rectByNodeId.values()) contentEnd = Math.max(contentEnd, horizontal ? rect.x + rect.width : rect.y + rect.height);
+		const leadingPadding = horizontal ? input.padding.left : input.padding.top;
+		for (const [id, rect] of rectByNodeId) rectByNodeId.set(id, horizontal ? {
+			...rect,
+			x: contentEnd - rect.x + leadingPadding - rect.width
+		} : {
+			...rect,
+			y: contentEnd - rect.y + leadingPadding - rect.height
+		});
+	}
+	return { rectByNodeId };
+};
+function getPortPoint(node, portName, rect, fallback, direction) {
+	if (portName === void 0) return fallback;
+	const port = placePorts(node.ports, rect, direction)?.find((candidate) => candidate.name === portName);
+	if (port?.x === void 0 || port.y === void 0) return fallback;
+	return {
+		x: rect.x + port.x + (port.width ?? 0) / 2,
+		y: rect.y + port.y + (port.height ?? 0) / 2
+	};
+}
+function removeDuplicatePoints(points) {
+	return points.filter((point, index) => index === 0 || point.x !== points[index - 1]?.x || point.y !== points[index - 1]?.y);
+}
+const routeEdgesOrthogonally = (input, _orientation, placement) => {
+	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+	const pointsByEdgeId = /* @__PURE__ */ new Map();
+	const horizontal = input.direction === "left" || input.direction === "right";
+	const reverse = input.direction === "up" || input.direction === "left";
+	for (const edge of input.graph.edges) {
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		const sourceRect = placement.rectByNodeId.get(edge.sourceId);
+		const targetRect = placement.rectByNodeId.get(edge.targetId);
+		if (!source || !target || !sourceRect || !targetRect) continue;
+		if (source.id === target.id) {
+			const x = sourceRect.x + sourceRect.width;
+			const y = sourceRect.y + sourceRect.height / 2;
+			pointsByEdgeId.set(edge.id, [
+				{
+					x,
+					y
+				},
+				{
+					x: x + 24,
+					y
+				},
+				{
+					x: x + 24,
+					y: y - 24
+				},
+				{
+					x,
+					y: y - 24
+				}
+			]);
+			continue;
+		}
+		const sourceFallback = horizontal ? {
+			x: sourceRect.x + (reverse ? 0 : sourceRect.width),
+			y: sourceRect.y + sourceRect.height / 2
+		} : {
+			x: sourceRect.x + sourceRect.width / 2,
+			y: sourceRect.y + (reverse ? 0 : sourceRect.height)
+		};
+		const targetFallback = horizontal ? {
+			x: targetRect.x + (reverse ? targetRect.width : 0),
+			y: targetRect.y + targetRect.height / 2
+		} : {
+			x: targetRect.x + targetRect.width / 2,
+			y: targetRect.y + (reverse ? targetRect.height : 0)
+		};
+		const start = getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction);
+		const end = getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction);
+		const middle = horizontal ? [{
+			x: (start.x + end.x) / 2,
+			y: start.y
+		}, {
+			x: (start.x + end.x) / 2,
+			y: end.y
+		}] : [{
+			x: start.x,
+			y: (start.y + end.y) / 2
+		}, {
+			x: end.x,
+			y: (start.y + end.y) / 2
+		}];
+		pointsByEdgeId.set(edge.id, removeDuplicatePoints([
+			start,
+			...middle,
+			end
+		]));
+	}
+	return { pointsByEdgeId };
+};
+function placePorts(ports, rect, direction) {
+	if (!ports) return void 0;
+	const horizontal = direction === "left" || direction === "right";
+	const reverse = direction === "up" || direction === "left";
+	return ports.map((port, index) => {
+		const size = {
+			width: port.width ?? 8,
+			height: port.height ?? 8
+		};
+		if (port.x !== void 0 && port.y !== void 0) return {
+			...port,
+			...size
+		};
+		const ratio = (index + 1) / (ports.length + 1);
+		const outgoing = port.direction !== "in";
+		const farSide = reverse ? !outgoing : outgoing;
+		return {
+			...port,
+			...size,
+			x: horizontal ? farSide ? rect.width - size.width / 2 : -size.width / 2 : ratio * rect.width - size.width / 2,
+			y: horizontal ? ratio * rect.height - size.height / 2 : farSide ? rect.height - size.height / 2 : -size.height / 2
+		};
+	});
+}
+function getPolylineMidpoint(points) {
+	if (points.length === 0) return {
+		x: 0,
+		y: 0
+	};
+	let total = 0;
+	const lengths = [];
+	for (let index = 1; index < points.length; index++) {
+		const previous = points[index - 1];
+		const point = points[index];
+		if (!previous || !point) continue;
+		const length = Math.hypot(point.x - previous.x, point.y - previous.y);
+		lengths.push(length);
+		total += length;
+	}
+	let remaining = total / 2;
+	for (let index = 1; index < points.length; index++) {
+		const previous = points[index - 1];
+		const point = points[index];
+		const length = lengths[index - 1] ?? 0;
+		if (!previous || !point) continue;
+		if (remaining <= length) {
+			const ratio = length === 0 ? 0 : remaining / length;
+			return {
+				x: previous.x + (point.x - previous.x) * ratio,
+				y: previous.y + (point.y - previous.y) * ratio
+			};
+		}
+		remaining -= length;
+	}
+	return points.at(-1) ?? {
+		x: 0,
+		y: 0
+	};
+}
+
+//#endregion
+//#region src/layered/index.ts
+const DEFAULT_NODE_SIZE = {
+	width: 100,
+	height: 50
+};
+function getNodeSize(node, options) {
+	const measured = options.measure?.(node);
+	if (measured) return measured;
+	return {
+		width: node.width !== void 0 && node.width > 0 ? node.width : DEFAULT_NODE_SIZE.width,
+		height: node.height !== void 0 && node.height > 0 ? node.height : DEFAULT_NODE_SIZE.height
+	};
+}
+function assertFlatGraph(graph) {
+	const compoundNodeIds = graph.nodes.filter((node) => node.parentId != null).map((node) => node.id);
+	if (compoundNodeIds.length > 0) throw new UnsupportedLayoutError(`The first layered milestone supports flat graphs only; nested nodes: ${compoundNodeIds.join(", ")}`);
+}
+function runLayeredPipeline(graph, options, context) {
+	assertFlatGraph(graph);
+	const direction = options.direction ?? graph.direction ?? "down";
+	const padding = typeof options.padding === "number" ? {
+		top: options.padding,
+		right: options.padding,
+		bottom: options.padding,
+		left: options.padding
+	} : {
+		top: options.padding?.top ?? 0,
+		right: options.padding?.right ?? 0,
+		bottom: options.padding?.bottom ?? 0,
+		left: options.padding?.left ?? 0
+	};
+	const input = {
+		graph,
+		sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)])),
+		direction,
+		spacing: {
+			node: options.spacing?.node ?? 40,
+			layer: options.spacing?.layer ?? 60
+		},
+		padding,
+		constrainedLayerByNodeId: new Map(graph.nodes.flatMap((node) => {
+			const layer = options.constraints?.layer?.(node);
+			return layer === void 0 ? [] : [[node.id, layer]];
+		}))
+	};
+	const measure = (id, run) => {
+		context?.throwIfAborted();
+		return context ? context.measurePhase(id, run) : run();
+	};
+	const orientation = measure("cycle-breaking", () => (options.strategies?.breakCycles ?? breakCyclesWithDepthFirstSearch)(input));
+	const assignment = measure("layer-assignment", () => (options.strategies?.assignLayers ?? assignLayersByLongestPath)(input, orientation));
+	const order = measure("crossing-minimization", () => (options.strategies?.minimizeCrossings ?? minimizeCrossingsWithBarycenter(options.crossingSweeps))(input, orientation, assignment));
+	const placement = measure("node-placement", () => (options.strategies?.placeNodes ?? placeNodesInLayers)(input, order));
+	const routes = measure("edge-routing", () => (options.strategies?.routeEdges ?? routeEdgesOrthogonally)(input, orientation, placement));
+	const nodes = graph.nodes.map((node) => {
+		const rect = placement.rectByNodeId.get(node.id);
+		if (!rect) throw new Error(`Node placement missing for ${node.id}`);
+		const ports = placePorts(node.ports, rect, direction);
+		return {
+			...node,
+			...rect,
+			...ports === void 0 ? {} : { ports }
+		};
+	});
+	const edges = graph.edges.map((edge) => {
+		const points = [...routes.pointsByEdgeId.get(edge.id) ?? []];
+		const midpoint = getPolylineMidpoint(points);
+		const width = edge.width ?? 0;
+		const height = edge.height ?? 0;
+		return {
+			...edge,
+			x: midpoint.x - width / 2,
+			y: midpoint.y - height / 2,
+			width,
+			height,
+			points,
+			routing: "orthogonal"
+		};
+	});
+	return {
+		...graph,
+		direction,
+		nodes,
+		edges
+	};
+}
+/**
+* Deterministic native layered layout for an `@statelyai/graph` graph.
+*
+* This initial vertical slice supports flat graphs, cycles, ports, self-loops,
+* four directions, custom phase strategies, and orthogonal routes.
+*/
+function getLayeredLayout(graph, options = {}) {
+	return runLayeredPipeline(graph, options);
+}
+const layeredAlgorithm = {
+	id: "layered",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: true
+	},
+	layout(graph, options, context) {
+		return runLayeredPipeline(graph, options ?? {}, context);
+	}
+};
+
+//#endregion
+export { getPolylineMidpoint as a, placePorts as c, UnsupportedLayoutError as d, breakCyclesWithDepthFirstSearch as i, routeEdgesOrthogonally as l, layeredAlgorithm as n, minimizeCrossingsWithBarycenter as o, assignLayersByLongestPath as r, placeNodesInLayers as s, getLayeredLayout as t, LayoutError as u };