@statelyai/layout 0.4.0 → 0.4.1

package/dist/{layered-CBPg6_6_.cjs → layered-5RxQhryb.cjs}

@@ -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,6 +19923,12 @@ const elkjs0111LayeredAlgorithm = {
 };
 
 //#endregion
+Object.defineProperty(exports, 'CROSSING_MODEL', {
+  enumerable: true,
+  get: function () {
+    return CROSSING_MODEL;
+  }
+});
 Object.defineProperty(exports, 'JavaRandom', {
   enumerable: true,
   get: function () {
@@ -19903,12 +20115,6 @@ Object.defineProperty(exports, 'fromElkLayeredOptionId', {
     return fromElkLayeredOptionId;
   }
 });
-Object.defineProperty(exports, 'getCrossingUnits', {
-  enumerable: true,
-  get: function () {
-    return getCrossingUnits;
-  }
-});
 Object.defineProperty(exports, 'getLayeredLayout', {
   enumerable: true,
   get: function () {