@statelyai/layout 0.0.1 → 0.0.3

package/dist/{layered-Dd868WZY.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);
@@ -1721,6 +1735,14 @@ function applyPostCompaction(input, placement, routes) {
 	input.settings["compaction.postCompaction.constraints"];
 	if (strategy === "NONE") return placement;
 	const rects = placement.rectByNodeId;
+	const originalEndpointsByEdgeId = new Map([...routes?.pointsByEdgeId ?? []].flatMap(([edgeId, points]) => {
+		const start = points[0];
+		const end = points.at(-1);
+		return start && end ? [[edgeId, {
+			start: { ...start },
+			end: { ...end }
+		}]] : [];
+	}));
 	const compactables = [...rects].map(([id, rect]) => {
 		const longEdgeDummy = id.startsWith("__layout_dummy:") && rect.width === 0 && rect.height === 0;
 		const incidentEdge = longEdgeDummy ? input.graph.edges.find((edge) => edge.sourceId === id || edge.targetId === id) : void 0;
@@ -1736,6 +1758,7 @@ function applyPostCompaction(input, placement, routes) {
 		};
 	});
 	if (routes) for (const [edgeId, readonlyPoints] of routes.pointsByEdgeId) {
+		if (routes.outsideFeedbackEdgeIds?.has(edgeId)) continue;
 		const points = readonlyPoints;
 		for (let index = 0; index + 1 < points.length; index++) {
 			const first = points[index];
@@ -1756,7 +1779,10 @@ function applyPostCompaction(input, placement, routes) {
 	}
 	const verticalSpacing = (left, right) => left.kind === "node" && right.kind === "node" ? input.spacing.node : left.kind === "segment" && right.kind === "segment" && left.edgeId === right.edgeId ? 1 : Number(input.settings[left.kind === "segment" && right.kind === "segment" ? "spacing.edgeEdge" : "spacing.edgeNode"] ?? 10);
 	const horizontalSpacing = (left, right) => left.kind === "node" && right.kind === "node" ? input.spacing.node : left.kind === "segment" && right.kind === "segment" && left.edgeId === right.edgeId ? 0 : Number(input.settings[left.kind === "segment" && right.kind === "segment" ? "spacing.edgeEdge" : "spacing.edgeNode"] ?? 10);
+	const centerLabeledEdgeIds = new Set(input.graph.edges.filter((edge) => (edge.width ?? 0) > 0 && (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER").map((edge) => edge.id));
+	const labelFlowLocked = new Set(compactables.filter((item) => item.kind === "segment" && item.edgeId !== void 0 && centerLabeledEdgeIds.has(item.edgeId)).map((item) => item.id));
 	const compact$1 = (direction, locked = /* @__PURE__ */ new Set()) => {
+		locked = new Set([...labelFlowLocked, ...locked]);
 		const nodes = compactables.map((item) => ({
 			...item,
 			x: direction === "RIGHT" ? -item.x - item.width : item.x,
@@ -1823,6 +1849,7 @@ function applyPostCompaction(input, placement, routes) {
 			for (const node of input.graph.nodes) {
 				const targets = outgoing.get(node.id) ?? [];
 				if (targets.length <= (incomingDegree.get(node.id) ?? 0) || targets.length === 0) continue;
+				if (input.graph.edges.some((edge) => edge.sourceId === node.id && centerLabeledEdgeIds.has(edge.id))) continue;
 				const item = itemByNodeId.get(node.id);
 				if (!item) continue;
 				const upper = Math.min(...targets.map((targetId) => (itemByNodeId.get(targetId)?.x ?? item.x) - item.width - input.spacing.node));
@@ -1830,6 +1857,49 @@ function applyPostCompaction(input, placement, routes) {
 			}
 		}
 	}
+	if (strategy === "EDGE_LENGTH" && input.settings["nodePlacement.favorStraightEdges"] === true && (input.direction === "down" || input.direction === "up")) {
+		const itemByNodeId = new Map(compactables.flatMap((item) => item.kind === "node" && item.nodeId ? [[item.nodeId, item]] : []));
+		const incomingDegree = new Map(input.graph.nodes.map((node) => [node.id, 0]));
+		for (const edge of input.graph.edges) if (edge.sourceId !== edge.targetId) incomingDegree.set(edge.targetId, (incomingDegree.get(edge.targetId) ?? 0) + 1);
+		for (const edge of input.graph.edges) {
+			if (edge.sourceId === edge.targetId || (incomingDegree.get(edge.targetId) ?? 0) !== 1) continue;
+			const endpoints$2 = originalEndpointsByEdgeId.get(edge.id);
+			const source = itemByNodeId.get(edge.sourceId);
+			const target = itemByNodeId.get(edge.targetId);
+			if (!endpoints$2 || !source || !target) continue;
+			if (!(input.direction === "down" ? endpoints$2.start.y < endpoints$2.end.y : endpoints$2.start.y > endpoints$2.end.y)) continue;
+			const desiredTargetX = source.x + (endpoints$2.start.x - source.originalX) - (endpoints$2.end.x - target.originalX);
+			if (compactables.some((candidate) => {
+				if (candidate.kind !== "node" || candidate === target) return false;
+				if (!(candidate.y < target.y + target.height && candidate.y + candidate.height > target.y)) return false;
+				const spacing = input.spacing.node;
+				return desiredTargetX < candidate.x + candidate.width + spacing && desiredTargetX + target.width + spacing > candidate.x;
+			})) continue;
+			target.x = desiredTargetX;
+			const alignedX = source.x + (endpoints$2.start.x - source.originalX);
+			for (const segment of compactables) if (segment.kind === "segment" && segment.edgeId === edge.id) segment.x = alignedX;
+		}
+	}
+	if (input.direction === "right" && centerLabeledEdgeIds.size > 0) {
+		const itemByNodeId = new Map(compactables.flatMap((item) => item.kind === "node" && item.nodeId ? [[item.nodeId, item]] : []));
+		const edgeNodeSpacing = Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10);
+		for (const edge of input.graph.edges) {
+			if (!centerLabeledEdgeIds.has(edge.id)) continue;
+			const source = itemByNodeId.get(edge.sourceId);
+			const target = itemByNodeId.get(edge.targetId);
+			const originalEndpoints = originalEndpointsByEdgeId.get(edge.id);
+			if (!source || !target || !originalEndpoints || originalEndpoints.start.x >= originalEndpoints.end.x) continue;
+			const tracks = compactables.filter((item) => item.kind === "segment" && item.edgeId === edge.id);
+			const track = tracks.length > 0 ? Math.max(...tracks.map((item) => item.x)) : void 0;
+			const targetNode = input.graph.nodes.find((node) => node.id === edge.targetId);
+			const targetPort = targetNode?.ports?.find((port) => port.name === edge.targetPort);
+			if (track !== void 0 && targetNode !== void 0 && targetPort !== void 0 && (targetPort.width ?? 8) === 0 && (targetPort.height ?? 8) === 0 && input.nodeSettings?.(targetNode)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.targetId === edge.targetId).length > input.graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId).length) source.x = Math.max(source.x, track - edgeNodeSpacing - (edge.width ?? 0) - input.spacing.layer - source.width);
+			else {
+				const routeStart = track !== void 0 ? track + edgeNodeSpacing : source.x + source.width + input.spacing.layer;
+				target.x = Math.max(target.x, routeStart + (edge.width ?? 0) + input.spacing.layer);
+			}
+		}
+	}
 	const offset = input.padding.left - Math.min(...compactables.map((item) => item.x));
 	for (const item of compactables) item.x += offset;
 	const nodeDeltaById = /* @__PURE__ */ new Map();
@@ -1846,14 +1916,71 @@ function applyPostCompaction(input, placement, routes) {
 		item.points[1].x += delta;
 	}
 	if (routes) {
+		const edgeRouting = input.settings.edgeRouting ?? "ORTHOGONAL";
+		const compactedSplineControls = routes.splineNubControlsByEdgeId ? new Map(routes.splineNubControlsByEdgeId) : void 0;
 		const edgeById = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
 		for (const [edgeId, readonlyPoints] of routes.pointsByEdgeId) {
-			const points = readonlyPoints;
+			const points = [...readonlyPoints];
 			const edge = edgeById.get(edgeId);
 			if (!edge || points.length === 0) continue;
-			points[0].x += nodeDeltaById.get(edge.sourceId) ?? 0;
-			points.at(-1).x += nodeDeltaById.get(edge.targetId) ?? 0;
+			const originalEndpoints = originalEndpointsByEdgeId.get(edgeId);
+			if (originalEndpoints) {
+				points[0] = {
+					...originalEndpoints.start,
+					x: originalEndpoints.start.x + (nodeDeltaById.get(edge.sourceId) ?? 0)
+				};
+				points[points.length - 1] = {
+					...originalEndpoints.end,
+					x: originalEndpoints.end.x + (nodeDeltaById.get(edge.targetId) ?? 0)
+				};
+				if (routes.outsideFeedbackEdgeIds?.has(edgeId)) {
+					const horizontal = input.direction === "left" || input.direction === "right";
+					const startDelta = points[0].x - originalEndpoints.start.x;
+					const endDelta = points.at(-1).x - originalEndpoints.end.x;
+					if (horizontal && points.length >= 6) {
+						for (const index of [1, 2]) points[index] = {
+							...points[index],
+							x: points[index].x + startDelta
+						};
+						for (const index of [points.length - 3, points.length - 2]) points[index] = {
+							...points[index],
+							x: points[index].x + endDelta
+						};
+					} else if (!horizontal && points.length >= 4) {
+						points[1] = {
+							...points[1],
+							x: points[1].x + startDelta
+						};
+						points[points.length - 2] = {
+							...points[points.length - 2],
+							x: points[points.length - 2].x + endDelta
+						};
+					}
+				}
+			}
+			let compactedPoints = points;
+			if (edgeRouting === "ORTHOGONAL") {
+				const horizontal = input.direction === "left" || input.direction === "right";
+				const orthogonal = [];
+				for (const [index, point] of points.entries()) {
+					const previous = orthogonal.at(-1);
+					if (previous && Math.abs(previous.x - point.x) > 1e-9 && Math.abs(previous.y - point.y) > 1e-9) {
+						const approachingTarget = index === points.length - 1;
+						orthogonal.push(horizontal === approachingTarget ? {
+							x: previous.x,
+							y: point.y
+						} : {
+							x: point.x,
+							y: previous.y
+						});
+					}
+					orthogonal.push(point);
+				}
+				compactedPoints = simplifyRoute$1(orthogonal);
+			} else if (edgeRouting === "SPLINES") compactedSplineControls?.delete(edgeId);
+			routes.pointsByEdgeId.set(edgeId, compactedPoints);
 		}
+		if (compactedSplineControls) routes.splineNubControlsByEdgeId = compactedSplineControls;
 	}
 	return placement;
 }
@@ -2046,8 +2173,16 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		const forward = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT" || sourceFlow <= targetFlow;
 		const feedback = input.settings.feedbackEdges === true && orientation?.reversedEdgeIds.has(edge.id) === true;
 		const directionReversed = input.direction === "left" || input.direction === "up";
-		const sourceSide = feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before";
-		const targetSide = feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after";
+		const endpointSide = (nodeId, portName) => {
+			const node = nodeById.get(nodeId);
+			const port = node?.ports?.find((candidate) => candidate.name === portName);
+			const constraints = node ? input.nodeSettings?.(node)?.portConstraints : void 0;
+			if (!node || !port || constraints !== "FIXED_SIDE" && constraints !== "FIXED_ORDER" && constraints !== "FIXED_RATIO" && constraints !== "FIXED_POS") return;
+			const configured = input.portSettings?.(port, node)?.["port.side"];
+			return configured === "WEST" || configured === "NORTH" ? "before" : configured === "EAST" || configured === "SOUTH" ? "after" : void 0;
+		};
+		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort) ?? (feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before");
+		const targetSide = endpointSide(edge.targetId, edge.targetPort) ?? (feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after");
 		const sourceKey = `${edge.sourceId}:${sourceSide}`;
 		const targetKey = `${edge.targetId}:${targetSide}`;
 		const sourceGroup = groups.get(sourceKey) ?? [];
@@ -2169,8 +2304,14 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 function routeEdges(style) {
 	return (input, orientation, placement) => {
 		const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+		const hasZeroFixedSideTarget = (edge) => {
+			const target = nodeById.get(edge.targetId);
+			const port = target?.ports?.find((candidate) => candidate.name === edge.targetPort);
+			return target !== void 0 && port !== void 0 && (port.width ?? 8) === 0 && (port.height ?? 8) === 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE";
+		};
 		const pointsByEdgeId = /* @__PURE__ */ new Map();
 		const splineNubControlsByEdgeId = /* @__PURE__ */ new Map();
+		const outsideFeedbackEdgeIds = /* @__PURE__ */ new Set();
 		const horizontal = input.direction === "left" || input.direction === "right";
 		const reverse = input.direction === "up" || input.direction === "left";
 		const mutableRects = placement.rectByNodeId;
@@ -2181,6 +2322,35 @@ function routeEdges(style) {
 			loops.push(edge);
 			selfLoopsByNodeId.set(edge.sourceId, loops);
 		}
+		const selfLoopEntriesByX = [...selfLoopsByNodeId].sort(([leftId], [rightId]) => (mutableRects.get(leftId)?.x ?? 0) - (mutableRects.get(rightId)?.x ?? 0));
+		for (const [id, loops] of selfLoopEntriesByX) {
+			const rect = mutableRects.get(id);
+			const node = nodeById.get(id);
+			if (!rect || !node) continue;
+			const eastLoops = loops.filter((edge) => {
+				const sourcePort = node.ports?.find((port) => port.name === edge.sourcePort);
+				const targetPort = node.ports?.find((port) => port.name === edge.targetPort);
+				return sourcePort !== void 0 && targetPort !== void 0 && input.portSettings?.(sourcePort, node)?.["port.side"] === "EAST" && input.portSettings?.(targetPort, node)?.["port.side"] === "EAST";
+			});
+			if (eastLoops.length === 0) continue;
+			const selfLoopSpacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+			const exteriorWidth = selfLoopSpacing + eastLoops.reduce((sum, edge) => sum + (edge.width ?? 0) + labelSpacing, 1);
+			const nodeRight = rect.x + rect.width;
+			const rightCandidates = [...mutableRects.entries()].filter(([candidateId, candidateRect]) => candidateId !== id && candidateRect.x >= nodeRight - 1e-9);
+			if (rightCandidates.length === 0) continue;
+			const nextX = Math.min(...rightCandidates.map(([, candidateRect]) => candidateRect.x));
+			const shift = nodeRight + exteriorWidth + input.spacing.node - nextX;
+			if (shift <= 0) continue;
+			for (const [candidateId, candidateRect] of mutableRects) {
+				if (candidateId === id || candidateRect.x < nextX - 1e-9) continue;
+				mutableRects.set(candidateId, {
+					...candidateRect,
+					x: candidateRect.x + shift
+				});
+			}
+		}
+		const northReserveByLayer = /* @__PURE__ */ new Map();
 		for (const [id, loops] of selfLoopsByNodeId) {
 			const rect = mutableRects.get(id);
 			if (!rect) continue;
@@ -2198,12 +2368,17 @@ function routeEdges(style) {
 			else {
 				const sideLoopCount = distribution === "NORTH_SOUTH" ? Math.ceil(loops.length / 2) : loops.length;
 				const reserve = (ordering === "SEQUENCED" ? Math.min(1, sideLoopCount) : sideLoopCount) * spacing + splineOffset;
-				mutableRects.set(id, {
-					...rect,
-					y: rect.y + reserve
-				});
+				northReserveByLayer.set(rect.y, Math.max(northReserveByLayer.get(rect.y) ?? 0, reserve));
 			}
 		}
+		const northReserves = [...northReserveByLayer].sort(([left], [right]) => left - right);
+		for (const [candidateId, candidateRect] of mutableRects) {
+			const reserve = northReserves.reduce((total, [layerY, layerReserve]) => candidateRect.y + 1e-9 >= layerY ? total + layerReserve : total, 0);
+			if (reserve > 0) mutableRects.set(candidateId, {
+				...candidateRect,
+				y: candidateRect.y + reserve
+			});
+		}
 		const edgeLabelSideSelection = input.settings["edgeLabels.sideSelection"] ?? "SMART_DOWN";
 		if (edgeLabelSideSelection === "ALWAYS_UP" || edgeLabelSideSelection === "SMART_UP" || edgeLabelSideSelection === "DIRECTION_UP") {
 			let crossShift = 0;
@@ -2243,12 +2418,13 @@ function routeEdges(style) {
 		}
 		const labelExtraByGap = flowLayers.slice(0, -1).map(() => 0);
 		for (const edge of input.graph.edges) {
-			if ((edge.width ?? 0) <= 0) continue;
+			const labelFlowSize = horizontal ? edge.width ?? 0 : edge.height ?? 0;
+			if (labelFlowSize <= 0) continue;
 			const sourceLayer = flowLayerByNodeId.get(edge.sourceId);
 			const targetLayer = flowLayerByNodeId.get(edge.targetId);
 			if (sourceLayer === void 0 || targetLayer === void 0) continue;
 			if (Math.abs(sourceLayer - targetLayer) !== 1) continue;
-			const extra = (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER" ? (edge.width ?? 0) + input.spacing.layer : (edge.width ?? 0) + Number(input.settings["spacing.edgeLabel"] ?? 2);
+			const extra = (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER" ? labelFlowSize + input.spacing.layer : labelFlowSize + Number(input.settings["spacing.edgeLabel"] ?? 2);
 			const gap = Math.min(sourceLayer, targetLayer);
 			labelExtraByGap[gap] = Math.max(labelExtraByGap[gap] ?? 0, extra);
 		}
@@ -2493,13 +2669,15 @@ function routeEdges(style) {
 				bounds.start = nextStart;
 				bounds.end = nextStart + size;
 				const slots = slotsByGap[layerNo] ?? 0;
-				const gapSpacing = slots === 0 ? existingGapByLayer[layerNo] ?? input.spacing.layer : Math.max(preservesNodeFlexibilityGap ? existingGapByLayer[layerNo] ?? input.spacing.layer : input.spacing.layer, 2 * edgeNodeSpacing + Math.max(0, slots - 1) * edgeEdgeSpacing);
+				const routesNearTarget = candidatesByGap[layerNo]?.some((candidate) => hasZeroFixedSideTarget(candidate.edge) && candidatesByGap[layerNo].filter(({ edge }) => edge.targetId === candidate.edge.targetId).length > candidatesByGap[layerNo].filter(({ edge }) => edge.sourceId === candidate.edge.sourceId).length);
+				const preservedGap = (existingGapByLayer[layerNo] ?? input.spacing.layer) - (routesNearTarget ? edgeEdgeSpacing : 0);
+				const gapSpacing = slots === 0 ? existingGapByLayer[layerNo] ?? input.spacing.layer : Math.max(preservesNodeFlexibilityGap || (labelExtraByGap[layerNo] ?? 0) > 0 ? preservedGap : input.spacing.layer, 2 * edgeNodeSpacing + Math.max(0, slots - 1) * edgeEdgeSpacing);
 				nextStart = bounds.end + gapSpacing;
 			}
 			implicitEndpoints = implicitEdgeEndpoints(input, placement, orientation);
 			for (const [gap, candidates] of candidatesByGap.entries()) for (const candidate of candidates) {
 				if (candidate.straight) continue;
-				const firstTrack = (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + (candidate.slot ?? 0) * edgeEdgeSpacing;
+				const firstTrack = input.direction === "right" && hasZeroFixedSideTarget(candidate.edge) && candidates.filter(({ edge }) => edge.targetId === candidate.edge.targetId).length > candidates.filter(({ edge }) => edge.sourceId === candidate.edge.sourceId).length ? (flowLayers[gap + 1]?.start ?? 0) - edgeNodeSpacing - (candidate.slot ?? 0) * edgeEdgeSpacing : (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + (candidate.slot ?? 0) * edgeEdgeSpacing;
 				if (candidate.secondSlot !== void 0 && candidate.crossover !== void 0) orthogonalDetourByEdgeId.set(candidate.edge.id, {
 					firstTrack,
 					secondTrack: (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + candidate.secondSlot * edgeEdgeSpacing,
@@ -2663,7 +2841,7 @@ function routeEdges(style) {
 					}] : [];
 				});
 				const incoming = segments.map(() => 0);
-				for (const dependency of acyclicDependencies) incoming[dependency.target]++;
+				for (const dependency of acyclicDependencies) incoming[dependency.target] = (incoming[dependency.target] ?? 0) + 1;
 				const queue = incoming.flatMap((count, index) => count === 0 ? [index] : []);
 				const rank = segments.map(() => 0);
 				for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
@@ -2745,67 +2923,92 @@ function routeEdges(style) {
 			const sourceRect = placement.rectByNodeId.get(edge.sourceId);
 			const targetRect = placement.rectByNodeId.get(edge.targetId);
 			if (!source || !target || !sourceRect || !targetRect) continue;
-			if (input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id)) {
-				const spacing = Number(input.settings["spacing.edgeNode"] ?? 10);
+			const reversedEdge = orientation.reversedEdgeIds.has(edge.id);
+			const feedbackSourcePort = source.ports?.find((port) => port.name === edge.sourcePort);
+			const feedbackTargetPort = target.ports?.find((port) => port.name === edge.targetPort);
+			const feedbackSourcePortSide = feedbackSourcePort ? input.portSettings?.(feedbackSourcePort, source)?.["port.side"] : void 0;
+			const feedbackTargetPortSide = feedbackTargetPort ? input.portSettings?.(feedbackTargetPort, target)?.["port.side"] : void 0;
+			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 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);
+				const flowSpacing = fixedSideFeedback ? Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10) + (source.id === target.id ? Number(input.settings["spacing.nodeSelfLoop"] ?? 10) : 0) : crossSpacing;
+				const sourceFallback$1 = implicitEndpoints.get(edge.id)?.source ?? {
+					x: sourceRect.x + sourceRect.width / 2,
+					y: sourceRect.y + sourceRect.height / 2
+				};
+				const targetFallback$1 = implicitEndpoints.get(edge.id)?.target ?? {
+					x: targetRect.x + targetRect.width / 2,
+					y: targetRect.y + targetRect.height / 2
+				};
+				const start$1 = fixedSideFeedback ? getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback$1, input.direction, input) : sourceFallback$1;
+				const end$1 = fixedSideFeedback ? getPortPoint(target, edge.targetPort, targetRect, targetFallback$1, input.direction, input) : targetFallback$1;
 				if (horizontal) {
-					const sign = reverse ? -1 : 1;
-					const start$1 = {
-						x: sign > 0 ? sourceRect.x + sourceRect.width : sourceRect.x,
-						y: sourceRect.y + sourceRect.height / 2
-					};
-					const end$1 = {
-						x: sign > 0 ? targetRect.x : targetRect.x + targetRect.width,
-						y: targetRect.y + targetRect.height / 2
-					};
-					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.y + rect.height)) + spacing;
+					const sign = fixedSideFeedback ? Math.sign(sourceRect.x - targetRect.x) || 1 : reverse ? -1 : 1;
+					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.y + rect.height)) + crossSpacing + (fixedSideFeedback ? .5 : 0);
+					const preserveCenters = fixedSideFeedback && input.settings.unnecessaryBendpoints === true;
 					pointsByEdgeId.set(edge.id, [
 						start$1,
 						{
-							x: start$1.x + sign * spacing,
+							x: start$1.x + sign * flowSpacing,
 							y: start$1.y
 						},
 						{
-							x: start$1.x + sign * spacing,
+							x: start$1.x + sign * flowSpacing,
 							y: outerCross
 						},
+						...preserveCenters ? [{
+							x: sourceRect.x + sourceRect.width / 2,
+							y: outerCross
+						}, {
+							x: targetRect.x + targetRect.width / 2,
+							y: outerCross
+						}] : [],
 						{
-							x: end$1.x - sign * spacing,
+							x: end$1.x - sign * flowSpacing,
 							y: outerCross
 						},
 						{
-							x: end$1.x - sign * spacing,
+							x: end$1.x - sign * flowSpacing,
 							y: end$1.y
 						},
 						end$1
 					]);
 				} else {
-					const sign = reverse ? -1 : 1;
-					const start$1 = {
-						x: sourceRect.x + sourceRect.width / 2,
-						y: sign > 0 ? sourceRect.y + sourceRect.height : sourceRect.y
-					};
-					const end$1 = {
-						x: targetRect.x + targetRect.width / 2,
-						y: sign > 0 ? targetRect.y : targetRect.y + targetRect.height
-					};
-					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.x + rect.width)) + spacing;
+					const sign = fixedSideFeedback ? Math.sign(sourceRect.y - targetRect.y) || 1 : reverse ? -1 : 1;
+					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.x + rect.width)) + crossSpacing + (fixedSideFeedback ? .5 : 0);
+					const preserveCenters = fixedSideFeedback && input.settings.unnecessaryBendpoints === true;
 					pointsByEdgeId.set(edge.id, [
 						start$1,
 						{
 							x: start$1.x,
-							y: start$1.y + sign * spacing
+							y: start$1.y + sign * flowSpacing
 						},
 						{
 							x: outerCross,
-							y: start$1.y + sign * spacing
+							y: start$1.y + sign * flowSpacing
 						},
+						...preserveCenters ? [{
+							x: outerCross,
+							y: sourceRect.y + sourceRect.height / 2
+						}, {
+							x: outerCross,
+							y: targetRect.y + targetRect.height / 2
+						}] : [],
 						{
 							x: outerCross,
-							y: end$1.y - sign * spacing
+							y: end$1.y - sign * flowSpacing
 						},
 						{
 							x: end$1.x,
-							y: end$1.y - sign * spacing
+							y: end$1.y - sign * flowSpacing
 						},
 						end$1
 					]);
@@ -2870,6 +3073,75 @@ function routeEdges(style) {
 				const distribution = nodeSettings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 				const ordering = nodeSettings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
 				if (style === "ORTHOGONAL") {
+					if (sameSideSelfLoop) {
+						const endpoints$2 = implicitEndpoints.get(edge.id);
+						const start$2 = getPortPoint(source, edge.sourcePort, sourceRect, endpoints$2?.source ?? {
+							x: sourceRect.x + sourceRect.width / 2,
+							y: sourceRect.y + sourceRect.height / 2
+						}, input.direction, input);
+						const end$2 = getPortPoint(target, edge.targetPort, targetRect, endpoints$2?.target ?? {
+							x: targetRect.x + targetRect.width / 2,
+							y: targetRect.y + targetRect.height / 2
+						}, input.direction, input);
+						const side = feedbackSourcePortSide;
+						const sameSideLoops = loops.filter((candidate) => {
+							const candidateSourcePort = source.ports?.find((port) => port.name === candidate.sourcePort);
+							const candidateTargetPort = source.ports?.find((port) => port.name === candidate.targetPort);
+							const candidateSourceSide = candidateSourcePort ? input.portSettings?.(candidateSourcePort, source)?.["port.side"] : void 0;
+							const candidateTargetSide = candidateTargetPort ? input.portSettings?.(candidateTargetPort, source)?.["port.side"] : void 0;
+							return candidateSourceSide === side && candidateTargetSide === side;
+						});
+						const sameSideLoopIndex = sameSideLoops.findIndex((candidate) => candidate.id === edge.id);
+						const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+						const trackDistance = spacing + sameSideLoops.slice(0, Math.max(0, sameSideLoopIndex)).reduce((extent$1, candidate) => extent$1 + (side === "EAST" || side === "WEST" ? candidate.width ?? 0 : candidate.height ?? 0) + labelSpacing, 0);
+						if (side === "EAST" || side === "WEST") {
+							const nodeRects = [...placement.rectByNodeId.values()];
+							const minimumNodeX = Math.min(...nodeRects.map((rect) => rect.x));
+							const maximumNodeX = Math.max(...nodeRects.map((rect) => rect.x + rect.width));
+							const maximumNodeY = Math.max(...nodeRects.map((rect) => rect.y + rect.height));
+							const precedingLabelHeight = sameSideLoops.slice(0, Math.max(0, sameSideLoopIndex)).reduce((extent$1, candidate) => extent$1 + (candidate.height ?? 0) + labelSpacing, 0);
+							const nearTrack = side === "EAST" ? sourceRect.x + sourceRect.width + spacing : sourceRect.x - spacing;
+							const farTrack = side === "EAST" ? maximumNodeX + trackDistance + (edge.width ?? 0) : minimumNodeX - trackDistance - (edge.width ?? 0);
+							const exteriorY = maximumNodeY + spacing + precedingLabelHeight + (edge.height ?? 0) / 2 + .5;
+							pointsByEdgeId.set(edge.id, [
+								start$2,
+								{
+									x: nearTrack,
+									y: start$2.y
+								},
+								{
+									x: nearTrack,
+									y: exteriorY
+								},
+								{
+									x: farTrack,
+									y: exteriorY
+								},
+								{
+									x: farTrack,
+									y: end$2.y
+								},
+								end$2
+							]);
+							outsideFeedbackEdgeIds.add(edge.id);
+							continue;
+						}
+						const track$1 = side === "SOUTH" ? sourceRect.y + sourceRect.height + trackDistance : sourceRect.y - trackDistance;
+						pointsByEdgeId.set(edge.id, [
+							start$2,
+							{
+								x: start$2.x,
+								y: track$1
+							},
+							{
+								x: end$2.x,
+								y: track$1
+							},
+							end$2
+						]);
+						outsideFeedbackEdgeIds.add(edge.id);
+						continue;
+					}
 					const routeHorizontalSide = (side, indexOnSide, countOnSide) => {
 						const denominator = countOnSide * 2 + 1;
 						const sequenced = ordering === "SEQUENCED";
@@ -3035,8 +3307,16 @@ function routeEdges(style) {
 				x: targetRect.x + targetRect.width / 2,
 				y: targetRect.y + (reverse ? targetRect.height : 0)
 			});
-			const start = getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
-			const end = getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
+			const sourcePort = source.ports?.find((port) => port.name === edge.sourcePort);
+			const targetPort = target.ports?.find((port) => port.name === edge.targetPort);
+			const sourcePortSide = sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : void 0;
+			const targetPortSide = targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : void 0;
+			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 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);
@@ -3181,14 +3461,15 @@ function routeEdges(style) {
 		}
 		return {
 			pointsByEdgeId,
-			splineNubControlsByEdgeId
+			splineNubControlsByEdgeId,
+			outsideFeedbackEdgeIds
 		};
 	};
 }
 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";
@@ -3202,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");
@@ -3312,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]);
@@ -3347,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);
@@ -3366,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));
@@ -3616,7 +3897,7 @@ function normalizeAndBalance(nodes, previousLayerCounts) {
 	}
 	return filling;
 }
