@statelyai/layout 0.4.0 → 0.4.1

package/dist/{layered-C7ERzZjR.mjs → layered-DSesbctm.mjs}

@@ -506,10 +506,18 @@ function createOrthogonalHypersegments(ports, connections, listRank) {
 		segmentByPort
 	};
 }
-/** ELK's hyperedge crossing estimate; positions are distinct ordinal port ranks on each side. */
-function countOrthogonalHypersegmentCrossings(ports, connections) {
-	const { segments } = createOrthogonalHypersegments(ports, connections);
-	const spans = segments.map((s) => ({
+/**
+* {@link countOrthogonalHypersegmentCrossings}, optionally separating shared
+* tracks. ELK routes a hyperedge on one shared track. When it joins two or
+* more ports on each side, its edges would run opposite ways along that
+* track, which routing never allows; `separateShared` counts such a
+* hyperedge's edges one by one instead. `shared` reports whether one exists.
+*/
+function scoreOrthogonalHypersegments(ports, connections, separateShared = false) {
+	const { segments: merged, segmentByPort } = createOrthogonalHypersegments(ports, connections);
+	const sharedSegments = new Set(merged.flatMap((s, i) => s.incoming.length > 1 && s.outgoing.length > 1 ? [i] : []));
+	const separating = separateShared && sharedSegments.size > 0;
+	const spans = merged.filter((_, i) => !separating || !sharedSegments.has(i)).map((s) => ({
 		leftStart: Math.min(...s.incoming),
 		leftEnd: Math.max(...s.incoming),
 		rightStart: Math.min(...s.outgoing),
@@ -522,6 +530,43 @@ function countOrthogonalHypersegmentCrossings(ports, connections) {
 		if (a.leftStart < b.leftEnd && b.leftStart < a.leftEnd) count++;
 		if (a.rightStart < b.rightEnd && b.rightStart < a.rightEnd) count++;
 	}
+	if (separating) {
+		const position = new Map(ports.map((p) => [p.id, p.position]));
+		const edges = connections.filter((c$1) => sharedSegments.has(segmentByPort.get(c$1.source))).map((c$1) => [position.get(c$1.source), position.get(c$1.target)]);
+		for (const [left, right] of edges) for (const b of spans) {
+			if ((left - b.leftStart) * (right - b.rightStart) < 0) count++;
+			if (left < b.leftEnd && b.leftStart < left) count++;
+			if (right < b.rightEnd && b.rightStart < right) count++;
+		}
+		count += strictInversions(edges);
+	}
+	return {
+		count,
+		shared: sharedSegments.size > 0
+	};
+}
+/** Pairs whose ends are strictly inverted: two separated edges that cross, in O(n log n). */
+function strictInversions(pairs) {
+	const ranks = [...new Set(pairs.map(([, right]) => right))].sort((a, b) => a - b);
+	const rankOf = new Map(ranks.map((value, index) => [value, index + 1]));
+	const tree = new Array(ranks.length + 1).fill(0);
+	const atMost = (rank) => {
+		let sum = 0;
+		for (let i = rank; i > 0; i -= i & -i) sum += tree[i];
+		return sum;
+	};
+	const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+	let inserted = 0, count = 0;
+	for (let start = 0; start < sorted.length;) {
+		let end = start;
+		while (end < sorted.length && sorted[end][0] === sorted[start][0]) end++;
+		for (let i = start; i < end; i++) count += inserted - atMost(rankOf.get(sorted[i][1]));
+		for (let i = start; i < end; i++) {
+			for (let r = rankOf.get(sorted[i][1]); r <= ranks.length; r += r & -r) tree[r]++;
+			inserted++;
+		}
+		start = end;
+	}
 	return count;
 }
 
@@ -650,21 +695,22 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		betweenLayers: 0,
 		inLayer: 0,
 		northSouth: 0,
-		total: 0
+		total: 0,
+		sharedTracks: false
 	};
 	if (!graph.layers.length) return score;
 	score.inLayer += countPorts(face(graph.layers[0], "WEST"), true);
 	score.inLayer += countPorts(face(graph.layers.at(-1), "EAST"), true);
 	for (const [index, layer] of graph.layers.entries()) {
 		const next = graph.layers[index + 1];
-		if (next) if ((layer.some((node) => node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1)) || next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1))) && boundaryMode === "hyperedges") {
+		if (next) if ((layer.some((node) => node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1)) || next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1))) && boundaryMode !== "edges") {
 			const sourcePorts = layer.flatMap((node) => node.ports).filter((port) => outgoing.get(port.id).some((peer) => layerByPort.get(peer) !== index));
 			const targetPorts = next.flatMap((node) => {
 				const connectedPorts = node.ports.filter((port) => incoming.get(port.id).some((peer) => layerByPort.get(peer) !== index + 1));
 				return [...connectedPorts.filter((port) => port.side === "NORTH").reverse(), ...connectedPorts.filter((port) => port.side !== "NORTH").reverse()];
 			});
 			const sources = new Set(sourcePorts.map((port) => port.id)), targets = new Set(targetPorts.map((port) => port.id));
-			score.betweenLayers += countOrthogonalHypersegmentCrossings([...sourcePorts.map((port, position) => ({
+			const hyperedges = scoreOrthogonalHypersegments([...sourcePorts.map((port, position) => ({
 				id: port.id,
 				side: "source",
 				position
@@ -672,7 +718,9 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 				id: port.id,
 				side: "target",
 				position
-			}))], graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)));
+			}))], graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)), boundaryMode === "separated");
+			score.betweenLayers += hyperedges.count;
+			score.sharedTracks ||= hyperedges.shared;
 			score.inLayer += countPorts(face(layer, "EAST"), true) + countPorts(face(next, "WEST"), true);
 		} else score.betweenLayers += countPorts([...face(layer, "EAST"), ...face(next, "WEST", false)], false);
 		if (layer.some((node) => node.type === "NORTH_SOUTH_PORT")) score.northSouth += countNorthSouth(layer);
