@statelyai/layout 0.4.3 → 0.5.1

package/dist/{layered-BsAdm_u8.mjs → layered-CUwft7on.mjs}

@@ -1,4 +1,4 @@
-import { A as routeOrthogonal, F as LayoutError, I as UnsupportedLayoutError, M as recordRouteGeometry, N as nativeGeometry, O as overlaps$1, P as worldGeometry, c as orthogonalRouting, k as routeCrosses, v as routeToPoints } from "./routing-CR8flv8b.mjs";
+import { A as overlaps$1, F as recordRouteGeometry, I as nativeGeometry, L as worldGeometry, M as routeOrthogonal, R as LayoutError, c as orthogonalRouting, j as routeCrosses, y as routeToPoints, z as UnsupportedLayoutError } from "./routing-D-LfMXOF.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 import { createGraph } from "@statelyai/graph";
 
@@ -1608,8 +1608,174 @@ function findNode(nodes, id) {
 	return position !== void 0 && nodes[position]?.id === id ? nodes[position] : nodes.find((node) => node.id === id);
 }
 
+//#endregion
+//#region src/layered/self-loop-ports.ts
+const hiddenBySettings = /* @__PURE__ */ new WeakMap();
+/** Sizes of the ports SelfLoopPreProcessor hid from a loop, if any. */
+function hiddenLoopPorts(settings, edgeId) {
+	return hiddenBySettings.get(settings)?.get(edgeId);
+}
+/**
+* ELK's SelfLoopPreProcessor removes ports that carry only self loops from
+* nodes whose port order is not fixed, and SelfLoopPortRestorer later puts
+* them on the loop's side. The layered phases then see implicit loop ports;
+* {@link restoreSelfLoopPorts} places the hidden ports at the loop ends.
+*/
+function hideSelfLoopPorts(graph, options) {
+	const uses = /* @__PURE__ */ new Map();
+	const nonLoop = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) for (const [node, port] of [[edge.sourceId, edge.sourcePort], [edge.targetId, edge.targetPort]]) {
+		if (port === void 0) continue;
+		const key = `${node}\0${port}`;
+		uses.set(key, (uses.get(key) ?? 0) + 1);
+		if (edge.sourceId !== edge.targetId) nonLoop.add(key);
+	}
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const hidden = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	const hiddenPorts = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) {
+		if (edge.sourceId !== edge.targetId || edge.sourcePort === void 0 || edge.targetPort === void 0 || edge.sourcePort === edge.targetPort) continue;
+		const node = nodeById.get(edge.sourceId);
+		const constraints = node && options.nodeSettings?.(node)?.portConstraints;
+		if (!node || constraints !== void 0 && constraints !== "FREE" && constraints !== "UNDEFINED") continue;
+		const ports = [edge.sourcePort, edge.targetPort].map((name) => node.ports?.find((port) => port.name === name));
+		if (ports.some((port) => !port || uses.get(`${node.id}\0${port.name}`) !== 1 || nonLoop.has(`${node.id}\0${port.name}`))) continue;
+		const size$1 = (port) => ({
+			width: port.width ?? 0,
+			height: port.height ?? 0
+		});
+		hidden.set(edge.id, {
+			source: size$1(ports[0]),
+			target: size$1(ports[1])
+		});
+		edges.set(edge.id, edge);
+		for (const port of ports) hiddenPorts.add(`${node.id}\0${port.name}`);
+	}
+	if (hidden.size === 0) return void 0;
+	const settings = { ...options.settings };
+	hiddenBySettings.set(settings, hidden);
+	return {
+		graph: {
+			...graph,
+			nodes: graph.nodes.map((node) => node.ports?.some((port) => hiddenPorts.has(`${node.id}\0${port.name}`)) ? {
+				...node,
+				ports: node.ports.filter((port) => !hiddenPorts.has(`${node.id}\0${port.name}`))
+			} : node),
+			edges: graph.edges.map((edge) => hidden.has(edge.id) ? {
+				...edge,
+				sourcePort: void 0,
+				targetPort: void 0
+			} : edge)
+		},
+		options: {
+			...options,
+			settings
+		},
+		edges
+	};
+}
+/** Put hidden loop ports back, anchored on the side their loop leaves from. */
+function restoreSelfLoopPorts(graph, result, edges) {
+	const anchors = /* @__PURE__ */ new Map();
+	for (const edge of result.edges) {
+		const original = edges.get(edge.id);
+		const points = edge.points;
+		if (!original || !points?.length) continue;
+		anchors.set(`${edge.sourceId}\0${original.sourcePort}`, points[0]);
+		anchors.set(`${edge.targetId}\0${original.targetPort}`, points.at(-1));
+	}
+	const originalById = new Map(graph.nodes.map((node) => [node.id, node]));
+	return {
+		...result,
+		nodes: result.nodes.map((node) => {
+			const original = originalById.get(node.id)?.ports;
+			if (!original?.some((port) => anchors.has(`${node.id}\0${port.name}`))) return node;
+			const placed = new Map(node.ports?.map((port) => [port.name, port]));
+			return {
+				...node,
+				ports: original.map((port) => {
+					const anchor = anchors.get(`${node.id}\0${port.name}`);
+					const width = port.width ?? 0, height = port.height ?? 0;
+					if (!anchor) return placed.get(port.name) ?? {
+						...port,
+						width,
+						height,
+						x: 0,
+						y: 0
+					};
+					const x = anchor.x - node.x, y = anchor.y - node.y;
+					return {
+						...port,
+						width,
+						height,
+						x: x <= 0 ? x : x >= node.width ? x - width : x - width / 2,
+						y: x <= 0 || x >= node.width ? y - height / 2 : y <= 0 ? y : y - height
+					};
+				})
+			};
+		}),
+		edges: result.edges.map((edge) => {
+			const original = edges.get(edge.id);
+			return original ? {
+				...edge,
+				sourcePort: original.sourcePort,
+				targetPort: original.targetPort
+			} : edge;
+		})
+	};
+}
+
 //#endregion
 //#region src/layered/loop-envelopes.ts
+const crossSide = (side) => side === "NORTH" || side === "SOUTH";
+/**
+* Extents of a movable loop's hidden ports in the canonical rightward frame:
+* along its side, and protruding from it.
+*/
+function loopPortExtents(input, edge, side) {
+	const ports = hiddenLoopPorts(input.settings, edge.id);
+	const horizontal$1 = input.direction === "right" || input.direction === "left";
+	const along = crossSide(side) === horizontal$1 ? "width" : "height";
+	const normal = along === "width" ? "height" : "width";
+	return {
+		along: ports ? ports.source[along] + ports.target[along] : 0,
+		normal: ports ? Math.max(ports.source[normal], ports.target[normal]) : 0
+	};
+}
+/** A movable loop's label extent away from its side, in the canonical frame. */
+function movableLoopLabelExtent(input, edge, side) {
+	const horizontal$1 = input.direction === "right" || input.direction === "left";
+	const size$1 = (crossSide(side) === horizontal$1 ? edge.height : edge.width) ?? 0;
+	return size$1 > 0 ? size$1 + Number(input.settings["spacing.edgeLabel"] ?? 2) : 0;
+}
+/**
+* ELK's OrthogonalSelfLoopRouter routing slot of a movable loop, measured
+* from its node side in the canonical frame: past the protruding ports and
+* the self-loop spacing, then one edge spacing plus any label per inner slot.
+*/
+function movableLoopTrack(input, sideLoops, edge, side, ordering) {
+	const ordered = ordering === "REVERSE_STACKED" ? [...sideLoops].reverse() : sideLoops;
+	const inner = ordering === "SEQUENCED" ? [] : ordered.slice(0, ordered.indexOf(edge));
+	const edgeSpacing = Number(input.settings["spacing.edgeEdge"] ?? 10);
+	return Math.max(0, ...sideLoops.map((loop) => loopPortExtents(input, loop, side).normal)) + Number(input.settings["spacing.nodeSelfLoop"] ?? 10) + inner.reduce((sum, loop) => sum + edgeSpacing + (crossSide(side) ? movableLoopLabelExtent(input, loop, side) : 0), 0);
+}
+/**
+* Canonical position of a movable loop port along its side, given its
+* DISTRIBUTED ratio among the side's implicit ports (ELK's port placement
+* with equal gaps between hidden ports of their own size).
+*/
+function movableLoopPortOffset(input, sideLoops, side, length, ratio) {
+	const count = sideLoops.length * 2;
+	const extents = sideLoops.map((loop) => loopPortExtents(input, loop, side));
+	const total = extents.reduce((sum, extent$2) => sum + extent$2.along, 0);
+	const size$1 = total / count;
+	const index = Math.round(ratio * (count + 1)) - 1;
+	return {
+		along: (length - total) / (count + 1) * (index + 1) + size$1 * index + size$1 / 2,
+		normal: Math.max(0, ...extents.map((extent$2) => extent$2.normal))
+	};
+}
 /** Unconstrained implicit loop ports are restored on loop faces after the sweep. */
 function hasMovableLoopPorts(input, edge) {
 	if (edge.sourceId !== edge.targetId || edge.sourcePort !== void 0 || edge.targetPort !== void 0) return false;
@@ -1647,7 +1813,7 @@ function loopEnvelopes(input) {
 			};
 			const horizontal$1 = input.direction === "right" || input.direction === "left";
 			const reverse = input.direction === "left" || input.direction === "up";
-			const spacing$1 = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+			const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 			let supported = true;
 			const tracks = selfLoopTracks(allLoops);
 			for (const edge of allLoops) {
@@ -1666,7 +1832,7 @@ function loopEnvelopes(input) {
 				}, input.direction, input), getPortPoint(node, edge.targetPort, rect, {
 					x: 0,
 					y: 0
-				}, input.direction, input), sourceSide, targetSide, spacing$1 * (tracks.get(edge.id) + 1), input.direction);
+				}, input.direction, input), sourceSide, targetSide, spacing * (tracks.get(edge.id) + 1), input.direction);
 				if (labeled) {
 					const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
 					const { width = 0, height = 0 } = edge;
@@ -1691,11 +1857,10 @@ function loopEnvelopes(input) {
 			}
 		}
 		const loops = allLoops.filter((edge) => hasMovableLoopPorts(input, edge));
-		if (loops.length === 0 || loops.some((edge) => input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true)) continue;
+		if (loops.length === 0) continue;
 		const settings = input.nodeSettings?.(node);
 		const distribution = settings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 		const ordering = settings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
-		const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 		const envelope = {
 			before: 0,
 			after: 0,
@@ -1708,12 +1873,16 @@ function loopEnvelopes(input) {
 			"flowAfter",
 			"flowBefore"
 		] : distribution === "NORTH_SOUTH" ? ["before", "after"] : ["before"];
+		const canonicalSides = {
+			before: "NORTH",
+			after: "SOUTH",
+			flowAfter: "EAST",
+			flowBefore: "WEST"
+		};
 		for (const side of sides$1) {
 			const selected = loops.filter((_, index) => sides$1[index % sides$1.length] === side);
-			const horizontal$1 = input.direction === "right" || input.direction === "left";
-			const crossSize$3 = side === "before" || side === "after" ? horizontal$1 ? "height" : "width" : horizontal$1 ? "width" : "height";
-			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
-			envelope[side] = spacing * (ordering === "SEQUENCED" ? Math.min(1, selected.length) : selected.length) + selected.reduce((sum, edge) => sum + ((edge[crossSize$3] ?? 0) > 0 ? (edge[crossSize$3] ?? 0) + labelSpacing : 0), 0);
+			const canonical = canonicalSides[side];
+			envelope[side] = Math.max(0, ...selected.map((edge) => movableLoopTrack(input, selected, edge, canonical, ordering) + movableLoopLabelExtent(input, edge, canonical)));
 		}
 		envelopes.set(node.id, envelope);
 	}
@@ -2881,7 +3050,7 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 		if (point.x >= rect.x + rect.width - 1e-9) return "EAST";
 		return point.y <= rect.y ? "NORTH" : "SOUTH";
 	};
-	const crossSide = (side) => side === "NORTH" || side === "SOUTH";
+	const crossSide$1 = (side) => side === "NORTH" || side === "SOUTH";
 	const segments = [];
 	for (const [edgeId, points] of canonicalRoutes) {
 		const edge = edgeById.get(edgeId);
@@ -2891,8 +3060,8 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 			const first = points[index];
 			const second = points[index + 1];
 			if (Math.abs(first.x - second.x) > 1e-9 || Math.abs(first.y - second.y) < 1e-9) continue;
-			if (index === 0 && !crossSide(endpointSide(edge.sourceId, edge.sourcePort, first))) continue;
-			if (index === points.length - 2 && !crossSide(endpointSide(edge.targetId, edge.targetPort, second))) continue;
+			if (index === 0 && !crossSide$1(endpointSide(edge.sourceId, edge.sourcePort, first))) continue;
+			if (index === points.length - 2 && !crossSide$1(endpointSide(edge.targetId, edge.targetPort, second))) continue;
 			const owner = index === 0 ? nodes.get(edge.sourceId) : index === points.length - 2 ? nodes.get(edge.targetId) : void 0;
 			const ownerSide = owner ? endpointSide(index === 0 ? edge.sourceId : edge.targetId, index === 0 ? edge.sourcePort : edge.targetPort, index === 0 ? first : second) : void 0;
 			const bend = index === 0 ? second : first;
@@ -3055,7 +3224,7 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 		const points = canonicalRoutes.get(edge.id);
 		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort, points?.[0]);
 		const targetSide = endpointSide(edge.targetId, edge.targetPort, points?.at(-1));