-function runNetworkSimplex(nodes, edges, iterationLimit, previousLayerCounts, balance = true) {
+function runNetworkSimplex(nodes, _edges, iterationLimit, previousLayerCounts, balance = true) {
 	const orderedEdges = nodes.flatMap((node) => node.outgoing);
 	orderedEdges.forEach((edge, index) => edge.order = index);
 	assignInitialLayers(nodes);
@@ -3890,10 +4171,26 @@ function splitLongEdges(input, orientation, assignment) {
 	const originalEdgeBySegmentId = /* @__PURE__ */ new Map();
 	const usedNodeIds = new Set(nodes.map((node) => node.id));
 	const originalNodeIds = new Set(usedNodeIds);
+	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+	const forwardSourceSide = input.direction === "right" ? "EAST" : input.direction === "left" ? "WEST" : input.direction === "down" ? "SOUTH" : "NORTH";
+	const forwardTargetSide = input.direction === "right" ? "WEST" : input.direction === "left" ? "EAST" : input.direction === "down" ? "NORTH" : "SOUTH";
 	for (const edge of input.graph.edges) {
 		const sourceLayer = layerByNodeId.get(edge.sourceId) ?? 0;
 		const targetLayer = layerByNodeId.get(edge.targetId) ?? 0;
-		if (Math.abs(targetLayer - sourceLayer) <= 1 || edge.sourceId === edge.targetId || input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id)) {
+		const span = Math.abs(targetLayer - sourceLayer);
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		const sourcePort = source?.ports?.find((port) => port.name === edge.sourcePort);
+		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 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);
 			if (orientation.reversedEdgeIds.has(edge.id)) reversedEdgeIds.add(edge.id);
@@ -4055,7 +4352,9 @@ function joinLongEdgeRoutes(routes, segmentIdsByEdgeId, preserveInternalDuplicat
 		return result;
 	};
 	const pointsByEdgeId = /* @__PURE__ */ new Map();
+	const outsideFeedbackEdgeIds = /* @__PURE__ */ new Set();
 	for (const [edgeId, segmentIds] of segmentIdsByEdgeId) {
+		if (segmentIds.some((segmentId) => routes.outsideFeedbackEdgeIds?.has(segmentId))) outsideFeedbackEdgeIds.add(edgeId);
 		if (convertLongSplines && segmentIds.length > 1) {
 			const segments = segmentIds.map((segmentId) => routes.pointsByEdgeId.get(segmentId) ?? []).filter((points$1) => points$1.length >= 2);
 			if (segments.length > 1) {
@@ -4128,7 +4427,10 @@ function joinLongEdgeRoutes(routes, segmentIdsByEdgeId, preserveInternalDuplicat
 		} else for (const segmentId of segmentIds) appendPoints(points, routes.pointsByEdgeId.get(segmentId) ?? [], preserveInternalDuplicates || segmentIds.length === 1);
 		pointsByEdgeId.set(edgeId, preserveInternalDuplicates || segmentIds.length === 1 ? points : simplify(points));
 	}
-	return { pointsByEdgeId };
+	return {
+		pointsByEdgeId,
+		outsideFeedbackEdgeIds
+	};
 }
 
 //#endregion
@@ -8181,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)])),
@@ -8199,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}`) } : {}
 		})
 	};
@@ -8396,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) => {
@@ -8421,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";
@@ -8554,12 +9053,115 @@ 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);
+		const first = points?.[0];
+		const last = points?.at(-1);
+		if (edge.sourcePort !== void 0 && first && graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId && candidate.sourcePort === edge.sourcePort).length === 1) routedPortAnchors.set(`${edge.sourceId}\0${edge.sourcePort}`, first);
+		if (edge.targetPort !== void 0 && last && graph.edges.filter((candidate) => candidate.targetId === edge.targetId && candidate.targetPort === edge.targetPort).length === 1) routedPortAnchors.set(`${edge.targetId}\0${edge.targetPort}`, last);
+	}
 	const nodes = graph.nodes.map((node) => {
 		const rect = placement.rectByNodeId.get(node.id);
 		if (!rect) throw new Error(`Node placement missing for ${node.id}`);
-		const ports = placePorts(node.ports, rect, direction, (port) => input.portSettings?.(port, node), {
+		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}`);
+			if (!anchor || port.x === void 0 || port.y === void 0) return port;
+			const configuredAnchor = (input.portSettings?.(port, node))?.["port.anchor"];
+			const width = port.width ?? 0;
+			const height = port.height ?? 0;
+			const defaultAnchorX = port.x >= rect.width ? width : port.x + width <= 0 ? 0 : width / 2;
+			const defaultAnchorY = port.y >= rect.height ? height : port.y + height <= 0 ? 0 : height / 2;
+			const x = anchor.x - rect.x - (configuredAnchor?.x ?? defaultAnchorX);
+			const y = anchor.y - rect.y - (configuredAnchor?.y ?? defaultAnchorY);
+			return {
+				...port,
+				x: x === 0 && Object.is(port.x, -0) ? port.x : x,
+				y: y === 0 && Object.is(port.y, -0) ? port.y : y
+			};
 		});
 		return {
 			...node,
@@ -8567,6 +9169,14 @@ function runLayeredPipeline(graph, options, context) {
 			...ports === void 0 ? {} : { ports }
 		};
 	});