@@ -3641,6 +3689,18 @@ function cycleModelOrder(input) {
 	const count = Math.max(1, input.graph.nodes.length);
 	return new Map(input.graph.nodes.map((node, index) => [node.id, enforced ? Number(input.nodeSettings?.(node)?.["considerModelOrder.groupModelOrder.cycleBreakingId"] ?? 0) * count + index : index]));
 }
+/**
+* Internal setting: how crossing minimization models ports and tracks.
+* `mixedPorts` (default true) counts a port carrying both directions as two
+* ports and groups its neighbours by direction. `separateSharedTracks`
+* (default false) counts a hyperedge joining two or more ports on each side
+* of its gap edge by edge, since routing never lets edges run opposite ways
+* along one track. A `probe` records whether either choice can change the
+* order. Each helps on average but steers the sweeps into worse orders on
+* some graphs, so the elkjs facade also lays such graphs out with the
+* alternatives and keeps the best result.
+*/
+const CROSSING_MODEL = "internal.crossingModel";
 const breakCyclesWithDepthFirstSearch = (input) => {
 	const outgoing = /* @__PURE__ */ new Map();
 	for (const node of input.graph.nodes) outgoing.set(node.id, []);
@@ -4128,8 +4188,7 @@ function applyLayerConstraintOrder(input, order) {
 	return {
 		...order,
 		layers: order.layers.map((layer) => {
-			const unconstrained = layer.filter((id) => !constrained.has(id));
-			return [...input.settings.mergeEdges === true ? [...unconstrained.filter((id) => id.startsWith("__layout_dummy:")), ...unconstrained.filter((id) => !id.startsWith("__layout_dummy:"))] : unconstrained, ...layer.filter((id) => constrained.has(id))];
+			return [...layer.filter((id) => !constrained.has(id)), ...layer.filter((id) => constrained.has(id))];
 		})
 	};
 }
@@ -4896,6 +4955,18 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	}
 	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
 	const edgeById = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
+	const boundaryPortIndex = (nodeId, edgeId, incoming) => {
+		const edge = edgeById.get(edgeId);
+		const name = incoming !== orientation.reversedEdgeIds.has(edgeId) ? edge.targetPort : edge.sourcePort;
+		if (!name?.startsWith("__native_hierarchy")) return -1;
+		return nodeById.get(nodeId).ports?.findIndex((port) => port.name === name) ?? -1;
+	};
+	for (const [orders, incoming] of [[outputPortOrder, false], [inputPortOrder, true]]) for (const [nodeId, edgeIds] of orders) {
+		if (edgeIds.length < 2) continue;
+		const slots = edgeIds.flatMap((id, slot) => boundaryPortIndex(nodeId, id, incoming) < 0 ? [] : [slot]);
+		const sorted = slots.map((slot) => edgeIds[slot]).sort((a, b) => boundaryPortIndex(nodeId, a, incoming) - boundaryPortIndex(nodeId, b, incoming));
+		slots.forEach((slot, index) => edgeIds[slot] = sorted[index]);
+	}
 	const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
 	const hierarchicalNodes = /* @__PURE__ */ new Set();
 	const fixedOrderNodes = new Set(input.graph.nodes.filter((node) => {
@@ -4933,10 +5004,24 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		if (edgeIds.length >= 4) edgeIds.splice(0, edgeIds.length - 1, ...edgeIds.slice(0, -1).reverse());
 	}
 	const buildCrossingGraph$1 = createCrossingGraphBuilder(input);
+	const crossingModel = input.settings[CROSSING_MODEL] ?? {};
+	const mixedPorts = crossingModel.mixedPorts !== false, probe = crossingModel.probe;
 	const countCrossings = (candidateLayers) => {
 		if (exactPortSweep) {
 			const graph = buildCrossingGraph$1(orientation, candidateLayers, inputPortOrder, outputPortOrder);
-			let total = countAllCrossings(splitMixedCrossingPorts(graph, canonicalReversed)).total;
+			for (const layer of graph.layers) for (const node of layer) {
+				const physical = node.ports.length > 1 ? canonicalNodes.get(node.id)?.ports : void 0;
+				if (physical?.length !== node.ports.length) continue;
+				const slot = new Map(physical.map((port, index) => [port.id, index]));
+				if (node.ports.every((port) => slot.has(port.id))) node.ports.sort((a, b) => slot.get(a.id) - slot.get(b.id));
+			}
+			const split = mixedPorts ? splitMixedCrossingPorts(graph, canonicalReversed) : graph;
+			const score = countAllCrossings(split, crossingModel.separateSharedTracks ? "separated" : "hyperedges");
+			if (probe) {
+				if (split !== graph) probe.mixedPorts = true;
+				if (score.sharedTracks) probe.sharedTracks = true;
+			}
+			let total = score.total;
 			const nodeInfluence = Number(input.settings["considerModelOrder.crossingCounterNodeInfluence"] ?? 0);
 			if ((input.settings["considerModelOrder.strategy"] ?? "NONE") !== "NONE" && nodeInfluence !== 0) {
 				const changes = countModelOrderChanges(input, orientation, graph);
@@ -4986,11 +5071,12 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				const nodes = fixedLayer.map((id) => canonicalNodes.get(id));
 				canonicalGraph.layers[fixedIndex] = nodes;
 				canonicalDistributor.calculatePortRanks(canonicalGraph, nodes, !forward, nodeRelativePortRanks);
-				const fixedIds = new Set(fixedLayer);
-				for (let index = 0; index < canonicalEdges.length; index++) {
+				const byEnd = forward ? canonicalEdgesBySource : canonicalEdgesByTarget;
+				const indices = fixedLayer.flatMap((id) => byEnd.get(id) ?? []).sort((a, b) => a - b);
+				for (const index of indices) {
 					const edge = canonicalEdges[index];
 					const [source, target] = canonicalOrientedEndpoints[index];
-					if (!fixedIds.has(forward ? source : target) || !freeIds.has(forward ? target : source)) continue;
+					if (!freeIds.has(forward ? target : source)) continue;
 					const endpoint = canonicalEndpoints.get(edge.id);
 					const rank = canonicalDistributor.state.ranks[forward ? endpoint.source : endpoint.target];
 					ranks.get(forward ? target : source).push(rank);
@@ -5072,6 +5158,14 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	const canonicalEdges = input.graph.edges.filter((edge) => edge.sourceId !== edge.targetId);
 	const canonicalReversed = canonicalEdges.map((edge) => orientation.reversedEdgeIds.has(edge.id));
 	const canonicalOrientedEndpoints = canonicalEdges.map((edge) => getOrientedEndpoints(edge, orientation));
+	const canonicalEdgesBySource = /* @__PURE__ */ new Map(), canonicalEdgesByTarget = /* @__PURE__ */ new Map();
+	canonicalOrientedEndpoints.forEach(([source, target], index) => {
+		for (const [byEnd, id] of [[canonicalEdgesBySource, source], [canonicalEdgesByTarget, target]]) {
+			const list = byEnd.get(id);
+			if (list) list.push(index);
+			else byEnd.set(id, [index]);
+		}
+	});
 	const canonicalEndpoints = new Map(canonicalEdges.map((edge, index) => [edge.id, canonicalGraph.edges[index]]));
 	const canonicalFixedOrder = new Set(input.graph.nodes.filter((node) => {
 		const constraint = input.nodeSettings?.(node)?.portConstraints;
@@ -5121,6 +5215,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	*/
 	const constrained = new Set([...units?.units.keys() ?? [], ...[...units?.successors ?? []].flatMap(([id, after]) => [id, ...after])]);
 	const groupMixedPortDirections = (free, fixed, beyond = []) => {
+		if (!mixedPorts) return;
 		const fixedIds = new Set(fixed);
 		const groups = /* @__PURE__ */ new Map();
 		for (const id of free) {
@@ -5143,6 +5238,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 			groups.set(key, group);
 		}
 		if (![...groups.values()].some((g) => g.some((m) => m.reversed) && g.some((m) => !m.reversed))) return;
+		if (probe) probe.mixedPorts = true;
 		const index = new Map(free.map((id, i) => [id, i]));
 		const far = new Map(beyond.map((id, i) => [id, i]));
 		const reach = (members) => {
@@ -5311,6 +5407,10 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		restore,
 		finish,
 		currentLayers: () => working,
+		crossingGraph: () => ({
+			layers: working.map((layer) => layer.map((id) => canonicalNodes.get(id))),
+			edges: canonicalGraph.edges
+		}),
 		physicalPortOrder: (id) => canonicalNodes.get(id)?.ports.map((port) => port.id) ?? [],
 		edgeOrders: (id) => ({
 			incoming: inputPortOrder.get(id) ?? [],
@@ -6014,6 +6114,16 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 	}
 	const result = /* @__PURE__ */ new Map();
 	const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
+	const orderIndexes = /* @__PURE__ */ new Map();
+	const orderIndex = (list, id) => {
+		let positions = orderIndexes.get(list);
+		if (!positions) {
+			positions = /* @__PURE__ */ new Map();
+			for (const [index, item] of list.entries()) if (!positions.has(item)) positions.set(item, index);
+			orderIndexes.set(list, positions);
+		}
+		return positions.get(id) ?? -1;
+	};
 	const placedPorts = /* @__PURE__ */ new Map();
 	const portSideCounts = /* @__PURE__ */ new Map();
 	const portSideCount = (node, side) => {
@@ -6055,7 +6165,7 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 			const leftIncoming = left.endpoint === "target" !== (orientation?.reversedEdgeIds.has(left.edge.id) ?? false);
 			if (leftIncoming === (right.endpoint === "target" !== (orientation?.reversedEdgeIds.has(right.edge.id) ?? false))) {
 				const selected = (leftIncoming ? sweptOrder?.inputPortOrderByNodeId : sweptOrder?.outputPortOrderByNodeId)?.get(nodeId);
-				const a = selected?.indexOf(left.edge.id) ?? -1, b = selected?.indexOf(right.edge.id) ?? -1;
+				const a = selected ? orderIndex(selected, left.edge.id) : -1, b = selected ? orderIndex(selected, right.edge.id) : -1;
 				if (a >= 0 && b >= 0 && a !== b) return (leftIncoming ? -1 : 1) * (a - b);
 			}
 			if (interactiveLeftSourceOrder) {
@@ -6753,8 +6863,9 @@ function routeEdges(style) {
 					candidate.slot = increasing ? segment.slot : maximumSlot - segment.slot;
 					if (segment.partner !== void 0) {
 						const partner = result.segments[segment.partner];
-						candidate.secondSlot = increasing ? partner.slot : maximumSlot - segment.slot;
-						if (!increasing) candidate.slot = maximumSlot - partner.slot;
+						const [first, second] = physicalPort(candidate, "source").graphSource ? [segment, partner] : [partner, segment];
+						candidate.slot = increasing ? first.slot : maximumSlot - first.slot;
+						candidate.secondSlot = increasing ? second.slot : maximumSlot - second.slot;
 						const sourcePort = portByCandidate.get(candidate).source;
 						const offset = (increasing ? candidate.sourceCross : candidate.targetCross) - byPort.get(sourcePort).position + (runShift.get(sourcePort) ?? 0);
 						candidate.crossover = segment.outgoing[0] + offset;
@@ -9654,6 +9765,10 @@ function crossing(s, t) {
 	const v = h === s ? t : s;
 	return v.a.x > Math.min(h.a.x, h.b.x) + EPS && v.a.x < Math.max(h.a.x, h.b.x) - EPS && h.a.y > Math.min(v.a.y, v.b.y) + EPS && h.a.y < Math.max(v.a.y, v.b.y) - EPS;
 }
+const onBorder = (p, r) => {
+	const inX = p.x >= r.x - EPS && p.x <= r.x + r.width + EPS;
+	return p.y >= r.y - EPS && p.y <= r.y + r.height + EPS && (Math.abs(p.x - r.x) <= EPS || Math.abs(p.x - r.x - r.width) <= EPS) || inX && (Math.abs(p.y - r.y) <= EPS || Math.abs(p.y - r.y - r.height) <= EPS);
+};
 const segmentsOf = (points) => points.slice(1).flatMap((b, i) => {
 	const s = {
 		a: points[i],
@@ -9686,7 +9801,34 @@ function separateOpposingTracks(scene) {
 		if (!rects) terminalCache.set(key, rects = terminals(a.route, b.route));
 		return rects;
 	};
+	const boxes = /* @__PURE__ */ new WeakMap();
+	const boxOf = (segments) => {
+		let box = boxes.get(segments);
+		if (!box) {
+			box = [
+				Infinity,
+				Infinity,
+				-Infinity,
+				-Infinity
+			];
+			for (const { a, b } of segments) {
+				box[0] = Math.min(box[0], a.x, b.x);
+				box[1] = Math.min(box[1], a.y, b.y);
+				box[2] = Math.max(box[2], a.x, b.x);
+				box[3] = Math.max(box[3], a.y, b.y);
+			}
+			boxes.set(segments, box);
+		}
+		return box;
+	};
+	const none = {
+		opposing: 0,
+		overlap: 0,
+		crossings: 0
+	};
 	const pair = (mine, self, other) => {
+		const [ax0, ay0, ax1, ay1] = boxOf(mine), [bx0, by0, bx1, by1] = boxOf(other.measured);
+		if (ax1 < bx0 - EPS || bx1 < ax0 - EPS || ay1 < by0 - EPS || by1 < ay0 - EPS) return none;
 		const rects = terminalsOf(self, other);
 		const as = rects.length ? clip(mine, rects, true) : mine, bs = rects.length ? clip(other.measured, rects, true) : other.measured;
 		let opposing = 0, overlap = 0, crossings$1 = 0;
@@ -9899,8 +10041,8 @@ function separateOpposingTracks(scene) {
 					y: p.y
 				};
 				if (k >= 1 && k <= raw.length - 2) {
-					const before = raw[k - 1], after = raw[k + 1];
-					if (h ? !vertical(before) || !vertical(after) : !horizontal(before) || !horizontal(after)) continue;
+					const before = raw[k - 1], after$1 = raw[k + 1];
+					if (h ? !vertical(before) || !vertical(after$1) : !horizontal(before) || !horizontal(after$1)) continue;
 					for (const delta of offsets) {
 						const points = state.points.map((p, i) => i === k || i === k + 1 ? shift(p, delta) : p);
 						const next = [
@@ -9911,11 +10053,11 @@ function separateOpposingTracks(scene) {
 							a: points[i],
 							b: points[i + 1]
 						}));
-						if (!keeps(before, next[0]) || !keeps(after, next[2])) continue;
+						if (!keeps(before, next[0]) || !keeps(after$1, next[2])) continue;
 						consider(points, [
 							before,
 							segment,
-							after
+							after$1
 						], next, next[1], 0, delta);
 					}
 					continue;
@@ -9938,6 +10080,32 @@ function separateOpposingTracks(scene) {
 					a: port,
 					b: corner
 				}], [inflate(rect, TERMINAL_MARGIN)], true).reduce((sum, part) => sum + size(part), 0) : along;
+				const after = {
+					a: corner,
+					b: beyond
+				};
+				const against = (s) => states.reduce((sum, other) => other === state ? sum : other.measured.reduce((n, t) => n + (opposite(s, t) ? shared(s, t) : 0), sum), 0);
+				if (state.route.ends.length === 2 && state.route.ports?.[reversed ? 1 : 0] === void 0 && rect && onBorder(port, rect) && (h ? vertical(after) : horizontal(after))) {
+					const lo = h ? rect.y : rect.x, hi = lo + (h ? rect.height : rect.width);
+					for (const delta of offsets) {
+						const moved = shift(port, delta);
+						if ((h ? moved.y : moved.x) < lo - EPS || (h ? moved.y : moved.x) > hi + EPS) continue;
+						const next = [{
+							a: moved,
+							b: shift(corner, delta)
+						}, {
+							a: shift(corner, delta),
+							b: beyond
+						}];
+						if (!keeps(after, next[1]) || against(next[1]) > against(after) + EPS) continue;
+						const replaced = [
+							moved,
+							shift(corner, delta),
+							...path.slice(2)
+						];
+						consider(reversed ? replaced.reverse() : replaced, [segment, after], next, next[0], 0, delta);
+					}
+				}
 				for (const stub of new Set([along - clearance, spacing])) for (const delta of offsets) {
 					if (stub < 1 || along - stub < spacing) continue;
 					const q = {
@@ -9995,14 +10163,34 @@ function separateOpposingTracks(scene) {
 	* half a spacing either side of the port's centre.
 	*/
 	function splitSharedPorts(tolerant) {
-		const ports = scene.ports;
-		if (!ports?.size) return;
 		const groups = /* @__PURE__ */ new Map();
+		const implicit = /* @__PURE__ */ new Map();
 		for (const state of states) for (const end of [0, 1]) {
-			const id = state.route.ports?.[end];
-			const port = id === void 0 ? void 0 : ports.get(id);
-			if (!port || state.points.length < 2) continue;
+			if (state.points.length < 2) continue;
 			const [p, q] = end ? [...state.points].reverse() : state.points;
+			let id = state.route.ports?.[end];
+			let port = id === void 0 ? void 0 : scene.ports?.get(id);
+			const node = state.route.ends.length === 2 ? state.route.ends[end] : void 0;
+			const rect = node === void 0 ? void 0 : nodes.get(node);
+			if (id === void 0 && rect && onBorder(p, rect)) {
+				const points = implicit.get(node) ?? [];
+				implicit.set(node, points);
+				let at = points.find((o) => Math.abs(o.x - p.x) <= EPS && Math.abs(o.y - p.y) <= EPS);
+				if (!at) points.push(at = {
+					x: p.x,
+					y: p.y
+				});
+				id = `${node}\0${points.indexOf(at)}`;
+				port = {
+					node,
+					rect: {
+						...at,
+						width: 0,
+						height: 0
+					}
+				};
+			}
+			if (!port) continue;
 			const s = {
 				a: p,
 				b: q
@@ -10024,7 +10212,13 @@ function separateOpposingTracks(scene) {
 				end
 			});
 		}
-		for (const { port, normal, ends } of groups.values()) {
+		for (const group of groups.values()) {
+			const { port, normal } = group;
+			const ends = group.ends.filter(({ state, end }) => {
+				if (state.route.ports?.[end] !== void 0) return true;
+				const p = end ? state.points.at(-1) : state.points[0];
+				return Math.abs(p.x - port.rect.x) <= EPS && Math.abs(p.y - port.rect.y) <= EPS;
+			});
 			const incoming = ends.filter((e) => e.end === 1), outgoing = ends.filter((e) => e.end === 0);
 			if (!incoming.length || !outgoing.length) continue;
 			const stub = ({ state, end }) => {
@@ -10043,9 +10237,25 @@ function separateOpposingTracks(scene) {
 			const sideLo = node[lateral], sideHi = node[lateral] + (lateral === "x" ? node.width : node.height);
 			const wide = extent$2 >= spacing - EPS;
 			const half = spacing / 2;
-			const shifted = (points, end, offset) => {
+			const slid = (state, points, end, offset) => {
+				if (state.route.ports?.some((id) => id !== void 0)) return void 0;
+				if (Math.abs(points[0][across] - points[1][across]) <= EPS) return void 0;
+				const far = nodes.get(state.route.ends[1 - end] ?? "");
+				const moved = points.map((p) => ({
+					...p,
+					[lateral]: p[lateral] + offset
+				}));
+				const within = (value$1, rect) => {
+					const lo = rect[lateral];
+					return value$1 >= lo - EPS && value$1 <= lo + (lateral === "x" ? rect.width : rect.height) + EPS;
+				};
+				const value = moved[0][lateral];
+				return within(value, node) && far && within(value, far) ? moved : void 0;
+			};
+			const shifted = (state, points, end, offset) => {
 				if (Math.abs(offset) <= EPS) return points;
 				const path = end ? [...points].reverse() : [...points];
+				if (path.length === 2) return slid(state, points, end, offset);
 				if (path.length < 3) return void 0;
 				const [p, q, r] = path;
 				const along = r[lateral] - q[lateral];
@@ -10109,7 +10319,7 @@ function separateOpposingTracks(scene) {
 				const next = /* @__PURE__ */ new Map();
 				let feasible = true;
 				for (const e of ends) {
-					const points = shifted(next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
+					const points = shifted(e.state, next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
 					if (!points) {
 						feasible = false;
 						break;
@@ -18811,10 +19021,6 @@ function* createLayeredScopePipeline(graph, options, context) {
 			switchedSideByPort.set(`${origin.node.id}\0${origin.port.name}`, opposite$2);
 		}
 	}
-	if (expanded.input.settings.mergeEdges === true) order = {
-		...order,
-		layers: order.layers.map((layer) => [...layer.filter((id) => id.startsWith("__layout_dummy:")), ...layer.filter((id) => !id.startsWith("__layout_dummy:"))])
-	};
 	const unzippingFanIn = graph.edges.length === graph.nodes.length - 1 && graph.nodes.some((node) => graph.edges.filter((edge) => edge.targetId === node.id).length === graph.nodes.length - 1);
 	if ((options.settings?.["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING") if (unzippingFanIn) order = applyLayerUnzipping(expanded.input, order);
 	else {
@@ -19717,4 +19923,4 @@ const elkjs0111LayeredAlgorithm = {
 };
 
 //#endregion
-export { createExternalPortDummy as $, breakCyclesByStronglyConnectedNodeType as A, minimizeCrossingsWithBarycenter as B, assignLayersByDepthFirstModelOrder as C, assignLayersWithCoffmanGraham as D, assignLayersInteractively as E, breakCyclesWithModelOrderBreadthFirstSearch as F, placePorts as G, minimizeCrossingsWithModelOrder as H, breakCyclesWithModelOrderDepthFirstSearch as I, routeEdgesWithSplines as J, routeEdgesOrthogonally as K, createLayerSweepSession as L, breakCyclesGreedilyByModelOrder as M, breakCyclesInteractively as N, breakCyclesByModelOrder as O, breakCyclesWithDepthFirstSearch as P, attachExternalPortDummy as Q, getPolylineMidpoint as R, assignLayersByBreadthFirstModelOrder as S, assignLayersByLongestPathToSink as T, placeNodesInLayers as U, minimizeCrossingsWithMedian as V, placeNodesInteractively as W, minimizeHierarchyCrossings as X, JavaRandom as Y, assignLayersWithNetworkSimplex as Z, statechartHints as _, fromElkLayeredOptionId as a, elkjs0111ResultPolicy as b, elkLayeredOptionDefinitions as c, placeNodesWithBrandesKoepf as d, externalPortDummyOf as et, assignLayersWithStretchWidth as f, hint as g, separateOpposingTracks as h, layeredAlgorithm as i, breakCyclesGreedily as j, breakCyclesByStronglyConnectedConnectivity as k, placeNodesWithNetworkSimplex as l, c as m, elkjs0111LayeredAlgorithm as n, createOrthogonalHypersegments as nt, toElkLayeredOptions as o, assignLayersWithMinWidth as p, routeEdgesWithPolylines as q, getLayeredLayout as r, elkLayeredEnumValues as s, createLayeredScopePipeline as t, getCrossingUnits as tt, placeNodesWithLinearSegments as u, isPerpendicularPortRestored as v, assignLayersByLongestPath as w, setElkjs0111ResultPolicy as x, hierarchicalPortSides as y, minimizeCrossingsInteractively as z };
+export { attachExternalPortDummy as $, breakCyclesByStronglyConnectedConnectivity as A, minimizeCrossingsInteractively as B, assignLayersByBreadthFirstModelOrder as C, assignLayersInteractively as D, assignLayersByLongestPathToSink as E, breakCyclesWithDepthFirstSearch as F, placeNodesInteractively as G, minimizeCrossingsWithMedian as H, breakCyclesWithModelOrderBreadthFirstSearch as I, routeEdgesWithPolylines as J, placePorts as K, breakCyclesWithModelOrderDepthFirstSearch as L, breakCyclesGreedily as M, breakCyclesGreedilyByModelOrder as N, assignLayersWithCoffmanGraham as O, breakCyclesInteractively as P, assignLayersWithNetworkSimplex as Q, createLayerSweepSession as R, CROSSING_MODEL as S, assignLayersByLongestPath as T, minimizeCrossingsWithModelOrder as U, minimizeCrossingsWithBarycenter as V, placeNodesInLayers as W, JavaRandom as X, routeEdgesWithSplines as Y, minimizeHierarchyCrossings as Z, statechartHints as _, fromElkLayeredOptionId as a, elkjs0111ResultPolicy as b, elkLayeredOptionDefinitions as c, placeNodesWithBrandesKoepf as d, createExternalPortDummy as et, assignLayersWithStretchWidth as f, hint as g, separateOpposingTracks as h, layeredAlgorithm as i, breakCyclesByStronglyConnectedNodeType as j, breakCyclesByModelOrder as k, placeNodesWithNetworkSimplex as l, c as m, elkjs0111LayeredAlgorithm as n, createOrthogonalHypersegments as nt, toElkLayeredOptions as o, assignLayersWithMinWidth as p, routeEdgesOrthogonally as q, getLayeredLayout as r, elkLayeredEnumValues as s, createLayeredScopePipeline as t, externalPortDummyOf as tt, placeNodesWithLinearSegments as u, isPerpendicularPortRestored as v, assignLayersByDepthFirstModelOrder as w, setElkjs0111ResultPolicy as x, hierarchicalPortSides as y, getPolylineMidpoint as z };

package/dist/{layout-engine-DAw06RhN.cjs → layout-engine-CLFySz3R.cjs}

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

package/dist/{layout-engine-DC3IYkIy.mjs → layout-engine-GpBIX6ng.mjs}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {