@statelyai/layout 0.0.2 → 0.0.3

package/dist/elkjs/index.mjs

@@ -1,5 +1,5 @@
-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-f_3mmGHr.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-BfTduMDc.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/elkjs/index.ts
@@ -573,8 +573,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 +600,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 ?? []) {

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-f_3mmGHr.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-BfTduMDc.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-f_3mmGHr.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-f_3mmGHr.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,186 @@ 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 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] : []));
+			if (nonSelfNeighbors(firstNode.id).size !== 1 || nonSelfNeighbors(secondNode.id).size !== 1) continue;
+			const hasFlexiblePorts = (node) => {
+				const constraints = options.nodeSettings?.(node)?.portConstraints;
+				return constraints === void 0 || constraints === "UNDEFINED" || constraints === "FREE";
+			};
+			if (!hasFlexiblePorts(firstNode) || !hasFlexiblePorts(secondNode)) 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, 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 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
+				});
+			};
+			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 +9053,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 +9145,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 +9220,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 +9231,17 @@ 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 explicitLabelPosition = antiparallelLabelPositions.get(edge.id) ?? 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-BfTduMDc.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-f_3mmGHr.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {
@@ -27,6 +27,10 @@
       "types": "./src/elkjs/index.ts",
       "default": "./dist/elkjs/index.mjs"
     },
