@statelyai/layout 0.0.2 → 0.0.4

package/README.md

@@ -9,12 +9,15 @@ return `VisualGraph`; positions remain node fields and routes remain
 
 ## Status
 
+<!-- layered compatibility coverage from test/oracle*.test.ts -->
+
 The native layered implementation covers the complete 152-option elkjs 0.11.1
 layered inventory with one simplified typed name per ELK option. Flat and
 compound graphs, cross-hierarchy edges, ports, labels, self-loops, wrapping,
 four directions, constraints, and replaceable phases are differential-tested
-against elkjs. Partial, incremental, and route-only layout remain explicit
-unimplemented capabilities.
+against elkjs, including a curated complex state-machine corpus in both primary
+layout orientations. Partial, incremental, and route-only layout remain
+explicit unimplemented capabilities.
 
 ## Install
 

package/dist/elkjs/index.mjs

@@ -1,8 +1,11 @@
-import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-QwJn2gb2.mjs";
-import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-D15xIQKj.mjs";
+import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-Bp8MkxWK.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-ePWz2LtF.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/elkjs/index.ts
+function isLayoutEdgeLabel(label) {
+	return getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true && (Boolean(label.text) || label.width !== void 0 || label.height !== void 0);
+}
 var ELK = class {
 	#options;
 	#algorithmIds;
@@ -573,8 +576,9 @@ function applyNodeMicroLayout(graph, globalOptions) {
 		const configuredSizeOptions = getOption(node.layoutOptions ?? {}, "nodeSize.options");
 		const sizeOptions = new Set(configuredSizeOptions === void 0 ? ["DEFAULT_MINIMUM_SIZE"] : String(configuredSizeOptions).split(/[\s,;]+/).filter(Boolean));
 		const effectivelyFixedPortLabelSize = constraints.includes("PORT_LABELS") && !constraints.includes("NODE_LABELS") && !constraints.includes("MINIMUM_SIZE");
-		let width = effectivelyFixedPortLabelSize ? node.width ?? 0 : 0;
-		let height = effectivelyFixedPortLabelSize ? node.height ?? 0 : 0;
+		const preserveComputedCompoundSize = (node.children?.length ?? 0) > 0;
+		let width = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.width ?? 0 : 0;
+		let height = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.height ?? 0 : 0;
 		let insideHorizontalInset = 0;
 		let insideVerticalInset = 0;
 		const insideLabelCells = /* @__PURE__ */ new Map();
@@ -599,8 +603,8 @@ function applyNodeMicroLayout(graph, globalOptions) {
 			}
 			width = Math.max(width, (Math.max(sideCounts.NORTH, sideCounts.SOUTH) + 1) * spacing);
 			height = Math.max(height, (Math.max(sideCounts.EAST, sideCounts.WEST) + 1) * spacing);
-			if (sideCounts.NORTH === 0 && sideCounts.SOUTH === 0) width = 0;
-			if (sideCounts.EAST === 0 && sideCounts.WEST === 0) height = 0;
+			if (!preserveComputedCompoundSize && sideCounts.NORTH === 0 && sideCounts.SOUTH === 0) width = 0;
+			if (!preserveComputedCompoundSize && sideCounts.EAST === 0 && sideCounts.WEST === 0) height = 0;
 		}
 		if (constraints.includes("NODE_LABELS")) {
 			for (const label of node.labels ?? []) {
@@ -896,7 +900,7 @@ function toGraph(root, globalOptions = {}) {
 			if (isInsideSelfLoop(root, edge)) return [];
 			const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
 			const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
-			const labels = (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
+			const labels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
 			const labelLabelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
 			const labelWidth = Math.max(0, ...labels.map((label) => label.width ?? 0));
 			const labelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelLabelSpacing;
@@ -999,7 +1003,7 @@ function applyLayout(root, graph, padding, layoutOptions) {
 				label.y ??= 0;
 				continue;
 			}
-			if (!label.text) {
+			if (!isLayoutEdgeLabel(label)) {
 				label.x ??= 0;
 				label.y ??= 0;
 				continue;
@@ -1025,7 +1029,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		minimumY = Math.min(minimumY, node.y ?? 0, ...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0)), ...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0))));
 	}
 	for (const edge of root.edges ?? []) {
-		const laidOutLabels = (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
+		const laidOutLabels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
 		minimumX = Math.min(minimumX, ...laidOutLabels.map((label) => label.x ?? 0));
 		minimumY = Math.min(minimumY, ...laidOutLabels.map((label) => label.y ?? 0));
 		if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") !== true) {
@@ -1054,7 +1058,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 				point.x += shiftX;
 				point.y += shiftY;
 			}
-			for (const label of (edge.labels ?? []).filter((candidate) => Boolean(candidate.text))) {
+			for (const label of (edge.labels ?? []).filter(isLayoutEdgeLabel)) {
 				label.x = (label.x ?? 0) + shiftX;
 				label.y = (label.y ?? 0) + shiftY;
 			}
@@ -1090,7 +1094,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)),
 		...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0) + (port.width ?? 0)),
 		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
 		section.startPoint.x,
 		...(section.bendPoints ?? []).map((point) => point.x),
 		section.endPoint.x
@@ -1100,7 +1104,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)),
 		...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0) + (port.height ?? 0)),
 		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" ? 1 : 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" ? 1 : 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
 		section.startPoint.y,
 		...(section.bendPoints ?? []).map((point) => point.y),
 		section.endPoint.y

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-QwJn2gb2.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-D15xIQKj.mjs";
+import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-Bp8MkxWK.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-ePWz2LtF.mjs";
 import { getGraphIssues } from "@statelyai/graph";
 
 //#region src/layout.ts

