@statelyai/layout 0.4.2 → 0.5.0

package/dist/{layered-BJu8A21s.cjs → layered-SB2mlAqt.cjs}

@@ -1,4 +1,4 @@
-const require_routing = require('./routing-QIdGGFBe.cjs');
+const require_routing = require('./routing-Phxu1R0x.cjs');
 let _statelyai_graph_layout = require("@statelyai/graph/layout");
 let _statelyai_graph = require("@statelyai/graph");
 
@@ -3719,6 +3719,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 +4936,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 +4972,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 +5124,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 +5269,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 +5365,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 +5379,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);
@@ -7381,6 +7399,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 +7417,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 +7432,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 +7449,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 +7464,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
 					]);
@@ -7924,6 +7953,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 +8028,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 +12848,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 			if (routeAllowed) {
 				if (options.settings?.edgeRouting === "SPLINES" || options.strategies?.routeEdges) throw new require_routing.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 +13878,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 +13989,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 +16313,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 +16335,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 +16369,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 +18738,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 +18882,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: {
@@ -18989,7 +19124,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 +19186,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 +19432,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 +19480,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 +19550,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 +19558,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 +19576,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 +19691,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 +19793,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;
@@ -19950,6 +20095,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 +20130,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.
 *

package/dist/{layout-engine-DnlmGxHL.mjs → layout-engine-BXoIpYL4.mjs}

@@ -1,4 +1,4 @@
-import { K as placePorts, X as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy, z as getPolylineMidpoint } from "./layered-BsAdm_u8.mjs";
+import { K as placePorts, X as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy, z as getPolylineMidpoint } from "./layered-CmL7oynw.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts

package/dist/{layout-engine-BFP1TZbF.cjs → layout-engine-CAyJ-I-u.cjs}

@@ -1,4 +1,4 @@
-const require_layered = require('./layered-BJu8A21s.cjs');
+const require_layered = require('./layered-SB2mlAqt.cjs');
 let _statelyai_graph_layout = require("@statelyai/graph/layout");
 
 //#region src/fixed.ts

package/dist/routing/index.cjs

@@ -1,4 +1,4 @@
-const require_routing = require('../routing-QIdGGFBe.cjs');
+const require_routing = require('../routing-Phxu1R0x.cjs');
 
 exports.applyRoutePatches = require_routing.applyRoutePatches;
 exports.bezierRouting = require_routing.bezierRouting;
@@ -23,7 +23,10 @@ exports.roundCorners = require_routing.roundCorners;
 exports.routeToGraphPatch = require_routing.routeToGraphPatch;
 exports.routeToPoints = require_routing.routeToPoints;
 exports.routeToPolylines = require_routing.routeToPolylines;
+exports.routingPolicies = require_routing.routingPolicies;
 exports.routingStrategies = require_routing.routingStrategies;
+exports.segmentCrossesRect = require_routing.segmentCrossesRect;
 exports.selfLoopRouting = require_routing.selfLoopRouting;
 exports.straightRouting = require_routing.straightRouting;
-exports.toSvgPath = require_routing.toSvgPath;
+exports.toSvgPath = require_routing.toSvgPath;
+exports.trimBezierPathStart = require_routing.trimBezierPathStart;

package/dist/routing/index.d.cts

@@ -1,3 +1,3 @@
-import { _ as RoutingMetrics, a as RouteBounds, b as RoutingStrategy, c as RoutePath, d as RouteSegment, f as RouteSide, g as RoutingGraph, h as RoutingDiagnosticCode, i as RouteAttachment, l as RoutePoint, m as RoutingDiagnostic, n as NativeRoutingStrategy, o as RouteEndpoint, p as RouteStyle, r as Route, s as RoutePatch, t as EdgeRoutingSettings, u as RouteSection, v as RoutingSettings, x as RoutingUpdate, y as RoutingSnapshot } from "../types-uxPlGRof.cjs";
-import { C as getPointAtLength, D as toSvgPath, E as roundCorners, O as applyRoutePatches, S as getPathLength, T as pathFromPoints, _ as routeToPoints, a as fanRouting, b as flattenPath, c as orthogonalRouting, d as routingStrategies, f as selfLoopRouting, g as routeToGraphPatch, h as pathFromSplinePoints, i as curvedRouting, l as parallelRouting, m as getLayoutRoutes, n as bundleRouting, o as octilinearRouting, p as straightRouting, r as busRouting, s as organicRouting, t as bezierRouting, u as polylineRouting, v as routeToPolylines, w as getTangentAtLength, x as getPathBounds, y as FlattenPathOptions } from "../index-B6cWNrMw.cjs";
-export { EdgeRoutingSettings, FlattenPathOptions, NativeRoutingStrategy, Route, RouteAttachment, RouteBounds, RouteEndpoint, RoutePatch, RoutePath, RoutePoint, RouteSection, RouteSegment, RouteSide, RouteStyle, RoutingDiagnostic, RoutingDiagnosticCode, RoutingGraph, RoutingMetrics, RoutingSettings, RoutingSnapshot, RoutingStrategy, RoutingUpdate, applyRoutePatches, bezierRouting, bundleRouting, busRouting, curvedRouting, fanRouting, flattenPath, getLayoutRoutes, getPathBounds, getPathLength, getPointAtLength, getTangentAtLength, octilinearRouting, organicRouting, orthogonalRouting, parallelRouting, pathFromPoints, pathFromSplinePoints, polylineRouting, roundCorners, routeToGraphPatch, routeToPoints, routeToPolylines, routingStrategies, selfLoopRouting, straightRouting, toSvgPath };
+import { A as BezierGuide, C as RoutingPolicy, D as RoutingTangent, E as RoutingStrategy, O as RoutingUpdate, S as RoutingMetrics, T as RoutingSnapshot, _ as RoutingCurve, a as Route, b as RoutingGraph, c as RouteEndpoint, d as RoutePath, f as RoutePoint, g as RouteStyle, h as RouteSide, i as NativeRoutingStrategy, j as trimBezierPathStart, k as BezierEndpoint, l as RouteLabelPlacement, m as RouteSegment, n as BezierRoutingOptions, o as RouteAttachment, p as RouteSection, r as EdgeRoutingSettings, s as RouteBounds, t as BezierEdgeSettings, u as RoutePatch, v as RoutingDiagnostic, w as RoutingSettings, x as RoutingLabel, y as RoutingDiagnosticCode } from "../types-D8pYSn8I.cjs";
+import { A as applyRoutePatches, C as getPathLength, D as roundCorners, E as pathFromPoints, O as segmentCrossesRect, S as getPathBounds, T as getTangentAtLength, _ as routeToGraphPatch, a as fanRouting, b as FlattenPathOptions, c as orthogonalRouting, d as routingStrategies, f as selfLoopRouting, g as pathFromSplinePoints, h as getLayoutRoutes, i as curvedRouting, k as toSvgPath, l as parallelRouting, m as routingPolicies, n as bundleRouting, o as octilinearRouting, p as straightRouting, r as busRouting, s as organicRouting, t as bezierRouting, u as polylineRouting, v as routeToPoints, w as getPointAtLength, x as flattenPath, y as routeToPolylines } from "../index-C0J4ttZe.cjs";
+export { BezierEdgeSettings, BezierEndpoint, BezierGuide, BezierRoutingOptions, EdgeRoutingSettings, FlattenPathOptions, NativeRoutingStrategy, Route, RouteAttachment, RouteBounds, RouteEndpoint, RouteLabelPlacement, RoutePatch, RoutePath, RoutePoint, RouteSection, RouteSegment, RouteSide, RouteStyle, RoutingCurve, RoutingDiagnostic, RoutingDiagnosticCode, RoutingGraph, RoutingLabel, RoutingMetrics, RoutingPolicy, RoutingSettings, RoutingSnapshot, RoutingStrategy, RoutingTangent, RoutingUpdate, applyRoutePatches, bezierRouting, bundleRouting, busRouting, curvedRouting, fanRouting, flattenPath, getLayoutRoutes, getPathBounds, getPathLength, getPointAtLength, getTangentAtLength, octilinearRouting, organicRouting, orthogonalRouting, parallelRouting, pathFromPoints, pathFromSplinePoints, polylineRouting, roundCorners, routeToGraphPatch, routeToPoints, routeToPolylines, routingPolicies, routingStrategies, segmentCrossesRect, selfLoopRouting, straightRouting, toSvgPath, trimBezierPathStart };

package/dist/routing/index.d.mts

@@ -1,3 +1,3 @@
-import { _ as RoutingMetrics, a as RouteBounds, b as RoutingStrategy, c as RoutePath, d as RouteSegment, f as RouteSide, g as RoutingGraph, h as RoutingDiagnosticCode, i as RouteAttachment, l as RoutePoint, m as RoutingDiagnostic, n as NativeRoutingStrategy, o as RouteEndpoint, p as RouteStyle, r as Route, s as RoutePatch, t as EdgeRoutingSettings, u as RouteSection, v as RoutingSettings, x as RoutingUpdate, y as RoutingSnapshot } from "../types-CT2akdK0.mjs";
-import { C as getPointAtLength, D as toSvgPath, E as roundCorners, O as applyRoutePatches, S as getPathLength, T as pathFromPoints, _ as routeToPoints, a as fanRouting, b as flattenPath, c as orthogonalRouting, d as routingStrategies, f as selfLoopRouting, g as routeToGraphPatch, h as pathFromSplinePoints, i as curvedRouting, l as parallelRouting, m as getLayoutRoutes, n as bundleRouting, o as octilinearRouting, p as straightRouting, r as busRouting, s as organicRouting, t as bezierRouting, u as polylineRouting, v as routeToPolylines, w as getTangentAtLength, x as getPathBounds, y as FlattenPathOptions } from "../index-CJQLUKD9.mjs";
-export { EdgeRoutingSettings, FlattenPathOptions, NativeRoutingStrategy, Route, RouteAttachment, RouteBounds, RouteEndpoint, RoutePatch, RoutePath, RoutePoint, RouteSection, RouteSegment, RouteSide, RouteStyle, RoutingDiagnostic, RoutingDiagnosticCode, RoutingGraph, RoutingMetrics, RoutingSettings, RoutingSnapshot, RoutingStrategy, RoutingUpdate, applyRoutePatches, bezierRouting, bundleRouting, busRouting, curvedRouting, fanRouting, flattenPath, getLayoutRoutes, getPathBounds, getPathLength, getPointAtLength, getTangentAtLength, octilinearRouting, organicRouting, orthogonalRouting, parallelRouting, pathFromPoints, pathFromSplinePoints, polylineRouting, roundCorners, routeToGraphPatch, routeToPoints, routeToPolylines, routingStrategies, selfLoopRouting, straightRouting, toSvgPath };
+import { A as BezierGuide, C as RoutingPolicy, D as RoutingTangent, E as RoutingStrategy, O as RoutingUpdate, S as RoutingMetrics, T as RoutingSnapshot, _ as RoutingCurve, a as Route, b as RoutingGraph, c as RouteEndpoint, d as RoutePath, f as RoutePoint, g as RouteStyle, h as RouteSide, i as NativeRoutingStrategy, j as trimBezierPathStart, k as BezierEndpoint, l as RouteLabelPlacement, m as RouteSegment, n as BezierRoutingOptions, o as RouteAttachment, p as RouteSection, r as EdgeRoutingSettings, s as RouteBounds, t as BezierEdgeSettings, u as RoutePatch, v as RoutingDiagnostic, w as RoutingSettings, x as RoutingLabel, y as RoutingDiagnosticCode } from "../types-MAUtJfKQ.mjs";
+import { A as applyRoutePatches, C as getPathLength, D as roundCorners, E as pathFromPoints, O as segmentCrossesRect, S as getPathBounds, T as getTangentAtLength, _ as routeToGraphPatch, a as fanRouting, b as FlattenPathOptions, c as orthogonalRouting, d as routingStrategies, f as selfLoopRouting, g as pathFromSplinePoints, h as getLayoutRoutes, i as curvedRouting, k as toSvgPath, l as parallelRouting, m as routingPolicies, n as bundleRouting, o as octilinearRouting, p as straightRouting, r as busRouting, s as organicRouting, t as bezierRouting, u as polylineRouting, v as routeToPoints, w as getPointAtLength, x as flattenPath, y as routeToPolylines } from "../index-0YVSvMvA.mjs";
+export { BezierEdgeSettings, BezierEndpoint, BezierGuide, BezierRoutingOptions, EdgeRoutingSettings, FlattenPathOptions, NativeRoutingStrategy, Route, RouteAttachment, RouteBounds, RouteEndpoint, RouteLabelPlacement, RoutePatch, RoutePath, RoutePoint, RouteSection, RouteSegment, RouteSide, RouteStyle, RoutingCurve, RoutingDiagnostic, RoutingDiagnosticCode, RoutingGraph, RoutingLabel, RoutingMetrics, RoutingPolicy, RoutingSettings, RoutingSnapshot, RoutingStrategy, RoutingTangent, RoutingUpdate, applyRoutePatches, bezierRouting, bundleRouting, busRouting, curvedRouting, fanRouting, flattenPath, getLayoutRoutes, getPathBounds, getPathLength, getPointAtLength, getTangentAtLength, octilinearRouting, organicRouting, orthogonalRouting, parallelRouting, pathFromPoints, pathFromSplinePoints, polylineRouting, roundCorners, routeToGraphPatch, routeToPoints, routeToPolylines, routingPolicies, routingStrategies, segmentCrossesRect, selfLoopRouting, straightRouting, toSvgPath, trimBezierPathStart };