+    "./lib/elk.bundled.js": {
+      "types": "./src/elkjs/index.ts",
+      "default": "./dist/elkjs/index.mjs"
+    },
     "./layered": {
       "types": "./src/layered/index.ts",
       "default": "./dist/layered/index.mjs"

package/src/elkjs/index.ts

@@ -824,8 +824,11 @@ function applyNodeMicroLayout(
       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 = new Map<string, { width: number; height: number }>();
@@ -845,8 +848,12 @@ function applyNodeMicroLayout(
       }
       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 ?? []) {

package/src/layered/index.ts

@@ -29,6 +29,7 @@ import {
   breakCyclesWithModelOrderBreadthFirstSearch,
   breakCyclesWithDepthFirstSearch,
   getPolylineMidpoint,
+  getOrientedPortDirection,
   minimizeCrossingsWithBarycenter,
   minimizeCrossingsWithMedian,
   minimizeCrossingsInteractively,
@@ -1332,6 +1333,37 @@ function runLayeredPipeline<N, E, G, P>(
           left: options.padding?.left ?? 12,
         };
   const switchedSideByPort = new Map<string, "NORTH" | "SOUTH" | "WEST" | "EAST">();
+  const parallelPortIndexByKey = new Map<string, number>();
+  const labeledEdgesByPair = new Map<string, GraphEdge[]>();
+  for (const edge of graph.edges as GraphEdge[]) {
+    const settings = options.edgeSettings?.(edge);
+    if (
+      edge.sourcePort === undefined ||
+      edge.targetPort === undefined ||
+      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: LayeredPhaseInput = {
     graph: graph as Graph<unknown, unknown, unknown, unknown>,
     sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)])),
@@ -1352,6 +1384,9 @@ function runLayeredPipeline<N, E, G, P>(
     ...(options.edgeSettings === undefined ? {} : { 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}`) }
         : {}),
@@ -1660,7 +1695,7 @@ function runLayeredPipeline<N, E, G, P>(
     }
   }
   measure("port-margin-normalization", () =>
-    normalizePlacementForPortExtents(expanded.input, placement, order),
+    normalizePlacementForPortExtents(expanded.input, placement, order, expanded.orientation),
   );
   {
     const horizontal = direction === "left" || direction === "right";
@@ -1720,10 +1755,257 @@ function runLayeredPipeline<N, E, G, P>(
       : edgeRouting === "SPLINES"
         ? routeEdgesWithSplines
         : routeEdgesOrthogonally);
-  const expandedRoutes = measure("edge-routing", () =>
+  let expandedRoutes = measure("edge-routing", () =>
     edgeRouter(expanded.input, expanded.orientation, placement),
   );
   measure("post-compaction", () => applyPostCompaction(expanded.input, placement, expandedRoutes));
+  const antiparallelLabelPositions = new Map<string, Point>();
+  const parallelLabelPositions = new Map<string, Point>();
+  const postCompactionNodeCrossDeltas = new Map<string, number>();
+  const horizontalAntiparallelFlow = direction === "left" || direction === "right";
+  const usesVizInteractivePlacementProfile =
+    options.strategies?.routeEdges === undefined &&
+    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";
+  if (usesVizInteractivePlacementProfile) {
+    const neighbors = new Map(graph.nodes.map((node) => [node.id, new Set<string>()]));
+    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 = new Set<string>();
+    for (const node of graph.nodes) {
+      if (visited.has(node.id)) continue;
+      const component: GraphNode[] = [];
+      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 = new Map<string, number>();
+      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 !== undefined && constraints !== "UNDEFINED" && constraints !== "FREE";
+        })
+      ) {
+        continue;
+      }
+      const layerCounts = new Map<number, number>();
+      for (const member of component) {
+        const layer = expanded.assignment.layerByNodeId.get(member.id);
+        if (layer === undefined) 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 minimumCross = Math.min(
+        ...rects.map(({ rect }) => (horizontalAntiparallelFlow ? rect.y : rect.x)),
+      );
+      const maximumCross = Math.max(
+        ...rects.map(({ rect }) =>
+          horizontalAntiparallelFlow ? rect.y + rect.height : rect.x + rect.width,
+        ),
+      );
+      const center = (minimumCross + maximumCross) / 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 = new Map<string, GraphEdge[]>();
+    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: string) =>
+        new Set(
+          graph.edges.flatMap((edge) =>
+            edge.sourceId === edge.targetId
+              ? []
+              : edge.sourceId === nodeId
+                ? [edge.targetId]
+                : edge.targetId === nodeId
+                  ? [edge.sourceId]
+                  : [],
+          ),
+        );
+      if (nonSelfNeighbors(firstNode.id).size !== 1 || nonSelfNeighbors(secondNode.id).size !== 1) {
+        continue;
+      }
+      const hasFlexiblePorts = (node: GraphNode): boolean => {
+        const constraints = options.nodeSettings?.(node)?.portConstraints;
+        return constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
+      };
+      if (!hasFlexiblePorts(firstNode) || !hasFlexiblePorts(secondNode)) 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,
+          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 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: GraphNode, portName: string): void => {
+        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 localCross = horizontal
+          ? (placedPort.y ?? 0) + (placedPort.height ?? 0) / 2
+          : (placedPort.x ?? 0) + (placedPort.width ?? 0) / 2;
+        const nextCross = forwardCross - localCross;
+        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 },
+        );
+      };
+      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: number, adjacentIndex: number, delta: number): void => {
+        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,
@@ -1877,6 +2159,99 @@ function runLayeredPipeline<N, E, G, P>(
         : { ...end, y: end.y + delta };
     (routes.pointsByEdgeId as Map<string, readonly Point[]>).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: string, portName: string): void => {
+      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 : undefined;
+        if (index === undefined) 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 as Map<string, readonly Point[]>).set(edge.id, points);
+      }
+    };
+    if (anchorEdge.sourcePort && anchorEdge.targetPort) {
+      alignEndpoint(anchorEdge.sourceId, anchorEdge.sourcePort);
+      alignEndpoint(anchorEdge.targetId, anchorEdge.targetPort);
+    }
+  }
   const routedPortAnchors = new Map<string, Point>();
   for (const edge of graph.edges) {
     const points = routes.pointsByEdgeId.get(edge.id);
@@ -1914,6 +2289,7 @@ function runLayeredPipeline<N, E, G, P>(
       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) => {
@@ -2024,8 +2400,9 @@ function runLayeredPipeline<N, E, G, P>(
           .sort((left, right) => right.length - left.length)[0]
       : undefined;
     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"]
@@ -2081,10 +2458,50 @@ function runLayeredPipeline<N, E, G, P>(
               : (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: GraphNode | undefined): boolean => {
+      const constraints = node ? options.nodeSettings?.(node)?.portConstraints : undefined;
+      return constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
+    };
+    const flexibleFeedbackLabel =
+      labelPlacement === "CENTER" &&
+      inlineLabel &&
+      expanded.orientation.reversedEdgeIds.has(edge.id) &&
+      hasFlexiblePorts(sourceNode) &&
+      hasFlexiblePorts(targetNode) &&
+      sourceRect !== undefined &&
+      targetRect !== undefined;
+    const [beforeFlowRect, afterFlowRect] =
+      sourceRect && targetRect
+        ? horizontal
+          ? sourceRect.x <= targetRect.x
+            ? [sourceRect, targetRect]
+            : [targetRect, sourceRect]
+          : sourceRect.y <= targetRect.y
+            ? [sourceRect, targetRect]
+            : [targetRect, sourceRect]
+        : [undefined, undefined];
+    const explicitLabelPosition =
+      antiparallelLabelPositions.get(edge.id) ?? 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/src/layered/long-edges.ts

@@ -71,14 +71,15 @@ export function splitLongEdges(
       source && sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : undefined;
     const targetSide =
       target && targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : undefined;
+    const hasFixedPortSide = (node: GraphNode | undefined): boolean => {
+      if (!node) return false;
+      const constraints = String(input.nodeSettings?.(node)?.portConstraints ?? "UNDEFINED");
+      return constraints !== "UNDEFINED" && constraints !== "FREE";
+    };
     const fixedSideFeedback =
       sourceLayer > targetLayer &&
-      ((source !== undefined &&
-        input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" &&
-        sourceSide === forwardSourceSide) ||
-        (target !== undefined &&
-          input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" &&
-          targetSide === forwardTargetSide));
+      ((hasFixedPortSide(source) && sourceSide === forwardSourceSide) ||
+        (hasFixedPortSide(target) && targetSide === forwardTargetSide));
     if (
       span <= 1 ||
       edge.sourceId === edge.targetId ||

package/src/layered/strategies.ts

@@ -30,6 +30,37 @@ function getOrientedEndpoints(
     : [edge.sourceId, edge.targetId];
 }
 
+export function getOrientedPortDirection(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  node: GraphNode,
+  port: GraphPort,
+): GraphPort["direction"] {
+  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: LayeredPhaseInput): Map<string, number> {
   const enforced =
     input.settings["considerModelOrder.groupModelOrder.cbGroupOrderStrategy"] === "ENFORCED";
@@ -4312,10 +4343,15 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
         source.id === target.id &&
         feedbackSourcePortSide !== undefined &&
         feedbackSourcePortSide === feedbackTargetPortSide;
+      const hasFixedPortSide = (node: GraphNode): boolean => {
+        const constraints = String(input.nodeSettings?.(node)?.portConstraints ?? "UNDEFINED");
+        return constraints !== "UNDEFINED" && constraints !== "FREE";
+      };
       const fixedSideFeedback =
         style === "ORTHOGONAL" &&
         !sameSideSelfLoop &&
-        (feedbackSourcePortSide === sourceAwaySide || feedbackTargetPortSide === targetAwaySide);
+        ((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);
@@ -4769,12 +4805,32 @@ function routeEdges(style: "ORTHOGONAL" | "POLYLINE" | "SPLINES"): EdgeRouter {
           (candidate) =>
             candidate.targetId === edge.targetId && candidate.targetPort === edge.targetPort,
         ).length === 1;
-      const start = sourceFixedSide
+      const flexibleFeedback =
+        reversedEdge && !hasFixedPortSide(source) && !hasFixedPortSide(target);
+      const start = flexibleFeedback
         ? sourceFallback
-        : getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
-      const end = targetFixedSide
+        : sourceFixedSide
+          ? sourceFallback
+          : getPortPoint(
+              source,
+              edge.sourcePort,
+              sourceRect,
+              sourceFallback,
+              input.direction,
+              input,
+            );
+      const end = flexibleFeedback
         ? targetFallback
-        : getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
+        : 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);
@@ -4955,6 +5011,7 @@ export function placePorts<P>(
   direction: LayeredPhaseInput["direction"],
   portSettings?: (port: GraphPort<P>) => ElkLayeredOptionValueByName | undefined,
   nodeSettings?: ElkLayeredOptionValueByName,
+  portDirection?: (port: GraphPort<P>) => GraphPort<P>["direction"],
 ): GraphPort<P>[] | undefined {
   if (!ports) return undefined;
   const horizontal = direction === "left" || direction === "right";
@@ -4981,7 +5038,7 @@ export function placePorts<P>(
       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");
@@ -5221,6 +5278,7 @@ export function normalizePlacementForPortExtents(
   input: LayeredPhaseInput,
   placement: NodePlacement,
   order: LayerOrder,
+  orientation: AcyclicOrientation,
 ): void {
   const horizontal = input.direction === "left" || input.direction === "right";
   const physicalLayers = order.layers
@@ -5267,6 +5325,7 @@ export function normalizePlacementForPortExtents(
           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 = horizontal
@@ -5297,6 +5356,7 @@ export function normalizePlacementForPortExtents(
       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));