package/dist/layered/index.mjs

@@ -1,3 +1,3 @@
-import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-QwJn2gb2.mjs";
+import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-Bp8MkxWK.mjs";
 
 export { assignLayersByBreadthFirstModelOrder, assignLayersByDepthFirstModelOrder, assignLayersByLongestPath, assignLayersByLongestPathToSink, assignLayersInteractively, assignLayersWithCoffmanGraham, assignLayersWithMinWidth, assignLayersWithNetworkSimplex, assignLayersWithStretchWidth, breakCyclesByModelOrder, breakCyclesByStronglyConnectedConnectivity, breakCyclesByStronglyConnectedNodeType, breakCyclesGreedily, breakCyclesGreedilyByModelOrder, breakCyclesInteractively, breakCyclesWithDepthFirstSearch, breakCyclesWithModelOrderBreadthFirstSearch, breakCyclesWithModelOrderDepthFirstSearch, elkLayeredEnumValues, elkLayeredOptionDefinitions, fromElkLayeredOptionId, getLayeredLayout, layeredAlgorithm, minimizeCrossingsInteractively, minimizeCrossingsWithBarycenter, minimizeCrossingsWithMedian, minimizeCrossingsWithModelOrder, placeNodesInLayers, placeNodesInteractively, placeNodesWithBrandesKoepf, placeNodesWithLinearSegments, placeNodesWithNetworkSimplex, routeEdgesOrthogonally, routeEdgesWithPolylines, routeEdgesWithSplines, toElkLayeredOptions };

package/dist/{layered-QwJn2gb2.mjs → layered-Bp8MkxWK.mjs}

@@ -195,6 +195,20 @@ const phaseRandomByInput = /* @__PURE__ */ new WeakMap();
 function getOrientedEndpoints$1(edge, orientation) {
 	return orientation.reversedEdgeIds.has(edge.id) ? [edge.targetId, edge.sourceId] : [edge.sourceId, edge.targetId];
 }