+	const feedbackNodeRects = graph.nodes.flatMap((node) => {
+		const rect = placement.rectByNodeId.get(node.id);
+		return rect ? [rect] : [];
+	});
+	const minimumFeedbackNodeX = Math.min(...feedbackNodeRects.map((rect) => rect.x));
+	const maximumFeedbackNodeX = Math.max(...feedbackNodeRects.map((rect) => rect.x + rect.width));
+	const minimumFeedbackNodeY = Math.min(...feedbackNodeRects.map((rect) => rect.y));
+	const maximumFeedbackNodeY = Math.max(...feedbackNodeRects.map((rect) => rect.y + rect.height));
 	const edges = graph.edges.map((edge) => {
 		const points = [...routes.pointsByEdgeId.get(edge.id) ?? []];
 		const midpoint = getPolylineMidpoint(points);
@@ -8582,11 +9192,56 @@ function runLayeredPipeline(graph, options, context) {
 		const labelDummyRect = placement.rectByNodeId.get(expanded.labelDummyIdByEdgeId.get(edge.id) ?? "");
 		const edgeLabelSideSelection = options.settings?.["edgeLabels.sideSelection"] ?? "SMART_DOWN";
 		const placeLabelUp = edgeLabelSideSelection === "ALWAYS_UP" || edgeLabelSideSelection === "SMART_UP" || edgeLabelSideSelection === "DIRECTION_UP";
-		const routeX = labelPlacement === "TAIL" ? firstPoint.x + labelSpacing : labelPlacement === "HEAD" ? lastPoint.x - width - labelSpacing : midpoint.x - width / 2;
-		const routeY = 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 horizontal = direction === "left" || direction === "right";
-		const x = labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
-		const y = labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
+		const verticalTrack = horizontal ? points.find((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.x === next.x && point.y !== next.y;
+		}) : void 0;
+		const secondPoint = points[1];
+		const beforeLastPoint = points.at(-2);
+		const flowDelta = horizontal ? lastPoint.x - firstPoint.x : lastPoint.y - firstPoint.y;
+		const firstLeadDelta = secondPoint ? horizontal ? secondPoint.x - firstPoint.x : secondPoint.y - firstPoint.y : 0;
+		const lastLeadDelta = beforeLastPoint ? horizontal ? lastPoint.x - beforeLastPoint.x : lastPoint.y - beforeLastPoint.y : 0;
+		const outsideFeedback = routes.outsideFeedbackEdgeIds?.has(edge.id) === true || secondPoint !== void 0 && beforeLastPoint !== void 0 && flowDelta !== 0 && firstLeadDelta * flowDelta < 0 && lastLeadDelta * flowDelta < 0;
+		const horizontalFeedbackCandidate = outsideFeedback ? points.flatMap((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.y === next.y && (point.y < minimumFeedbackNodeY || point.y > maximumFeedbackNodeY) ? [{
+				start: point,
+				end: next,
+				length: Math.abs(next.x - point.x)
+			}] : [];
+		}).sort((left, right) => right.length - left.length)[0] : void 0;
+		const verticalFeedbackCandidate = outsideFeedback ? points.flatMap((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.x === next.x && (point.x < minimumFeedbackNodeX || point.x > maximumFeedbackNodeX) ? [{
+				start: point,
+				end: next,
+				length: Math.abs(next.y - point.y)
+			}] : [];
+		}).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 = 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;
+		const verticalFeedbackTrack = horizontalFeedbackTrack ? void 0 : verticalFeedbackCandidate;
+		const trackNearTarget = verticalTrack !== void 0 && Math.abs(lastPoint.x - verticalTrack.x) < Math.abs(verticalTrack.x - firstPoint.x);
+		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 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,