-		if (crossSide(sourceSide) && crossSide(targetSide)) continue;
+		if (crossSide$1(sourceSide) && crossSide$1(targetSide)) continue;
 		const reversed = orientation?.reversedEdgeIds.has(edge.id) ?? source.x > target.x;
 		const from = reversed ? target : source, to = reversed ? source : target;
 		constraints.push({
@@ -3149,8 +3318,8 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 			const start = pointToCanonical(originals[0]);
 			const next = pointToCanonical(originals[1]);
 			const previous = pointToCanonical(originals.at(-2));
-			if (!crossSide(endpointSide(edge.sourceId, edge.sourcePort, start)) && Math.abs(start.x - next.x) < 1e-9) points[1].x = points[0].x;
-			if (!crossSide(endpointSide(edge.targetId, edge.targetPort, end)) && Math.abs(end.x - previous.x) < 1e-9) points[points.length - 2].x = points.at(-1).x;
+			if (!crossSide$1(endpointSide(edge.sourceId, edge.sourcePort, start)) && Math.abs(start.x - next.x) < 1e-9) points[1].x = points[0].x;
+			if (!crossSide$1(endpointSide(edge.targetId, edge.targetPort, end)) && Math.abs(end.x - previous.x) < 1e-9) points[points.length - 2].x = points.at(-1).x;
 		}
 	}
 	const extent$2 = Math.max(...items.map((item) => item.x + item.width), ...[...canonicalRoutes.values()].flatMap((points) => points.map((point) => point.x)));
@@ -3719,6 +3888,19 @@ function assertNorthSouthPortSides(graph) {
 //#region src/layered/strategies.ts
 const modelSweepInputs = /* @__PURE__ */ new WeakSet();
 const nodeRelativePortRanksByInput = /* @__PURE__ */ new WeakMap();
+const labelPortSideFeedbackByInput = /* @__PURE__ */ new WeakMap();
+/**
+* @internal Collect the feedback segments routed to a center-label dummy's port
+* sides. Exempt segments keep the plain feedback detour instead.
+*/
+function trackLabelPortSideFeedback(input, exempt) {
+	const routed = /* @__PURE__ */ new Set();
+	labelPortSideFeedbackByInput.set(input, {
+		exempt,
+		routed
+	});
+	return routed;
+}
 function getOrientedEndpoints(edge, orientation) {
 	return orientation.reversedEdgeIds.has(edge.id) ? [edge.targetId, edge.sourceId] : [edge.sourceId, edge.targetId];
 }
@@ -4923,7 +5105,7 @@ const assignLayersWithCoffmanGraham = (input, orientation) => {
 		seedOrder: [...layerMembers].reverse().flat()
 	};
 };
-function sortLayerByAdjacentPosition(layer, ranksByNodeId, statistic, random, preOrdered = true, sourceUnknownPlacement = true, perturbSummedWeight = true, units, sameLayerNeighbors = /* @__PURE__ */ new Map(), orderedVisits, forcedCompare) {
+function sortLayerByAdjacentPosition(layer, ranksByNodeId, statistic, random, preOrdered = true, sourceUnknownPlacement = true, perturbSummedWeight = true, units, sameLayerNeighbors = /* @__PURE__ */ new Map(), orderedVisits, forcedCompare, forcedTies) {
 	const originalIndex = new Map(layer.map((nodeId, index) => [nodeId, index]));
 	const adjacentPosition = /* @__PURE__ */ new Map();
 	if (units && statistic === "mean") for (const [id, score] of associatedBarycenters(layer, ranksByNodeId, sameLayerNeighbors, units.associates, random, orderedVisits)) adjacentPosition.set(id, score);
@@ -4959,6 +5141,7 @@ function sortLayerByAdjacentPosition(layer, ranksByNodeId, statistic, random, pr
 	}
 	else for (const nodeId of layer) if (adjacentPosition.get(nodeId) === void 0) adjacentPosition.set(nodeId, originalIndex.get(nodeId) ?? 0);
 	const compare = (a, b) => {
+		if (forcedTies?.has(a) || forcedTies?.has(b)) return 0;
 		return forcedCompare?.(a, b) || (adjacentPosition.get(a) ?? 0) - (adjacentPosition.get(b) ?? 0) || (originalIndex.get(a) ?? 0) - (originalIndex.get(b) ?? 0);
 	};
 	if (forcedCompare) insertionSort(layer, transitiveComparator((id) => id, compare));
@@ -5110,6 +5293,10 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	let initialOrderAttempt = usesInitialModelOrder;
 	const sourceUnknownPlacement = true;
 	const forcedCompare = usesInitialModelOrder && input.settings["crossingMinimization.forceNodeModelOrder"] === true ? normalModelComparator(input) : void 0;
+	const forcedTies = forcedCompare ? new Set(input.graph.nodes.filter((node) => {
+		const constraint = input.nodeSettings?.(node)?.["layering.layerConstraint"];
+		return constraint === "FIRST_SEPARATE" || constraint === "LAST_SEPARATE";
+	}).map((node) => node.id)) : void 0;
 	const medianWeights = /* @__PURE__ */ new Map();
 	const listedEdgeIds = /* @__PURE__ */ new Map();
 	const listedEdgeId = (edgeId) => {
@@ -5251,7 +5438,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	const shuffleFirstLayer = (forward) => {
 		const firstLayerIndex = forward ? 0 : Math.max(0, working.length - 1);
 		const firstLayerWeights = new Map((working[firstLayerIndex] ?? []).map((id) => [id, random.nextDouble()]));
-		const compare = (left, right) => forcedCompare?.(left, right) || (firstLayerWeights.get(left) ?? 0) - (firstLayerWeights.get(right) ?? 0);
+		const compare = (left, right) => forcedTies?.has(left) || forcedTies?.has(right) ? 0 : forcedCompare?.(left, right) || (firstLayerWeights.get(left) ?? 0) - (firstLayerWeights.get(right) ?? 0);
 		const first = working[firstLayerIndex];
 		if (first) if (forcedCompare) insertionSort(first, transitiveComparator((id) => id, compare));
 		else first.sort(compare);
@@ -5347,7 +5534,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				if (statistic === "median") sortWithMedianWeights(current, previous);
 				else {
 					const adjacent = adjacentRanks(previous, current, true);
-					sortLayerByAdjacentPosition(current, adjacent.ranks, statistic, random, !firstSweep || initialOrderAttempt || canonicalNodes.get(current[0] ?? "")?.type === "EXTERNAL_PORT", sourceUnknownPlacement, true, units, sameLayerNeighbors(isForward), adjacent.visits, forcedCompare);
+					sortLayerByAdjacentPosition(current, adjacent.ranks, statistic, random, !firstSweep || initialOrderAttempt || canonicalNodes.get(current[0] ?? "")?.type === "EXTERNAL_PORT", sourceUnknownPlacement, true, units, sameLayerNeighbors(isForward), adjacent.visits, forcedCompare, forcedTies);
 				}
 				groupMixedPortDirections(current, previous, working[layer + 1]);
 				if (exactPortSweep) distributePorts(layer, true);
@@ -5361,7 +5548,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				if (statistic === "median") sortWithMedianWeights(current, next);
 				else {
 					const adjacent = adjacentRanks(next, current, false);
-					sortLayerByAdjacentPosition(current, adjacent.ranks, statistic, random, !firstSweep || initialOrderAttempt || canonicalNodes.get(current[0] ?? "")?.type === "EXTERNAL_PORT", sourceUnknownPlacement, true, units, sameLayerNeighbors(isForward), adjacent.visits, forcedCompare);
+					sortLayerByAdjacentPosition(current, adjacent.ranks, statistic, random, !firstSweep || initialOrderAttempt || canonicalNodes.get(current[0] ?? "")?.type === "EXTERNAL_PORT", sourceUnknownPlacement, true, units, sameLayerNeighbors(isForward), adjacent.visits, forcedCompare, forcedTies);
 				}
 				groupMixedPortDirections(current, next, working[layer - 1]);
 				if (exactPortSweep) distributePorts(layer, false);
@@ -6409,13 +6596,13 @@ function routeEdges(style) {
 				"WEST"
 			][index % 4] : distribution === "NORTH_SOUTH" && index % 2 === 1 ? "SOUTH" : "NORTH";
 		};
-		const loopDistance = (loops, edge, side, ordering, canonical = false) => {
-			const axis = (side === "NORTH" || side === "SOUTH") === (!canonical || horizontal$1) ? "height" : "width";
+		const loopDistance = (loops, edge, side, ordering) => {
+			const axis = side === "NORTH" || side === "SOUTH" ? "height" : "width";
 			const ordered = ordering === "REVERSE_STACKED" ? [...loops].reverse() : loops;
 			const index = ordered.indexOf(edge);
 			const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
-			const size$1 = (candidate) => canonical || input.edgeSettings?.(candidate)?.["edgeLabels.inline"] === true ? candidate[axis] ?? 0 : 0;
+			const size$1 = (candidate) => input.edgeSettings?.(candidate)?.["edgeLabels.inline"] === true ? candidate[axis] ?? 0 : 0;
 			return spacing * (ordering === "SEQUENCED" ? 1 : index + 1) + ordered.slice(0, index).reduce((extent$2, candidate) => extent$2 + (size$1(candidate) > 0 ? size$1(candidate) + labelSpacing : 0), 0) + (size$1(edge) > 0 && input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? size$1(edge) / 2 + labelSpacing : 0);
 		};
 		const hasFixedLoopPorts = (node) => {
@@ -6470,7 +6657,7 @@ function routeEdges(style) {
 			for (const [id, loops] of selfLoopsByNodeId) {
 				const rect = mutableRects.get(id);
 				const node = nodeById.get(id);
-				if (!rect || !node) continue;
+				if (!rect || !node || hasPlacementLoopEnvelope(placement, id)) continue;
 				const settings = input.nodeSettings?.(node);
 				const distribution = settings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 				const ordering = settings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
@@ -7381,6 +7568,17 @@ function routeEdges(style) {
 				};
 				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;
+				const [forwardSide, backwardSide] = {
+					right: ["EAST", "WEST"],
+					left: ["WEST", "EAST"],
+					down: ["SOUTH", "NORTH"],
+					up: ["NORTH", "SOUTH"]
+				}[input.direction];
+				const labelPortSides = labelPortSideFeedbackByInput.get(input);
+				const faces = (node, side, away) => !fixedSideFeedback && !labelPortSides?.exempt.has(edge.id) && node.id.startsWith("__layout_dummy:label:") && side === away;
+				const sourceFace = faces(source, feedbackSourcePortSide, backwardSide) ? -1 : 1;
+				const targetFace = faces(target, feedbackTargetPortSide, forwardSide) ? -1 : 1;
+				if (sourceFace < 0 || targetFace < 0) labelPortSides?.routed.add(edge.id);
 				if (horizontal$1) {
 					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);
@@ -7388,11 +7586,11 @@ function routeEdges(style) {
 					pointsByEdgeId.set(edge.id, [
 						start$1,
 						{
-							x: start$1.x + sign * flowSpacing,
+							x: start$1.x + sourceFace * sign * flowSpacing,
 							y: start$1.y
 						},
 						{
-							x: start$1.x + sign * flowSpacing,
+							x: start$1.x + sourceFace * sign * flowSpacing,
 							y: outerCross
 						},
 						...preserveCenters ? [{
@@ -7403,11 +7601,11 @@ function routeEdges(style) {
 							y: outerCross
 						}] : [],
 						{
-							x: end$1.x - sign * flowSpacing,
+							x: end$1.x - targetFace * sign * flowSpacing,
 							y: outerCross
 						},
 						{
-							x: end$1.x - sign * flowSpacing,
+							x: end$1.x - targetFace * sign * flowSpacing,
 							y: end$1.y
 						},
 						end$1
@@ -7420,11 +7618,11 @@ function routeEdges(style) {
 						start$1,
 						{
 							x: start$1.x,
-							y: start$1.y + sign * flowSpacing
+							y: start$1.y + sourceFace * sign * flowSpacing
 						},
 						{
 							x: outerCross,
-							y: start$1.y + sign * flowSpacing
+							y: start$1.y + sourceFace * sign * flowSpacing
 						},
 						...preserveCenters ? [{
 							x: outerCross,
@@ -7435,11 +7633,11 @@ function routeEdges(style) {
 						}] : [],
 						{
 							x: outerCross,
-							y: end$1.y - sign * flowSpacing
+							y: end$1.y - targetFace * sign * flowSpacing
 						},
 						{
 							x: end$1.x,
-							y: end$1.y - sign * flowSpacing
+							y: end$1.y - targetFace * sign * flowSpacing
 						},
 						end$1
 					]);
@@ -7574,7 +7772,7 @@ function routeEdges(style) {
 						outsideFeedbackEdgeIds.add(edge.id);
 						continue;
 					}
-					const movable = hasMovableLoopPorts(input, edge) && hasPlacementLoopEnvelope(placement, source.id) && input.edgeSettings?.(edge)?.["edgeLabels.inline"] !== true;
+					const movable = hasMovableLoopPorts(input, edge) && hasPlacementLoopEnvelope(placement, source.id);
 					const loopRect = movable ? {
 						x: 0,
 						y: 0,
@@ -7614,7 +7812,32 @@ function routeEdges(style) {
 							startRatio = (countOnSide + nestingIndex + 1) / denominator;
 							endRatio = (countOnSide - nestingIndex) / denominator;
 						}
-						const distance = loopDistance(loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side), edge, side, ordering, movable);
+						const sideLoops = loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side);
+						if (movable) {
+							const track$1 = movableLoopTrack(input, sideLoops, edge, side, ordering);
+							const sign = side === "NORTH" ? -1 : 1;
+							const base = side === "NORTH" ? 0 : loopRect.height;
+							const [first, last] = [startRatio, endRatio].map((ratio) => movableLoopPortOffset(input, sideLoops, side, loopRect.width, ratio));
+							return [
+								{
+									x: first.along,
+									y: base + sign * first.normal
+								},
+								{
+									x: first.along,
+									y: base + sign * track$1
+								},
+								{
+									x: last.along,
+									y: base + sign * track$1
+								},
+								{
+									x: last.along,
+									y: base + sign * last.normal
+								}
+							];
+						}
+						const distance = loopDistance(sideLoops, edge, side, ordering);
 						const y = side === "NORTH" ? loopRect.y - distance : loopRect.y + loopRect.height + distance;
 						const start$2 = {
 							x: loopRect.x + loopRect.width * startRatio,
@@ -7644,7 +7867,32 @@ function routeEdges(style) {
 						const secondRatio = sequenced ? 1 / denominator : 2 / denominator;
 						const startRatio = side === "EAST" ? firstRatio : secondRatio;
 						const endRatio = side === "EAST" ? secondRatio : firstRatio;
-						const distance = movable || input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? loopDistance(loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side), edge, side, ordering, movable) : spacing * (indexOnSide + 1);
+						const sideLoops = loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side);
+						if (movable) {
+							const track$1 = movableLoopTrack(input, sideLoops, edge, side, ordering);
+							const sign = side === "WEST" ? -1 : 1;
+							const base = side === "WEST" ? 0 : loopRect.width;
+							const [first, last] = [startRatio, endRatio].map((ratio) => movableLoopPortOffset(input, sideLoops, side, loopRect.height, ratio));
+							return [
+								{
+									x: base + sign * first.normal,
+									y: first.along
+								},
+								{
+									x: base + sign * track$1,
+									y: first.along
+								},
+								{
+									x: base + sign * track$1,
+									y: last.along
+								},
+								{
+									x: base + sign * last.normal,
+									y: last.along
+								}
+							];
+						}
+						const distance = input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? loopDistance(sideLoops, edge, side, ordering) : spacing * (indexOnSide + 1);
 						const x = side === "EAST" ? loopRect.x + loopRect.width + distance : loopRect.x - distance;
 						const start$2 = {
 							x: side === "EAST" ? loopRect.x + loopRect.width : loopRect.x,
@@ -7924,6 +8172,55 @@ function routeEdges(style) {
 const routeEdgesOrthogonally = routeEdges("ORTHOGONAL");
 const routeEdgesWithPolylines = routeEdges("POLYLINE");
 const routeEdgesWithSplines = routeEdges("SPLINES");
+const sweptPortRanks = /* @__PURE__ */ new WeakMap();
+/**
+* Order movable ports along each physical side as crossing minimization left
+* them, as ELK places ports from its swept port lists. The lists are
+* clockwise per canonical side.
+*/
+function recordSweptPortOrder(graph, direction, order) {
+	const connected = new Set(graph.edges.flatMap((edge) => [JSON.stringify([edge.sourceId, edge.sourcePort]), JSON.stringify([edge.targetId, edge.targetPort])]));
+	const vertical$1 = direction === "down" || direction === "up";
+	const reverse = direction === "up" || direction === "left";
+	const canonical = direction === "right" ? {
+		NORTH: "NORTH",
+		EAST: "EAST",
+		SOUTH: "SOUTH",
+		WEST: "WEST"
+	} : direction === "left" ? {
+		NORTH: "NORTH",
+		EAST: "WEST",
+		SOUTH: "SOUTH",
+		WEST: "EAST"
+	} : direction === "down" ? {
+		NORTH: "WEST",
+		EAST: "SOUTH",
+		SOUTH: "EAST",
+		WEST: "NORTH"
+	} : {
+		NORTH: "EAST",
+		EAST: "SOUTH",
+		SOUTH: "WEST",
+		WEST: "NORTH"
+	};
+	for (const node of graph.nodes) {
+		if (!node.ports) continue;
+		const swept = order.physicalPortOrderByNodeId?.get(node.id);
+		if (!swept) {
+			sweptPortRanks.delete(node.ports);
+			continue;
+		}
+		const index = new Map(swept.flatMap((id, i) => connected.has(id) ? [[id, i]] : []));
+		const rankByPort = new Map(node.ports.map((port) => [port, index.get(JSON.stringify([node.id, port.name]))]));
+		sweptPortRanks.set(node.ports, (port, side) => {
+			const rank = rankByPort.get(port);
+			if (rank === void 0) return void 0;
+			const alongFlow = (side === "NORTH" || side === "SOUTH") !== vertical$1;
+			const c$1 = canonical[side];
+			return (alongFlow ? (c$1 === "NORTH" ? 1 : -1) * (reverse ? -1 : 1) : c$1 === "EAST" ? 1 : -1) * rank;
+		});
+	}
+}
 function placePorts(ports, rect, direction, portSettings, nodeSettings, portDirection) {
 	if (!ports) return void 0;
 	const horizontal$1 = direction === "left" || direction === "right";
@@ -7950,9 +8247,12 @@ function placePorts(ports, rect, direction, portSettings, nodeSettings, portDire
 		group.push(port);
 		grouped.set(side, group);
 	}
+	const swept = constraints === "FIXED_ORDER" || constraints === "FIXED_POS" || constraints === "FIXED_RATIO" ? void 0 : sweptPortRanks.get(ports);
 	for (const group of grouped.values()) {
-		group.sort((left, right) => Number(portSettings?.(left)?.["port.index"] ?? ports.indexOf(left)) - Number(portSettings?.(right)?.["port.index"] ?? ports.indexOf(right)));
 		const side = sideByPort.get(group[0]);
+		const ranks = swept && group.map((port) => swept(port, side));
+		const ranked = ranks?.every((rank) => rank !== void 0) && group.every((port) => portSettings?.(port)?.["port.index"] === void 0) ? new Map(group.map((port, i) => [port, ranks[i]])) : void 0;
+		group.sort((left, right) => ranked ? ranked.get(left) - ranked.get(right) : Number(portSettings?.(left)?.["port.index"] ?? ports.indexOf(left)) - Number(portSettings?.(right)?.["port.index"] ?? ports.indexOf(right)));
 		if (constraints === "FIXED_ORDER" && (side === "SOUTH" || side === "WEST")) group.reverse();
 	}
 	return ports.map((port) => {
@@ -12767,13 +13067,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 			if (routeAllowed) {
 				if (options.settings?.edgeRouting === "SPLINES" || options.strategies?.routeEdges) throw new UnsupportedLayoutError("Partial layout supports its built-in orthogonal router only");
 				const ancestorIds = new Set([...ancestors(source.id), ...ancestors(target.id)]);
-				const nodeObstacles = graph.nodes.filter((n) => !ancestorIds.has(n.id)).map((n) => n.id === source.id || n.id === target.id ? n : {
-					...n,
-					x: n.x - 1,
-					y: n.y - 1,
-					width: n.width + 2,
-					height: n.height + 2
-				});
+				const nodeObstacles = graph.nodes.filter((n) => !ancestorIds.has(n.id));
 				const labelObstacles = [...edgeById.values()].filter((e) => e.id !== edge.id && e.width > 0 && e.height > 0);
 				const required = waypoints.filter((c$1) => (c$1.strength ?? "required") === "required");
 				const accepted = new Set(required.map((c$1) => c$1.id));
@@ -13803,7 +14097,7 @@ function switchCenterLabelDummies(expansion, labels, order) {
 //#endregion
 //#region src/layered/north-south-ports.ts
 /** Detach fixed cross-axis ports into same-layer units before crossing minimization. */
-function insertNorthSouthPortDummies(expansion) {
+function insertNorthSouthPortDummies(expansion, sortedPorts) {
 	const { input, orientation } = expansion;
 	const vertical$1 = input.direction === "down" || input.direction === "up";
 	const forward = input.direction === "right" ? "EAST" : input.direction === "left" ? "WEST" : input.direction === "down" ? "SOUTH" : "NORTH";
@@ -13914,13 +14208,16 @@ function insertNorthSouthPortDummies(expansion) {
 	for (const node of nodes) if (origins.has(node.id)) node.ports?.sort((a, b) => Number(a.name === "output") - Number(b.name === "output"));
 	const roleOrder = (origin) => origin.input && origin.output ? 2 : origin.input ? 0 : 1;
 	const negativeFlow = input.direction === "left" || input.direction === "up";
+	const modelOrder = (input.settings["considerModelOrder.strategy"] ?? "NONE") !== "NONE";
 	const orderedOrigins = input.graph.nodes.flatMap((node) => {
 		const entries = [...origins].filter(([, origin]) => origin.node.id === node.id);
 		const constraints = input.nodeSettings?.(node)?.portConstraints;
+		const sorted = sortedPorts?.get(node.id);
 		const coordinate = (origin) => {
-			if (constraints === "FIXED_POS" || constraints === "FIXED_RATIO") return (vertical$1 ? origin.port.y ?? 0 : origin.port.x ?? 0) * (negativeFlow ? -1 : 1);
-			const index = node.ports?.indexOf(origin.port) ?? 0;
-			return origin.beforeOwner ? index : -index;
+			const flip = modelOrder && origin.output && !origin.input ? -1 : 1;
+			if (constraints === "FIXED_POS" || constraints === "FIXED_RATIO") return (vertical$1 ? origin.port.y ?? 0 : origin.port.x ?? 0) * (negativeFlow ? -1 : 1) * flip;
+			const index = sorted ? sorted.indexOf(JSON.stringify([node.id, origin.port.name])) : node.ports?.indexOf(origin.port) ?? 0;
+			return (origin.beforeOwner ? index : -index) * flip;
 		};
 		return entries.sort(([, a], [, b]) => Number(!a.beforeOwner) - Number(!b.beforeOwner) || roleOrder(a) - roleOrder(b) || coordinate(a) - coordinate(b));
 	});
@@ -16235,9 +16532,10 @@ function opposed(a, b) {
 * A reversed feedback edge split by label or inverted-port dummies is routed
 * one segment at a time, so each segment detours to the outer feedback track
 * and back to the next dummy. Rejoin the chain as one track: the label's own
-* track, or the outer track with the label moved onto it, whichever is clear.
+* track, or the outer track with the label moved onto it, whichever is clear;
+* failing both, a fresh track past everything else with the label on it.
 */
-function straightenFeedbackChains(chains, pointsByEdgeId, rectByNodeId, horizontal$1) {
+function straightenFeedbackChains(chains, pointsByEdgeId, rectByNodeId, horizontal$1, spacing) {
 	const cross = (p) => horizontal$1 ? p.y : p.x;
 	const flow = (p) => horizontal$1 ? p.x : p.y;
 	const at = (f, c$1) => horizontal$1 ? {
@@ -16256,7 +16554,12 @@ function straightenFeedbackChains(chains, pointsByEdgeId, rectByNodeId, horizont
 		const tail = points.at(-2), end = points.at(-1);
 		const outer = Math.max(...points.map(cross));
 		const labelRect = label && rectByNodeId.get(label.id);
-		for (const track of label ? [label.cross, outer] : [outer]) {
+		const tracks = label ? [label.cross, outer] : [outer];
+		if (labelRect) {
+			const farthest = Math.max(...[...pointsByEdgeId.values()].flatMap((other) => other.map(cross)), ...[...rectByNodeId.values()].map((rect) => horizontal$1 ? rect.y + rect.height : rect.x + rect.width));
+			tracks.push(farthest + spacing + label.cross - (horizontal$1 ? labelRect.y : labelRect.x));
+		}
+		for (const track of tracks) {
 			const route = [
 				start,
 				lead,
@@ -16285,7 +16588,7 @@ function straightenFeedbackChains(chains, pointsByEdgeId, rectByNodeId, horizont
 			}
 			if (simple.at(-1) !== end) continue;
 			if (simple.length >= points.length) break;
-			if ([...pointsByEdgeId].some(([id, other]) => id !== edgeId && opposed(simple, other))) continue;
+			if ([...pointsByEdgeId].some(([id, other]) => id !== edgeId && opposed(simple, other) && !opposed(points, other))) continue;
 			pointsByEdgeId.set(edgeId, simple);
 			if (moved) rectByNodeId.set(label.id, moved);
 			break;
@@ -18654,53 +18957,100 @@ function runSeparatedComponents(graph, options, context) {
 		bottom: options.padding?.bottom ?? 12,
 		left: options.padding?.left ?? 12
 	};
+	const direction = options.direction ?? graph.direction ?? "right";
+	const drawnRects = (result) => {
+		const rects = [];
+		for (const node of result.nodes) {
+			const x$1 = node.x ?? 0, y$1 = node.y ?? 0;
+			rects.push({
+				x: x$1,
+				y: y$1,
+				width: node.width ?? 0,
+				height: node.height ?? 0
+			});
+			for (const port of node.ports ?? []) rects.push({
+				x: x$1 + (port.x ?? 0),
+				y: y$1 + (port.y ?? 0),
+				width: port.width ?? 0,
+				height: port.height ?? 0
+			});
+		}
+		for (const edge of result.edges) {
+			const points = edge.points ?? [];
+			for (let index = 1; index < points.length; index++) {
+				const from = points[index - 1], to = points[index];
+				const x$1 = Math.min(from.x, to.x), y$1 = Math.min(from.y, to.y);
+				rects.push({
+					x: x$1,
+					y: y$1,
+					width: Math.max(from.x, to.x) - x$1,
+					height: Math.max(from.y, to.y) - y$1
+				});
+			}
+			if ((edge.width ?? 0) > 0 || (edge.height ?? 0) > 0) rects.push({
+				x: edge.x ?? 0,
+				y: edge.y ?? 0,
+				width: edge.width ?? 0,
+				height: edge.height ?? 0
+			});
+		}
+		return rects;
+	};
+	const rows = [];
 	let x = 0;
+	for (const component of components) {
+		if (x > 0 && x + component.bounds.width > maxRowWidth) x = 0;
+		if (x === 0) rows.push([]);
+		rows.at(-1).push({
+			component,
+			x
+		});
+		x += component.bounds.width + componentSpacing;
+	}
 	let y = 0;
-	let rowHeight = 0;
 	const compactConnectedComponents = options.settings?.["compaction.connectedComponents"] === true;
 	const placedShapes = [];
 	const nodeResults = /* @__PURE__ */ new Map();
 	const edgeResults = /* @__PURE__ */ new Map();
 	const placements = [];
-	for (const component of components) {
-		if (x > 0 && x + component.bounds.width > maxRowWidth) {
-			x = 0;
-			y += rowHeight + componentSpacing;
-			rowHeight = 0;
-		}
-		let compactedY = y;
-		if (compactConnectedComponents && y > 0) {
-			let requiredY = 0;
-			for (const node of component.result.nodes) {
-				const localLeft = x + (node.x ?? 0) - component.bounds.left;
-				const localRight = localLeft + (node.width ?? 0);
-				const localTop = (node.y ?? 0) - component.bounds.top;
-				for (const placed of placedShapes) {
-					if (localRight <= placed.left || localLeft >= placed.right) continue;
-					requiredY = Math.max(requiredY, placed.bottom + componentSpacing - localTop);
+	for (const row of rows) {
+		const rowWidth = Math.max(...row.map((entry) => entry.x + entry.component.bounds.width));
+		let rowHeight = 0;
+		for (const { component, x: packedX } of row) {
+			const { bounds } = component;
+			const left = direction === "left" ? rowWidth - packedX - bounds.width : packedX;
+			const shapes = drawnRects(component.result).map((rect) => ({
+				left: left + rect.x - bounds.left,
+				top: direction === "up" ? bounds.top + bounds.height - rect.y - rect.height : rect.y - bounds.top,
+				width: rect.width,
+				height: rect.height
+			}));
+			let compactedY = y;
+			if (compactConnectedComponents && y > 0) {
+				let requiredY = 0;
+				for (const shape of shapes) for (const placed of placedShapes) {
+					if (shape.left + shape.width <= placed.left || shape.left >= placed.right) continue;
+					requiredY = Math.max(requiredY, placed.bottom + componentSpacing - shape.top);
 				}
+				compactedY = Math.min(y, requiredY);
 			}
-			compactedY = Math.min(y, requiredY);
+			for (const shape of shapes) placedShapes.push({
+				left: shape.left,
+				right: shape.left + shape.width,
+				top: compactedY + shape.top,
+				bottom: compactedY + shape.top + shape.height
+			});
+			placements.push({
+				component,
+				x: left,
+				y: compactedY
+			});
+			rowHeight = Math.max(rowHeight, bounds.height);
 		}
-		for (const node of component.result.nodes) placedShapes.push({
-			left: x + (node.x ?? 0) - component.bounds.left,
-			right: x + (node.x ?? 0) - component.bounds.left + (node.width ?? 0),
-			top: compactedY + (node.y ?? 0) - component.bounds.top,
-			bottom: compactedY + (node.y ?? 0) - component.bounds.top + (node.height ?? 0)
-		});
-		placements.push({
-			component,
-			x,
-			y: compactedY
-		});
-		x += component.bounds.width + componentSpacing;
-		rowHeight = Math.max(rowHeight, component.bounds.height);
+		y += rowHeight + componentSpacing;
 	}
-	const direction = options.direction ?? graph.direction ?? "right";
-	const packedWidth = Math.max(0, ...placements.map((p) => p.x + p.component.bounds.width));
 	const packedHeight = Math.max(0, ...placements.map((p) => p.y + p.component.bounds.height));
-	for (const { component, x: packedX, y: packedY } of placements) {
-		const left = direction === "left" ? packedWidth - packedX - component.bounds.width : packedX;
+	for (const { component, x: left, y: packedY } of placements) {
 		const top = direction === "up" ? packedHeight - packedY - component.bounds.height : packedY;
 		const dx = padding.left + left - component.bounds.left;
 		const dy = padding.top + top - component.bounds.top;
@@ -18751,7 +19101,11 @@ function runLayeredPipeline(graph, options, context) {
 * coordinator can prepare every scope, share sweep state, then resume each
 * scope with its final order. The ordinary entry point drains this same pipeline.
 */
-function* createLayeredScopePipeline(graph, options, context) {
+function* createLayeredScopePipeline(graph, options, context, fallbacks = {
+	antiparallelPairs: /* @__PURE__ */ new Set(),
+	feedbackSegments: /* @__PURE__ */ new Set()
+}) {
+	const scopeOptions = options;
 	if ((options.settings?.["spacing.edgeEdge"] ?? 10) < 2) options = {
 		...options,
 		settings: {
@@ -18801,6 +19155,8 @@ function* createLayeredScopePipeline(graph, options, context) {
 		const separated$1 = runSeparatedComponents(graph, options, context);
 		if (separated$1) return separated$1;
 	}
+	const hiddenLoopPorts$1 = hideSelfLoopPorts(graph, options);
+	if (hiddenLoopPorts$1) return restoreSelfLoopPorts(graph, yield* createLayeredScopePipeline(hiddenLoopPorts$1.graph, hiddenLoopPorts$1.options, context, fallbacks), hiddenLoopPorts$1.edges);
 	const direction = options.direction ?? graph.direction ?? "right";
 	const padding = typeof options.padding === "number" ? {
 		top: options.padding,
@@ -18989,7 +19345,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 			}
 		};
 	}
-	const northSouth = insertNorthSouthPortDummies(expanded);
+	const northSouth = insertNorthSouthPortDummies(expanded, preparedPorts);
 	expanded = northSouth.expansion;
 	if (prepareModelOrder) markInitialModelOrderPrepared(expanded.input, preparedPorts);
 	const associates = /* @__PURE__ */ new Map(), unitMembers = /* @__PURE__ */ new Map();
@@ -19051,6 +19407,8 @@ function* createLayeredScopePipeline(graph, options, context) {
 		minimize: minimizeScope,
 		finishOrder: finishCrossingOrder
 	};
+	const crossingOrder = order;
+	recordSweptPortOrder(graph, direction, order);
 	traceLayeredPhase(() => ({
 		kind: "crossing-order",
 		scope: graph.id,
@@ -19295,6 +19653,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 	const edgeRouting = options.settings?.edgeRouting ?? "ORTHOGONAL";
 	const edgeRouter = options.strategies?.routeEdges ?? (edgeRouting === "POLYLINE" ? routeEdgesWithPolylines : edgeRouting === "SPLINES" ? routeEdgesWithSplines : routeEdgesOrthogonally);
 	if (options.strategies?.routeEdges) measure("post-compaction", () => applyPostCompaction(expanded.input, placement));
+	const labelPortSideSegments = trackLabelPortSideFeedback(expanded.input, fallbacks.feedbackSegments);
 	let expandedRoutes = measure("edge-routing", () => edgeRouter(expanded.input, expanded.orientation, placement));
 	const restoredJunctionCounts = /* @__PURE__ */ new Map();
 	expandedRoutes = restoreNorthSouthPortRoutes({
@@ -19342,6 +19701,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 	const outerAntiparallelLabelIds = /* @__PURE__ */ new Set();
 	const parallelLabelPositions = /* @__PURE__ */ new Map();
 	const postCompactionNodeCrossDeltas = /* @__PURE__ */ new Map();
+	const flowOrderedPairs = /* @__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()]));
@@ -19411,6 +19771,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 		const horizontal$1 = horizontalAntiparallelFlow;
 		const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
 		const pairEdges = /* @__PURE__ */ new Map();
+		const flowOrder = direction === "left" || direction === "up";
 		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");
@@ -19418,7 +19779,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 			pair.push(edge);
 			pairEdges.set(key, pair);
 		}
-		for (const pair of pairEdges.values()) {
+		for (const [pairKey, pair] of pairEdges) {
 			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;
@@ -19436,11 +19797,13 @@ function* createLayeredScopePipeline(graph, options, context) {
 			};
 			const hasFlexiblePairPorts = hasFlexiblePorts(firstNode) && hasFlexiblePorts(secondNode);
 			if (isolatedAntiparallelPair && !hasFlexiblePairPorts) continue;
-			const firstBeforeSecond = horizontal$1 ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2 : firstRect.y + firstRect.height / 2 < secondRect.y + secondRect.height / 2;
+			const pairFlowOrder = flowOrder && !fallbacks.antiparallelPairs.has(pairKey);
+			const firstBeforeSecond = (horizontal$1 ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2 : firstRect.y + firstRect.height / 2 < secondRect.y + secondRect.height / 2) !== pairFlowOrder;
 			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;
+			if (pairFlowOrder) flowOrderedPairs.set(pairKey, [firstNode.id, secondNode.id]);
 			let cross = Math.min(horizontal$1 ? firstRect.y : firstRect.x, horizontal$1 ? secondRect.y : secondRect.x);
 			const edgeSpacing = Number(options.settings?.["spacing.edgeEdge"] ?? 10);
 			for (const edge of pair) {
@@ -19549,7 +19912,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 					cross: horizontal$1 ? anchor.y : anchor.x
 				}
 			}];
-		}), routes.pointsByEdgeId, placement.rectByNodeId, horizontal$1);
+		}), routes.pointsByEdgeId, placement.rectByNodeId, horizontal$1, Number(options.settings?.["spacing.edgeEdge"] ?? 10));
 	}
 	if (options.settings?.["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT") {
 		const horizontal$1 = direction === "right" || direction === "left";
@@ -19651,8 +20014,11 @@ function* createLayeredScopePipeline(graph, options, context) {
 		}
 	}
 	if ((options.settings?.["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING" && !unzippingFanIn && edgeRouting === "ORTHOGONAL") routes = { pointsByEdgeId: adjustUnzippedSinkRoutes(graph, routes.pointsByEdgeId, direction, Number(options.settings?.["spacing.edgeNodeBetweenLayers"] ?? 10), Number(options.settings?.["spacing.edgeEdgeBetweenLayers"] ?? 10)) };
+	const connectsOnlyTo = (nodeId, otherId) => graph.edges.every((edge) => edge.sourceId === edge.targetId || edge.sourceId !== nodeId && edge.targetId !== nodeId || edge.sourceId === otherId || edge.targetId === otherId);
 	for (const pair of labeledEdgesByPair.values()) {
 		if (pair.length < 2) continue;
+		const { sourceId, targetId } = pair[0];
+		if (!connectsOnlyTo(sourceId, targetId) || !connectsOnlyTo(targetId, sourceId)) continue;
 		const sourceRect = mutableRects.get(pair[0].sourceId);
 		const targetRect = mutableRects.get(pair[0].targetId);
 		if (!sourceRect || !targetRect) continue;
@@ -19872,7 +20238,7 @@ function* createLayeredScopePipeline(graph, options, context) {
 			y: (points[1].y + points[2].y - height) / 2
 		} : void 0;
 		const movableExteriorLoopLabelPosition = (() => {
-			if (edgeRouting !== "ORTHOGONAL" || labelPlacement !== "CENTER" || inlineLabel || !hasMovableLoopPorts(input, edge) || !sourceRect || points.length !== 4) return void 0;
+			if (edgeRouting !== "ORTHOGONAL" || labelPlacement !== "CENTER" || !hasMovableLoopPorts(input, edge) || !sourceRect || points.length !== 4) return void 0;
 			const first = points[1], last = points[2];
 			if (first.y === last.y) {
 				const low = first.y < sourceRect.y;
@@ -19950,6 +20316,28 @@ function* createLayeredScopePipeline(graph, options, context) {
 			};
 		}
 	});
+	if (edgeRouting === "ORTHOGONAL") {
+		const diagonalEdges = edges.filter((edge) => countDiagonals(edge.points) > 0);
+		const antiparallelPairs = [...flowOrderedPairs].flatMap(([key, nodeIds]) => diagonalEdges.some((edge) => nodeIds.includes(edge.sourceId) || nodeIds.includes(edge.targetId)) ? [key] : []);
+		const feedbackSegments = diagonalEdges.flatMap((edge) => {
+			const segments = expanded.segmentIdsByEdgeId.get(edge.id) ?? [edge.id];
+			return segments.some((id) => labelPortSideSegments.has(id)) ? segments : [];
+		});
+		if (antiparallelPairs.length > 0 || feedbackSegments.length > 0) {
+			const retry = createLayeredScopePipeline(graph, scopeOptions, context && {
+				...context,
+				diagnostics: []
+			}, {
+				antiparallelPairs: new Set([...fallbacks.antiparallelPairs, ...antiparallelPairs]),
+				feedbackSegments: new Set([...fallbacks.feedbackSegments, ...feedbackSegments])
+			});
+			const prepared = retry.next();
+			const resumed = prepared.done ? prepared : retry.next(crossingOrder);
+			if (!resumed.done) throw new Error("Layered scope yielded more than one crossing phase");
+			const diagonals = (routed) => routed.reduce((sum, edge) => sum + countDiagonals(edge.points), 0);
+			if (diagonals(resumed.value.edges) < diagonals(edges)) return resumed.value;
+		}
+	}
 	return setElkjs0111ResultPolicy({
 		...graph,
 		direction,
@@ -19963,6 +20351,15 @@ function* createLayeredScopePipeline(graph, options, context) {
 		junctionPointsByEdgeId: routes.junctionPointsByEdgeId
 	});
 }
+function countDiagonals(points) {
+	let count = 0;
+	for (let index = 1; index < (points?.length ?? 0); index++) {
+		const a = points[index - 1];
+		const b = points[index];
+		if (Math.abs(a.x - b.x) > 1e-6 && Math.abs(a.y - b.y) > 1e-6) count++;
+	}
+	return count;
+}
 /**
 * Deterministic native layered layout for an `@statelyai/graph` graph.
 *