+function getOrientedPortDirection(input, orientation, node, port) {
+	const configuredSide = input.portSettings?.(port, node)?.["port.side"];
+	if (configuredSide !== "NORTH" && configuredSide !== "SOUTH" && configuredSide !== "WEST" && configuredSide !== "EAST") return port.direction;
+	let incoming = false;
+	let outgoing = false;
+	for (const edge of input.graph.edges) {
+		const reversed = orientation.reversedEdgeIds.has(edge.id);
+		if (edge.sourceId === node.id && edge.sourcePort === port.name) if (reversed) incoming = true;
+		else outgoing = true;
+		if (edge.targetId === node.id && edge.targetPort === port.name) if (reversed) outgoing = true;
+		else incoming = true;
+	}
+	return incoming && outgoing ? "inout" : outgoing ? "out" : incoming ? "in" : port.direction;
+}
 function cycleModelOrder(input) {
 	const enforced = input.settings["considerModelOrder.groupModelOrder.cbGroupOrderStrategy"] === "ENFORCED";
 	const count = Math.max(1, input.graph.nodes.length);
@@ -2917,7 +2931,11 @@ function routeEdges(style) {
 			const sourceAwaySide = horizontal ? sourceRect.x < targetRect.x ? "WEST" : "EAST" : sourceRect.y < targetRect.y ? "NORTH" : "SOUTH";
 			const targetAwaySide = horizontal ? sourceRect.x < targetRect.x ? "EAST" : "WEST" : sourceRect.y < targetRect.y ? "SOUTH" : "NORTH";
 			const sameSideSelfLoop = source.id === target.id && feedbackSourcePortSide !== void 0 && feedbackSourcePortSide === feedbackTargetPortSide;
-			const fixedSideFeedback = style === "ORTHOGONAL" && !sameSideSelfLoop && (feedbackSourcePortSide === sourceAwaySide || feedbackTargetPortSide === targetAwaySide);
+			const hasFixedPortSide = (node) => {
+				const constraints = String(input.nodeSettings?.(node)?.portConstraints ?? "UNDEFINED");
+				return constraints !== "UNDEFINED" && constraints !== "FREE";
+			};
+			const fixedSideFeedback = style === "ORTHOGONAL" && !sameSideSelfLoop && (hasFixedPortSide(source) && feedbackSourcePortSide === sourceAwaySide || hasFixedPortSide(target) && feedbackTargetPortSide === targetAwaySide);
 			if (input.settings.feedbackEdges === true && reversedEdge || fixedSideFeedback) {
 				if (fixedSideFeedback) outsideFeedbackEdgeIds.add(edge.id);
 				const crossSpacing = Number(input.settings["spacing.edgeNode"] ?? 10);
@@ -3296,8 +3314,9 @@ function routeEdges(style) {
 			const fallbackMatchesPortSide = (fallback, rect, side) => side === void 0 || side === "UNDEFINED" || side === "EAST" && Math.abs(fallback.x - rect.x - rect.width) < 1e-9 || side === "WEST" && Math.abs(fallback.x - rect.x) < 1e-9 || side === "SOUTH" && Math.abs(fallback.y - rect.y - rect.height) < 1e-9 || side === "NORTH" && Math.abs(fallback.y - rect.y) < 1e-9;
 			const sourceFixedSide = sourcePort !== void 0 && fallbackMatchesPortSide(sourceFallback, sourceRect, sourcePortSide) && (sourcePort.width ?? 8) === 0 && (sourcePort.height ?? 8) === 0 && input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId && candidate.sourcePort === edge.sourcePort).length === 1;
 			const targetFixedSide = targetPort !== void 0 && fallbackMatchesPortSide(targetFallback, targetRect, targetPortSide) && (targetPort.width ?? 8) === 0 && (targetPort.height ?? 8) === 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.targetId === edge.targetId && candidate.targetPort === edge.targetPort).length === 1;
-			const start = sourceFixedSide ? sourceFallback : getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
-			const end = targetFixedSide ? targetFallback : getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
+			const flexibleFeedback = reversedEdge && !hasFixedPortSide(source) && !hasFixedPortSide(target);
+			const start = flexibleFeedback ? sourceFallback : sourceFixedSide ? sourceFallback : getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
+			const end = flexibleFeedback ? targetFallback : targetFixedSide ? targetFallback : getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
 			const sourceLayer = flowLayerByNodeId.get(edge.sourceId) ?? 0;
 			const targetLayer = flowLayerByNodeId.get(edge.targetId) ?? 0;
 			const earlierLayer = Math.min(sourceLayer, targetLayer);
@@ -3450,7 +3469,7 @@ function routeEdges(style) {
 const routeEdgesOrthogonally = routeEdges("ORTHOGONAL");
 const routeEdgesWithPolylines = routeEdges("POLYLINE");
 const routeEdgesWithSplines = routeEdges("SPLINES");
-function placePorts(ports, rect, direction, portSettings, nodeSettings) {
+function placePorts(ports, rect, direction, portSettings, nodeSettings, portDirection) {
 	if (!ports) return void 0;
 	const horizontal = direction === "left" || direction === "right";
 	const reverse = direction === "up" || direction === "left";
@@ -3464,7 +3483,7 @@ function placePorts(ports, rect, direction, portSettings, nodeSettings) {
 			sideByPort.set(port, configured);
 			continue;
 		}
-		const outgoing = port.direction === "out";
+		const outgoing = (portDirection?.(port) ?? port.direction) === "out";
 		const normalFarSide = reverse ? !outgoing : outgoing;
 		const farSide = sideFixed && configured === "UNDEFINED" ? !normalFarSide : normalFarSide;
 		sideByPort.set(port, horizontal ? farSide ? "EAST" : "WEST" : farSide ? "SOUTH" : "NORTH");
@@ -3574,7 +3593,7 @@ function placePorts(ports, rect, direction, portSettings, nodeSettings) {
 	});
 }
 /** Account for port extents in ELK's graph-padding normalization. */
-function normalizePlacementForPortExtents(input, placement, order) {
+function normalizePlacementForPortExtents(input, placement, order, orientation) {
 	const horizontal = input.direction === "left" || input.direction === "right";
 	const physicalLayers = order.layers.map((layer) => layer.flatMap((id) => placement.rectByNodeId.has(id) ? [id] : [])).filter((layer) => layer.length > 0).sort((left, right) => {
 		const leftRect = placement.rectByNodeId.get(left[0]);
@@ -3609,7 +3628,7 @@ function normalizePlacementForPortExtents(input, placement, order) {
 			const ports = placePorts(node.ports, rect, input.direction, (port) => input.portSettings?.(port, node), {
 				...input.settings,
 				...input.nodeSettings?.(node)
-			});
+			}, (port) => getOrientedPortDirection(input, orientation, node, port));
 			for (const port of ports ?? []) {
 				const extent$1 = horizontal ? trailing ? Math.max(0, (port.x ?? 0) + (port.width ?? 0) - rect.width) : Math.max(0, -(port.x ?? 0)) : trailing ? Math.max(0, (port.y ?? 0) + (port.height ?? 0) - rect.height) : Math.max(0, -(port.y ?? 0));
 				if (trailing) trailingExtent = Math.max(trailingExtent, extent$1);
@@ -3628,7 +3647,7 @@ function normalizePlacementForPortExtents(input, placement, order) {
 		const ports = placePorts(node.ports, rect, input.direction, (port) => input.portSettings?.(port, node), {
 			...input.settings,
 			...input.nodeSettings?.(node)
-		});
+		}, (port) => getOrientedPortDirection(input, orientation, node, port));
 		for (const port of ports ?? []) {
 			minimumX = Math.min(minimumX, rect.x + (port.x ?? 0));
 			minimumY = Math.min(minimumY, rect.y + (port.y ?? 0));
@@ -4165,7 +4184,12 @@ function splitLongEdges(input, orientation, assignment) {
 		const targetPort = target?.ports?.find((port) => port.name === edge.targetPort);
 		const sourceSide = source && sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : void 0;
 		const targetSide = target && targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : void 0;
-		const fixedSideFeedback = sourceLayer > targetLayer && (source !== void 0 && input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" && sourceSide === forwardSourceSide || target !== void 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" && targetSide === forwardTargetSide);
+		const hasFixedPortSide = (node) => {
+			if (!node) return false;
+			const constraints = String(input.nodeSettings?.(node)?.portConstraints ?? "UNDEFINED");
+			return constraints !== "UNDEFINED" && constraints !== "FREE";
+		};
+		const fixedSideFeedback = sourceLayer > targetLayer && (hasFixedPortSide(source) && sourceSide === forwardSourceSide || hasFixedPortSide(target) && targetSide === forwardTargetSide);
 		if (span <= 1 || edge.sourceId === edge.targetId || input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id) || fixedSideFeedback) {
 			edges.push(edge);
 			originalEdgeBySegmentId.set(edge.id, edge);
@@ -8459,6 +8483,24 @@ function runLayeredPipeline(graph, options, context) {
 		left: options.padding?.left ?? 12
 	};
 	const switchedSideByPort = /* @__PURE__ */ new Map();
+	const parallelPortIndexByKey = /* @__PURE__ */ new Map();
+	const labeledEdgesByPair = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const settings = options.edgeSettings?.(edge);
+		if (edge.sourcePort === void 0 || edge.targetPort === void 0 || edge.sourceId === edge.targetId || (edge.width ?? 0) <= 0 || (edge.height ?? 0) <= 0 || (settings?.["edgeLabels.placement"] ?? "CENTER") !== "CENTER" || settings?.["edgeLabels.inline"] !== true) continue;
+		const key = `${edge.sourceId}\0${edge.targetId}`;
+		const pair = labeledEdgesByPair.get(key) ?? [];
+		pair.push(edge);
+		labeledEdgesByPair.set(key, pair);
+	}
+	for (const pair of labeledEdgesByPair.values()) {
+		if (pair.length < 2) continue;
+		for (const [index, edge] of pair.entries()) {
+			const portIndex = options.settings?.["considerModelOrder.strategy"] === "PREFER_NODES" ? index : pair.length - index - 1;
+			parallelPortIndexByKey.set(`${edge.sourceId}\0${edge.sourcePort}`, portIndex);
+			parallelPortIndexByKey.set(`${edge.targetId}\0${edge.targetPort}`, portIndex);
+		}
+	}
 	const input = {
 		graph,
 		sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)])),
@@ -8477,6 +8519,7 @@ function runLayeredPipeline(graph, options, context) {
 		...options.edgeSettings === void 0 ? {} : { edgeSettings: options.edgeSettings },
 		portSettings: (port, node) => ({
 			...options.portSettings?.(port, node),
+			...parallelPortIndexByKey.has(`${node.id}\0${port.name}`) ? { "port.index": parallelPortIndexByKey.get(`${node.id}\0${port.name}`) } : {},
 			...switchedSideByPort.has(`${node.id}\0${port.name}`) ? { "port.side": switchedSideByPort.get(`${node.id}\0${port.name}`) } : {}
 		})
 	};
@@ -8674,7 +8717,7 @@ function runLayeredPipeline(graph, options, context) {
 			});
 		}
 	}
-	measure("port-margin-normalization", () => normalizePlacementForPortExtents(expanded.input, placement, order));
+	measure("port-margin-normalization", () => normalizePlacementForPortExtents(expanded.input, placement, order, expanded.orientation));
 	{
 		const horizontal = direction === "left" || direction === "right";
 		const crossCenter = (nodeId) => {
@@ -8699,8 +8742,197 @@ function runLayeredPipeline(graph, options, context) {
 	}
 	const edgeRouting = options.settings?.edgeRouting ?? "ORTHOGONAL";
 	const edgeRouter = options.strategies?.routeEdges ?? (edgeRouting === "POLYLINE" ? routeEdgesWithPolylines : edgeRouting === "SPLINES" ? routeEdgesWithSplines : routeEdgesOrthogonally);
-	const expandedRoutes = measure("edge-routing", () => edgeRouter(expanded.input, expanded.orientation, placement));
+	let expandedRoutes = measure("edge-routing", () => edgeRouter(expanded.input, expanded.orientation, placement));
 	measure("post-compaction", () => applyPostCompaction(expanded.input, placement, expandedRoutes));
+	const antiparallelLabelPositions = /* @__PURE__ */ new Map();
+	const outerAntiparallelLabelIds = /* @__PURE__ */ new Set();
+	const parallelLabelPositions = /* @__PURE__ */ new Map();
+	const postCompactionNodeCrossDeltas = /* @__PURE__ */ new Map();
+	const horizontalAntiparallelFlow = direction === "left" || direction === "right";
+	if (options.strategies?.routeEdges === void 0 && options.settings?.["cycleBreaking.strategy"] === "MODEL_ORDER" && options.settings?.["layering.strategy"] === "INTERACTIVE" && options.settings?.["crossingMinimization.forceNodeModelOrder"] === true && options.settings?.["nodePlacement.strategy"] === "BRANDES_KOEPF" && options.settings?.["nodePlacement.favorStraightEdges"] === true && options.settings?.["compaction.postCompaction.strategy"] === "LEFT" && options.settings?.["compaction.postCompaction.constraints"] === "SCANLINE") {
+		const neighbors = new Map(graph.nodes.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+		for (const edge of graph.edges) {
+			if (edge.sourceId === edge.targetId) continue;
+			neighbors.get(edge.sourceId)?.add(edge.targetId);
+			neighbors.get(edge.targetId)?.add(edge.sourceId);
+		}
+		const visited = /* @__PURE__ */ new Set();
+		for (const node of graph.nodes) {
+			if (visited.has(node.id)) continue;
+			const component = [];
+			const pending = [node.id];
+			while (pending.length > 0) {
+				const id = pending.pop();
+				if (visited.has(id)) continue;
+				visited.add(id);
+				const member = graph.nodes.find((candidate) => candidate.id === id);
+				if (member) component.push(member);
+				for (const neighbor of neighbors.get(id) ?? []) pending.push(neighbor);
+			}
+			if (component.length < 2) continue;
+			const componentIds = new Set(component.map((member) => member.id));
+			if (!graph.edges.some((edge) => componentIds.has(edge.sourceId) && componentIds.has(edge.targetId) && expanded.orientation.reversedEdgeIds.has(edge.id))) continue;
+			const directedPairCounts = /* @__PURE__ */ new Map();
+			for (const edge of graph.edges) {
+				if (!componentIds.has(edge.sourceId) || !componentIds.has(edge.targetId)) continue;
+				const key = `${edge.sourceId}\0${edge.targetId}`;
+				directedPairCounts.set(key, (directedPairCounts.get(key) ?? 0) + 1);
+			}
+			if ([...directedPairCounts.values()].some((count) => count > 1)) continue;
+			if (component.some((member) => {
+				const constraints = options.nodeSettings?.(member)?.portConstraints;
+				return constraints !== void 0 && constraints !== "UNDEFINED" && constraints !== "FREE";
+			})) continue;
+			const layerCounts = /* @__PURE__ */ new Map();
+			for (const member of component) {
+				const layer = expanded.assignment.layerByNodeId.get(member.id);
+				if (layer === void 0) continue;
+				layerCounts.set(layer, (layerCounts.get(layer) ?? 0) + 1);
+			}
+			if ([...layerCounts.values()].some((count) => count !== 1)) continue;
+			const rects = component.flatMap((member) => {
+				const rect = mutableRects.get(member.id);
+				return rect ? [{
+					member,
+					rect
+				}] : [];
+			});
+			if (rects.length !== component.length) continue;
+			const center = (Math.min(...rects.map(({ rect }) => horizontalAntiparallelFlow ? rect.y : rect.x)) + Math.max(...rects.map(({ rect }) => horizontalAntiparallelFlow ? rect.y + rect.height : rect.x + rect.width))) / 2;
+			for (const { member, rect } of rects) {
+				const currentCross = horizontalAntiparallelFlow ? rect.y : rect.x;
+				const nextCross = horizontalAntiparallelFlow ? center - rect.height / 2 : center - rect.width / 2;
+				postCompactionNodeCrossDeltas.set(member.id, nextCross - currentCross);
+				mutableRects.set(member.id, horizontalAntiparallelFlow ? {
+					...rect,
+					y: nextCross
+				} : {
+					...rect,
+					x: nextCross
+				});
+			}
+		}
+	}
+	{
+		const horizontal = horizontalAntiparallelFlow;
+		const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+		const pairEdges = /* @__PURE__ */ new Map();
+		for (const edge of graph.edges) {
+			if (edge.sourceId === edge.targetId || (edge.width ?? 0) <= 0 || (edge.height ?? 0) <= 0) continue;
+			const key = [edge.sourceId, edge.targetId].sort().join("\0");
+			const pair = pairEdges.get(key) ?? [];
+			pair.push(edge);
+			pairEdges.set(key, pair);
+		}
+		for (const pair of pairEdges.values()) {
+			if (pair.length !== 2 || pair[0].sourceId !== pair[1].targetId || pair[0].targetId !== pair[1].sourceId || pair.some((edge) => {
+				const settings = options.edgeSettings?.(edge);
+				return (settings?.["edgeLabels.placement"] ?? "CENTER") !== "CENTER" || settings?.["edgeLabels.inline"] !== true;
+			})) continue;
+			const firstNode = nodesById.get(pair[0].sourceId);
+			const secondNode = nodesById.get(pair[0].targetId);
+			const firstRect = placement.rectByNodeId.get(pair[0].sourceId);
+			const secondRect = placement.rectByNodeId.get(pair[0].targetId);
+			if (!firstNode || !secondNode || !firstRect || !secondRect) continue;
+			const nonSelfNeighbors = (nodeId) => new Set(graph.edges.flatMap((edge) => edge.sourceId === edge.targetId ? [] : edge.sourceId === nodeId ? [edge.targetId] : edge.targetId === nodeId ? [edge.sourceId] : []));
+			const isolatedAntiparallelPair = nonSelfNeighbors(firstNode.id).size === 1 && nonSelfNeighbors(secondNode.id).size === 1;
+			const hasFlexiblePorts = (node) => {
+				const constraints = options.nodeSettings?.(node)?.portConstraints;
+				return constraints === void 0 || constraints === "UNDEFINED" || constraints === "FREE";
+			};
+			const hasFlexiblePairPorts = hasFlexiblePorts(firstNode) && hasFlexiblePorts(secondNode);
+			if (isolatedAntiparallelPair && !hasFlexiblePairPorts) continue;
+			const firstBeforeSecond = horizontal ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2 : firstRect.y + firstRect.height / 2 < secondRect.y + secondRect.height / 2;
+			const beforeRect = firstBeforeSecond ? firstRect : secondRect;
+			const afterRect = firstBeforeSecond ? secondRect : firstRect;
+			const forward = pair.find((edge) => firstBeforeSecond ? edge.sourceId === pair[0].sourceId : edge.sourceId === pair[0].targetId);
+			if (!forward?.sourcePort || !forward.targetPort) continue;
+			let cross = Math.min(horizontal ? firstRect.y : firstRect.x, horizontal ? secondRect.y : secondRect.x);
+			const edgeSpacing = Number(options.settings?.["spacing.edgeEdge"] ?? 10);
+			for (const edge of pair) {
+				const width = edge.width ?? 0;
+				const height = edge.height ?? 0;
+				antiparallelLabelPositions.set(edge.id, isolatedAntiparallelPair ? horizontal ? {
+					x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+					y: cross
+				} : {
+					x: cross,
+					y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2
+				} : horizontal ? {
+					x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+					y: edge === forward ? (firstRect.y + firstRect.height / 2 + secondRect.y + secondRect.height / 2) / 2 - height / 2 : Math.max(firstRect.y + firstRect.height, secondRect.y + secondRect.height) + edgeSpacing
+				} : {
+					x: edge === forward ? (firstRect.x + firstRect.width / 2 + secondRect.x + secondRect.width / 2) / 2 - width / 2 : Math.max(firstRect.x + firstRect.width, secondRect.x + secondRect.width) + edgeSpacing,
+					y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2
+				});
+				if (!isolatedAntiparallelPair && edge !== forward) outerAntiparallelLabelIds.add(edge.id);
+				cross += (horizontal ? height : width) + edgeSpacing;
+			}
+			const forwardLabel = antiparallelLabelPositions.get(forward.id);
+			const forwardCross = horizontal ? Math.round(forwardLabel.y + (forward.height ?? 0) / 2) : Math.round(forwardLabel.x + (forward.width ?? 0) / 2);
+			const alignPort = (node, portName) => {
+				const rect = placement.rectByNodeId.get(node.id);
+				const port = node.ports?.find((candidate) => candidate.name === portName);
+				if (!rect || !port) return;
+				const placedPort = placePorts(node.ports, rect, direction, (candidate) => input.portSettings?.(candidate, node), {
+					...options.settings,
+					...options.nodeSettings?.(node)
+				}, (candidate) => getOrientedPortDirection(expanded.input, expanded.orientation, node, candidate))?.find((candidate) => candidate.name === portName);
+				if (!placedPort) return;
+				const nextCross = forwardCross - (horizontal ? (placedPort.y ?? 0) + (placedPort.height ?? 0) / 2 : (placedPort.x ?? 0) + (placedPort.width ?? 0) / 2);
+				const currentCross = horizontal ? rect.y : rect.x;
+				postCompactionNodeCrossDeltas.set(node.id, (postCompactionNodeCrossDeltas.get(node.id) ?? 0) + nextCross - currentCross);
+				mutableRects.set(node.id, horizontal ? {
+					...rect,
+					y: nextCross
+				} : {
+					...rect,
+					x: nextCross
+				});
+			};
+			if (isolatedAntiparallelPair) {
+				alignPort(nodesById.get(forward.sourceId), forward.sourcePort);
+				alignPort(nodesById.get(forward.targetId), forward.targetPort);
+			}
+		}
+	}
+	if (postCompactionNodeCrossDeltas.size > 0) {
+		const pointsByEdgeId = new Map(expandedRoutes.pointsByEdgeId);
+		for (const edge of graph.edges) {
+			const points = [...pointsByEdgeId.get(edge.id) ?? []];
+			if (points.length === 0) continue;
+			const sourceDelta = postCompactionNodeCrossDeltas.get(edge.sourceId) ?? 0;
+			const targetDelta = postCompactionNodeCrossDeltas.get(edge.targetId) ?? 0;
+			const shiftEndpoint = (endpointIndex, adjacentIndex, delta) => {
+				if (delta === 0) return;
+				const endpoint = points[endpointIndex];
+				const adjacent = points[adjacentIndex];
+				if (!endpoint) return;
+				const originalCross = horizontalAntiparallelFlow ? endpoint.y : endpoint.x;
+				points[endpointIndex] = horizontalAntiparallelFlow ? {
+					...endpoint,
+					y: endpoint.y + delta
+				} : {
+					...endpoint,
+					x: endpoint.x + delta
+				};
+				if (adjacent && (horizontalAntiparallelFlow ? adjacent.y : adjacent.x) === originalCross) points[adjacentIndex] = horizontalAntiparallelFlow ? {
+					...adjacent,
+					y: adjacent.y + delta
+				} : {
+					...adjacent,
+					x: adjacent.x + delta
+				};
+			};
+			shiftEndpoint(0, 1, sourceDelta);
+			shiftEndpoint(points.length - 1, points.length - 2, targetDelta);
+			pointsByEdgeId.set(edge.id, points);
+		}
+		expandedRoutes = {
+			...expandedRoutes,
+			pointsByEdgeId
+		};
+	}
 	let routes = measure("long-edge-joining", () => joinLongEdgeRoutes(expandedRoutes, expanded.segmentIdsByEdgeId, edgeRouting === "SPLINES" || options.settings?.unnecessaryBendpoints === true, edgeRouting === "SPLINES", Number(options.settings?.["spacing.edgeNodeBetweenLayers"] ?? 10)));
 	if (options.settings?.["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT") {
 		const horizontal = direction === "right" || direction === "left";
@@ -8832,6 +9064,84 @@ function runLayeredPipeline(graph, options, context) {
 		};
 		routes.pointsByEdgeId.set(edge.id, points);
 	}
+	for (const pair of labeledEdgesByPair.values()) {
+		if (pair.length < 2) continue;
+		const sourceRect = mutableRects.get(pair[0].sourceId);
+		const targetRect = mutableRects.get(pair[0].targetId);
+		if (!sourceRect || !targetRect) continue;
+		const horizontal = direction === "left" || direction === "right";
+		const beforeRect = horizontal ? sourceRect.x <= targetRect.x ? sourceRect : targetRect : sourceRect.y <= targetRect.y ? sourceRect : targetRect;
+		const afterRect = beforeRect === sourceRect ? targetRect : sourceRect;
+		const edgeSpacing = Number(options.settings?.["spacing.edgeEdge"] ?? 10);
+		let cross = horizontal ? padding.top : padding.left;
+		const orderedPair = options.settings?.["considerModelOrder.strategy"] === "PREFER_NODES" ? pair : [...pair].reverse();
+		for (const edge of orderedPair) {
+			const width = edge.width ?? 0;
+			const height = edge.height ?? 0;
+			parallelLabelPositions.set(edge.id, horizontal ? {
+				x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+				y: cross
+			} : {
+				x: cross,
+				y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2
+			});
+			cross += (horizontal ? height : width) + edgeSpacing;
+		}
+		const anchorEdge = orderedPair[0];
+		const anchorLabel = parallelLabelPositions.get(anchorEdge.id);
+		const desiredCross = Math.round(horizontal ? anchorLabel.y + (anchorEdge.height ?? 0) / 2 : anchorLabel.x + (anchorEdge.width ?? 0) / 2);
+		const alignEndpoint = (nodeId, portName) => {
+			const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+			const rect = mutableRects.get(nodeId);
+			const port = node?.ports?.find((candidate) => candidate.name === portName);
+			if (!node || !rect || !port) return;
+			const placedPort = placePorts(node.ports, rect, direction, (candidate) => input.portSettings?.(candidate, node), {
+				...options.settings,
+				...options.nodeSettings?.(node)
+			}, (candidate) => getOrientedPortDirection(expanded.input, expanded.orientation, node, candidate))?.find((candidate) => candidate.name === portName);
+			if (!placedPort) return;
+			const localCross = horizontal ? (placedPort.y ?? 0) + (placedPort.height ?? 0) / 2 : (placedPort.x ?? 0) + (placedPort.width ?? 0) / 2;
+			const currentCross = horizontal ? rect.y : rect.x;
+			const nextCross = desiredCross - localCross;
+			const delta = nextCross - currentCross;
+			mutableRects.set(nodeId, horizontal ? {
+				...rect,
+				y: nextCross
+			} : {
+				...rect,
+				x: nextCross
+			});
+			for (const edge of graph.edges) {
+				const points = [...routes.pointsByEdgeId.get(edge.id) ?? []];
+				if (points.length === 0) continue;
+				const index = edge.sourceId === nodeId ? 0 : edge.targetId === nodeId ? points.length - 1 : void 0;
+				if (index === void 0) continue;
+				const endpoint = points[index];
+				const originalCross = horizontal ? endpoint.y : endpoint.x;
+				points[index] = horizontal ? {
+					...endpoint,
+					y: endpoint.y + delta
+				} : {
+					...endpoint,
+					x: endpoint.x + delta
+				};
+				const adjacentIndex = index === 0 ? 1 : points.length - 2;
+				const adjacent = points[adjacentIndex];
+				if (adjacent && (horizontal ? adjacent.y : adjacent.x) === originalCross) points[adjacentIndex] = horizontal ? {
+					...adjacent,
+					y: adjacent.y + delta
+				} : {
+					...adjacent,
+					x: adjacent.x + delta
+				};
+				routes.pointsByEdgeId.set(edge.id, points);
+			}
+		};
+		if (anchorEdge.sourcePort && anchorEdge.targetPort) {
+			alignEndpoint(anchorEdge.sourceId, anchorEdge.sourcePort);
+			alignEndpoint(anchorEdge.targetId, anchorEdge.targetPort);
+		}
+	}
 	const routedPortAnchors = /* @__PURE__ */ new Map();
 	for (const edge of graph.edges) {
 		const points = routes.pointsByEdgeId.get(edge.id);
@@ -8846,7 +9156,7 @@ function runLayeredPipeline(graph, options, context) {
 		let ports = placePorts(node.ports, rect, direction, (port) => input.portSettings?.(port, node), {
 			...options.settings,
 			...options.nodeSettings?.(node)
-		});
+		}, (port) => getOrientedPortDirection(expanded.input, expanded.orientation, node, port));
 		if (options.nodeSettings?.(node)?.portConstraints === "FIXED_SIDE") ports = ports?.map((port) => {
 			if ((port.width ?? 8) !== 0 || (port.height ?? 8) !== 0) return port;
 			const anchor = routedPortAnchors.get(`${node.id}\0${port.name}`);
@@ -8921,8 +9231,9 @@ function runLayeredPipeline(graph, options, context) {
 			}] : [];
 		}).sort((left, right) => right.length - left.length)[0] : void 0;
 		const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
+		const targetNode = graph.nodes.find((node) => node.id === edge.targetId);
 		const sourcePort = sourceNode?.ports?.find((port) => port.name === edge.sourcePort);
-		const targetPort = sourceNode?.ports?.find((port) => port.name === edge.targetPort);
+		const targetPort = targetNode?.ports?.find((port) => port.name === edge.targetPort);
 		const sourcePortSide = sourceNode && sourcePort ? options.portSettings?.(sourcePort, sourceNode)?.["port.side"] : void 0;
 		const targetPortSide = sourceNode && targetPort ? options.portSettings?.(targetPort, sourceNode)?.["port.side"] : void 0;
 		const horizontalFeedbackTrack = edge.sourceId === edge.targetId && (sourcePortSide === "EAST" || sourcePortSide === "WEST") && targetPortSide === sourcePortSide || (horizontalFeedbackCandidate?.length ?? -1) >= (verticalFeedbackCandidate?.length ?? -1) ? horizontalFeedbackCandidate : void 0;
@@ -8931,8 +9242,43 @@ function runLayeredPipeline(graph, options, context) {
 		const edgeNodeSpacing = Number(options.settings?.["spacing.edgeNodeBetweenLayers"] ?? 10);
 		const routeX = labelPlacement === "TAIL" ? firstPoint.x + labelSpacing : labelPlacement === "HEAD" ? lastPoint.x - width - labelSpacing : inlineLabel && horizontalFeedbackTrack ? (horizontalFeedbackTrack.start.x + horizontalFeedbackTrack.end.x - width) / 2 : inlineLabel && verticalFeedbackTrack ? verticalFeedbackTrack.start.x > (minimumFeedbackNodeX + maximumFeedbackNodeX) / 2 ? verticalFeedbackTrack.start.x + labelSpacing + 1 : verticalFeedbackTrack.start.x - labelSpacing - width - 1 : inlineLabel && verticalTrack ? (direction === "right" ? trackNearTarget : !trackNearTarget) ? verticalTrack.x - edgeNodeSpacing - width : verticalTrack.x + edgeNodeSpacing : inlineLabel ? horizontal ? Math.floor(midpoint.x - width / 2) : Math.ceil(midpoint.x - width / 2) : midpoint.x - width / 2;
 		const routeY = labelPlacement === "CENTER" && inlineLabel && horizontalFeedbackTrack ? horizontalFeedbackTrack.start.y - height / 2 - .5 : labelPlacement === "CENTER" && inlineLabel && verticalFeedbackTrack ? (verticalFeedbackTrack.start.y + verticalFeedbackTrack.end.y - height) / 2 : labelPlacement === "CENTER" && inlineLabel ? midpoint.y - height / 2 - .5 : labelPlacement === "CENTER" && placeLabelUp ? midpoint.y - height - labelSpacing - Math.round(edgeThickness / 2) : (labelPlacement === "CENTER" ? midpoint.y : (firstPoint.y + lastPoint.y) / 2) + labelSpacing + Math.round(edgeThickness / 2);
-		const x = labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
-		const y = labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
+		const sourceRect = placement.rectByNodeId.get(edge.sourceId);
+		const targetRect = placement.rectByNodeId.get(edge.targetId);
+		const hasFlexiblePorts = (node) => {
+			const constraints = node ? options.nodeSettings?.(node)?.portConstraints : void 0;
+			return constraints === void 0 || constraints === "UNDEFINED" || constraints === "FREE";
+		};
+		const flexibleFeedbackLabel = labelPlacement === "CENTER" && inlineLabel && expanded.orientation.reversedEdgeIds.has(edge.id) && hasFlexiblePorts(sourceNode) && hasFlexiblePorts(targetNode) && sourceRect !== void 0 && targetRect !== void 0;
+		const [beforeFlowRect, afterFlowRect] = sourceRect && targetRect ? horizontal ? sourceRect.x <= targetRect.x ? [sourceRect, targetRect] : [targetRect, sourceRect] : sourceRect.y <= targetRect.y ? [sourceRect, targetRect] : [targetRect, sourceRect] : [void 0, void 0];
+		const antiparallelLabelPosition = antiparallelLabelPositions.get(edge.id);
+		const explicitLabelPosition = (() => {
+			if (!outerAntiparallelLabelIds.has(edge.id)) return void 0;
+			const edgeNodeSpacing$1 = Number(options.settings?.["spacing.edgeNode"] ?? 10);
+			if (horizontal) {
+				const x$1 = (beforeFlowRect.x + beforeFlowRect.width + afterFlowRect.x - width) / 2;
+				const blockers$1 = [
+					sourceRect,
+					targetRect,
+					...[...placement.rectByNodeId.values()].filter((rect) => rect.x < x$1 + width && rect.x + rect.width > x$1)
+				];
+				return {
+					x: x$1,
+					y: Math.max(...blockers$1.map((rect) => rect.y + rect.height)) + edgeNodeSpacing$1
+				};
+			}
+			const y$1 = (beforeFlowRect.y + beforeFlowRect.height + afterFlowRect.y - height) / 2;
+			const blockers = [
+				sourceRect,
+				targetRect,
+				...[...placement.rectByNodeId.values()].filter((rect) => rect.y < y$1 + height && rect.y + rect.height > y$1)
+			];
+			return {
+				x: Math.max(...blockers.map((rect) => rect.x + rect.width)) + edgeNodeSpacing$1,
+				y: y$1
+			};
+		})() ?? antiparallelLabelPosition ?? parallelLabelPositions.get(edge.id);
+		const x = explicitLabelPosition ? explicitLabelPosition.x : flexibleFeedbackLabel ? horizontal ? (beforeFlowRect.x + beforeFlowRect.width + afterFlowRect.x - width) / 2 : targetRect.x + (targetRect.width - width) / 2 : labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
+		const y = explicitLabelPosition ? explicitLabelPosition.y : flexibleFeedbackLabel ? horizontal ? targetRect.y + (targetRect.height - height) / 2 : (beforeFlowRect.y + beforeFlowRect.height + afterFlowRect.y - height) / 2 : labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
 		return {
 			...edge,
 			x,

package/dist/{spore-D15xIQKj.mjs → spore-ePWz2LtF.mjs}

@@ -1,4 +1,4 @@
-import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-QwJn2gb2.mjs";
+import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-Bp8MkxWK.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts