@statelyai/layout 0.4.0 → 0.4.2

package/dist/elkjs/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-require('../layered-CBPg6_6_.cjs');
-const require_elkjs = require('../elkjs-ggjsBuVP.cjs');
+require('../layered-BJu8A21s.cjs');
+const require_elkjs = require('../elkjs-CnBvdyBu.cjs');
 
 exports.compileStatechartLayout = require_elkjs.compileStatechartLayout;
 exports.default = require_elkjs.ELK;

package/dist/elkjs/index.mjs

@@ -1,4 +1,4 @@
-import "../layered-C7ERzZjR.mjs";
-import { a as scoreStatechartLayout, i as layoutStatechart, n as getElkRoutes, r as compileStatechartLayout, t as ELK } from "../elkjs-UciYx7lD.mjs";
+import "../layered-BsAdm_u8.mjs";
+import { a as scoreStatechartLayout, i as layoutStatechart, n as getElkRoutes, r as compileStatechartLayout, t as ELK } from "../elkjs-CSi7oB5J.mjs";
 
 export { compileStatechartLayout, ELK as default, getElkRoutes, layoutStatechart, scoreStatechartLayout };

package/dist/elkjs/main.cjs

@@ -1,4 +1,4 @@
-require('../layered-CBPg6_6_.cjs');
+require('../layered-BJu8A21s.cjs');
 const require_elkjs_worker = require('./worker.cjs');
 const require_worker_client = require('../worker-client-D4oEvhAl.cjs');
 

package/dist/elkjs/main.mjs

@@ -1,4 +1,4 @@
-import "../layered-C7ERzZjR.mjs";
+import "../layered-BsAdm_u8.mjs";
 import { Worker } from "./worker.mjs";
 import { t as WorkerELK } from "../worker-client-BNjwT1AJ.mjs";
 

package/dist/elkjs/worker.cjs

@@ -1,5 +1,5 @@
-require('../layered-CBPg6_6_.cjs');
-const require_elkjs = require('../elkjs-ggjsBuVP.cjs');
+require('../layered-BJu8A21s.cjs');
+const require_elkjs = require('../elkjs-CnBvdyBu.cjs');
 
 //#region src/elkjs/worker.ts
 /*******************************************************************************

package/dist/elkjs/worker.mjs

@@ -1,5 +1,5 @@
-import "../layered-C7ERzZjR.mjs";
-import { t as ELK } from "../elkjs-UciYx7lD.mjs";
+import "../layered-BsAdm_u8.mjs";
+import { t as ELK } from "../elkjs-CSi7oB5J.mjs";
 
 //#region src/elkjs/worker.ts
 /*******************************************************************************

package/dist/{elkjs-UciYx7lD.mjs → elkjs-CSi7oB5J.mjs}

@@ -1,30 +1,38 @@
 import { T as pathFromPoints, g as pathFromSplinePoints, j as freeze } from "./routing-CR8flv8b.mjs";
-import { $ as createExternalPortDummy, L as createLayerSweepSession, Q as attachExternalPortDummy, X as minimizeHierarchyCrossings, b as elkjs0111ResultPolicy, c as elkLayeredOptionDefinitions, et as externalPortDummyOf, h as separateOpposingTracks, nt as createOrthogonalHypersegments, t as createLayeredScopePipeline, tt as getCrossingUnits, v as isPerpendicularPortRestored, y as hierarchicalPortSides } from "./layered-C7ERzZjR.mjs";
-import { n as executeElkjs0111Layout } from "./layout-engine-DC3IYkIy.mjs";
+import { $ as attachExternalPortDummy, R as createLayerSweepSession, S as CROSSING_MODEL, Z as minimizeHierarchyCrossings, b as elkjs0111ResultPolicy, c as elkLayeredOptionDefinitions, et as createExternalPortDummy, h as separateOpposingTracks, nt as createOrthogonalHypersegments, t as createLayeredScopePipeline, tt as externalPortDummyOf, v as isPerpendicularPortRestored, y as hierarchicalPortSides } from "./layered-BsAdm_u8.mjs";
+import { n as executeElkjs0111Layout } from "./layout-engine-DnlmGxHL.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/layered/hierarchy-sweepiness.ts
-function useBottomUpHierarchySweep(input, orientation, layers, parent) {
+/**
+* Whether a child graph is swept on its own before its parent. Like ELK, a
+* node starts a random path when no western port carries an edge and ends one
+* when no eastern port does, on the canonical crossing graph's port sides.
+*/
+function useBottomUpHierarchySweep(input, graph, parent) {
 	const boundary = input.settings["crossingMinimization.hierarchicalSweepiness"] ?? .1;
 	if (boundary < -1 || parent.portOrderFixed || parent.inputPorts < 2 && parent.outputPorts < 2) return true;
 	if (parent.deterministic) return false;
 	const nodes = new Map(input.graph.nodes.map((node) => [node.id, node]));
-	const infos = new Map(input.graph.nodes.map((node) => [node.id, {
+	const owner = /* @__PURE__ */ new Map();
+	for (const node of graph.layers.flat()) for (const port of node.ports) owner.set(port.id, node.id);
+	const degree = /* @__PURE__ */ new Map(), targets = /* @__PURE__ */ new Map();
+	for (const { source, target } of graph.edges) {
+		degree.set(source, (degree.get(source) ?? 0) + 1);
+		degree.set(target, (degree.get(target) ?? 0) + 1);
+		const from = owner.get(source);
+		targets.set(from, [...targets.get(from) ?? [], owner.get(target)]);
+	}
+	const infos = new Map(graph.layers.flat().map((node) => [node.id, {
 		random: 0,
 		hierarchy: 0,
 		edges: 0
 	}]));
-	const outgoing = /* @__PURE__ */ new Map(), incoming = /* @__PURE__ */ new Map();
-	for (const edge of input.graph.edges) {
-		const reversed = orientation.reversedEdgeIds.has(edge.id);
-		const source = reversed ? edge.targetId : edge.sourceId, target = reversed ? edge.sourceId : edge.targetId;
-		outgoing.set(source, [...outgoing.get(source) ?? [], target]);
-		incoming.set(target, [...incoming.get(target) ?? [], source]);
-	}
-	const units = getCrossingUnits(input);
 	let randomPaths = 0, hierarchyPaths = 0;
 	const transfer = (source, target) => {
 		const a = infos.get(source), b = infos.get(target);
+		randomPaths += a.random;
+		hierarchyPaths += a.hierarchy;
 		b.random += a.random;
 		b.hierarchy += a.hierarchy;
 		b.edges += a.edges + 1;
@@ -35,36 +43,25 @@ function useBottomUpHierarchySweep(input, orientation, layers, parent) {
 		down: "SOUTH",
 		up: "NORTH"
 	}[input.direction];
-	const passEdges = (id) => {
-		const state = infos.get(id);
-		for (const target of outgoing.get(id) ?? []) {
-			randomPaths += state.random;
-			hierarchyPaths += state.hierarchy;
-			transfer(id, target);
-		}
-	};
-	for (const layer of layers) {
+	for (const layer of graph.layers) {
 		const northSouth = [];
-		for (const id of layer) {
-			if (id.startsWith("__layout_dummy:north-south:")) {
-				northSouth.push(id);
+		for (const node of layer) {
+			if (node.type === "NORTH_SOUTH_PORT") {
+				northSouth.push(node.id);
 				continue;
 			}
-			const node = nodes.get(id), state = infos.get(id);
-			const external = externalPortDummyOf(node);
+			const state = infos.get(node.id);
+			const connected = (side) => node.ports.some((port) => port.side === side && degree.has(port.id));
+			const external = externalPortDummyOf(nodes.get(node.id));
 			if (external) {
 				state.hierarchy = 1;
 				if (external.side === outputSide) hierarchyPaths += state.edges;
-			} else if (!incoming.get(id)?.length) state.random = 1;
-			else if (!outgoing.get(id)?.length) randomPaths += state.edges;
-			passEdges(id);
-			for (const dummy of units?.associates.get(id) ?? []) {
-				randomPaths += state.random;
-				hierarchyPaths += state.hierarchy;
-				transfer(id, dummy);
-			}
+			} else if (!connected("WEST")) state.random = 1;
+			else if (!connected("EAST")) randomPaths += state.edges;
+			for (const target of targets.get(node.id) ?? []) transfer(node.id, target);
+			for (const port of node.ports) if ((port.side === "NORTH" || port.side === "SOUTH") && port.dummy) transfer(node.id, port.dummy);
 		}
-		for (const id of northSouth) passEdges(id);
+		for (const id of northSouth) for (const target of targets.get(id) ?? []) transfer(id, target);
 	}
 	const all = randomPaths + hierarchyPaths;
 	return (all === 0 ? Number.POSITIVE_INFINITY : (randomPaths - hierarchyPaths) / all) >= boundary;
@@ -166,9 +163,13 @@ const vertical = (s) => Math.abs(s.a.x - s.b.x) < EPS;
 const span = (s, axis) => [Math.min(s.a[axis], s.b[axis]), Math.max(s.a[axis], s.b[axis])];
 const strictlyInside = (value, low, high) => value > low + EPS && value < high - EPS;
 const overlapLength = (a, b) => Math.max(0, Math.min(a[1], b[1]) - Math.max(a[0], b[0]));
-const inRect = (point, rect, margin) => point.x > rect.x - margin && point.x < rect.x + rect.width + margin && point.y > rect.y - margin && point.y < rect.y + rect.height + margin;
-/** Measure an ELK JSON result in absolute coordinates. */
-function measureLayout(root) {
+/** Within `margin` of the rectangle, its border included. */
+const inRect = (point, rect, margin) => point.x >= rect.x - margin - EPS && point.x <= rect.x + rect.width + margin + EPS && point.y >= rect.y - margin - EPS && point.y <= rect.y + rect.height + margin + EPS;
+/**
+* Measure an ELK JSON result in absolute coordinates. `defectsOnly` skips the
+* pairwise route measures (crossings and overlap stay 0).
+*/
+function measureLayout(root, defectsOnly = false) {
 	const frames = new Map([[String(root.id), {
 		x: 0,
 		y: 0
@@ -263,6 +264,7 @@ function measureLayout(root) {
 			routes.push({
 				ends,
 				segments,
+				visible: labels.length && !defectsOnly ? segments.flatMap((s) => outsideAll(s, labels)) : segments,
 				labels
 			});
 		}
@@ -279,26 +281,31 @@ function measureLayout(root) {
 		for (const label of other.labels) if (route.segments.some((segment) => horizontal(segment) && strictlyInside(segment.a.y, label.y, label.y + label.height) && overlapLength(span(segment, "x"), [label.x, label.x + label.width]) > EPS || vertical(segment) && strictlyInside(segment.a.x, label.x, label.x + label.width) && overlapLength(span(segment, "y"), [label.y, label.y + label.height]) > EPS)) defects++;
 	}
 	let crossings = 0, overlap = 0;
-	for (const [index, first] of routes.entries()) for (const second of routes.slice(index + 1)) {
+	if (!defectsOnly) for (const [index, first] of routes.entries()) for (const second of routes.slice(index + 1)) {
 		const shared = first.ends.filter((id) => second.ends.includes(id)).flatMap((id) => {
 			const rect = rects.get(id);
 			return rect ? [rect] : [];
 		});
 		const clear = (point) => shared.every((rect) => !inRect(point, rect, TERMINAL_MARGIN));
-		for (const s of first.segments) for (const t of second.segments) {
+		let points;
+		const cross$1 = (s, t) => {
 			const h = horizontal(s) && vertical(t) ? s : horizontal(t) && vertical(s) ? t : void 0;
-			if (h) {
-				const v = h === s ? t : s;
-				const point = {
-					x: v.a.x,
-					y: h.a.y
-				};
-				if (strictlyInside(point.x, ...span(h, "x")) && strictlyInside(point.y, ...span(v, "y")) && clear(point)) crossings++;
-				continue;
-			}
+			if (!h) return;
+			const v = h === s ? t : s;
+			const point = {
+				x: v.a.x,
+				y: h.a.y
+			};
+			if (strictlyInside(point.x, ...span(h, "x")) && strictlyInside(point.y, ...span(v, "y")) && clear(point)) (points ??= /* @__PURE__ */ new Set()).add(`${Math.round(point.x / EPS)}:${Math.round(point.y / EPS)}`);
+		};
+		const unlabeled = first.visible === first.segments && second.visible === second.segments;
+		for (const s of first.segments) for (const t of second.segments) {
+			if (unlabeled) cross$1(s, t);
 			const shared$1 = sharedLength(s, t);
 			if (shared$1 > EPS && clear(s.a) && clear(s.b)) overlap += shared$1;
 		}
+		if (!unlabeled) for (const s of first.visible) for (const t of second.visible) cross$1(s, t);
+		crossings += points?.size ?? 0;
 	}
 	const xs = bounds.map((point) => point.x).filter(Number.isFinite), ys = bounds.map((point) => point.y).filter(Number.isFinite);
 	const area = xs.length ? (Math.max(...xs) - Math.min(...xs)) * (Math.max(...ys) - Math.min(...ys)) : 0;
@@ -311,6 +318,29 @@ function measureLayout(root) {
 		area
 	};
 }
+/** The parts of an axis-parallel segment outside the open interiors of `rects`. */
+function outsideAll(segment, rects) {
+	let parts = [segment];
+	for (const rect of rects) parts = parts.flatMap((part) => {
+		const axis = horizontal(part) ? "x" : vertical(part) ? "y" : void 0;
+		if (!axis) return [part];
+		const cross$1 = axis === "x" ? "y" : "x";
+		const [low, high] = axis === "x" ? [rect.x, rect.x + rect.width] : [rect.y, rect.y + rect.height];
+		const [crossLow, crossHigh] = cross$1 === "x" ? [rect.x, rect.x + rect.width] : [rect.y, rect.y + rect.height];
+		if (!strictlyInside(part.a[cross$1], crossLow, crossHigh)) return [part];
+		const [from, to] = span(part, axis);
+		if (overlapLength([from, to], [low, high]) <= EPS) return [part];
+		const at = (value) => ({
+			...part.a,
+			[axis]: value
+		});
+		return [[from, Math.max(from, low)], [Math.min(to, high), to]].filter(([a, b]) => b - a > EPS).map(([a, b]) => ({
+			a: at(a),
+			b: at(b)
+		}));
+	});
+	return parts;
+}
 function sharedLength(s, t) {
 	if (horizontal(s) && horizontal(t) && Math.abs(s.a.y - t.a.y) < EPS) return overlapLength(span(s, "x"), span(t, "x"));
 	if (vertical(s) && vertical(t) && Math.abs(s.a.x - t.a.x) < EPS) return overlapLength(span(s, "y"), span(t, "y"));
@@ -1017,6 +1047,8 @@ function getElkRoutes(graph, options = {}) {
 function isLayoutEdgeLabel(label) {
 	return getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true && (Boolean(label.text) || label.width !== void 0 || label.height !== void 0);
 }
+/** The crossing-model setting a layout passes to crossing minimization. */
+const crossingModel = Symbol("crossingModel");
 var ELK = class {
 	#options;
 	#algorithmIds;
@@ -1091,20 +1123,42 @@ var ELK = class {
 			...this.#options.defaultLayoutOptions,
 			...arguments_.layoutOptions
 		};
-		const variants = crossingVariants(options, graph);
-		const pristine = variants.length ? structuredClone(graph) : void 0;
-		let best = separated(await this.#layoutWithoutDefectiveCompaction(graph, arguments_), options);
+		const seeds = crossingVariants(options, graph);
+		const probe = mayShareTracks(graph, options) ? {
+			mixedPorts: false,
+			sharedTracks: false
+		} : void 0;
+		const pristine = seeds.length || probe ? structuredClone(graph) : void 0;
+		let best = separated(await this.#layoutWithoutDefectiveCompaction(graph, probe ? {
+			...arguments_,
+			[crossingModel]: { probe }
+		} : arguments_), options);
 		if (!pristine) return best;
-		let quality = measureLayout(best);
-		if (quality.defects === 0 && !thorough(options, graph)) return best;
-		for (const variant of variants) {
-			const candidate = separated(await this.#layoutWithoutDefectiveCompaction(structuredClone(pristine), {
+		const reseed = seeds.length > 0 && (thorough(options, graph) || measureLayout(best, true).defects > 0);
+		const variants = [
+			...probe?.mixedPorts ? [{
+				...arguments_,
+				[crossingModel]: { mixedPorts: false }
+			}] : [],
+			...probe?.sharedTracks ? [{
+				...arguments_,
+				[crossingModel]: {
+					mixedPorts: false,
+					separateSharedTracks: true
+				}
+			}] : [],
+			...(reseed ? seeds : []).map((variant) => ({
 				...arguments_,
 				layoutOptions: {
 					...arguments_.layoutOptions,
 					...variant
 				}
-			}), options);
+			}))
+		];
+		if (!variants.length) return best;
+		let quality = measureLayout(best);
+		for (const variant of variants) {
+			const candidate = separated(await this.#layoutWithoutDefectiveCompaction(structuredClone(pristine), variant), options);
 			const candidateQuality = measureLayout(candidate);
 			if (isBetterLayout(candidateQuality, quality)) {
 				best = candidate;
@@ -1119,7 +1173,7 @@ var ELK = class {
 			...arguments_.layoutOptions
 		}, graph) ? structuredClone(graph) : void 0;
 		const result = await this.#layout(graph, arguments_);
-		const defects = pristine ? measureLayout(result).defects : 0;
+		const defects = pristine ? measureLayout(result, true).defects : 0;
 		if (!pristine || defects === 0) return result;
 		const strategy = { "elk.layered.compaction.postCompaction.strategy": "NONE" };
 		const uncompacted = await this.#layout(disablePostCompaction(pristine), {
@@ -1129,7 +1183,7 @@ var ELK = class {
 				...strategy
 			}
 		});
-		return measureLayout(uncompacted).defects < defects ? uncompacted : result;
+		return measureLayout(uncompacted, true).defects < defects ? uncompacted : result;
 	}
 	async #layout(graph, arguments_ = {}, compoundLayout = false) {
 		const prepared = await this.#prepareLayout(graph, arguments_, compoundLayout);
@@ -1382,8 +1436,10 @@ var ELK = class {
 						const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
 						const sourceInside = descendantOwnerByEndpointId.has(sourceId);
 						const proxy = proxyFor(sourceInside ? "output" : "input", edge);
+						const labels = (graph.edges ?? []).includes(edge) && !ownPortFor(edge) ? edge.labels?.filter((label) => (getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") !== "CENTER") : edge.labels;
 						const segment = {
 							...edge,
+							labels,
 							id: `__native_hierarchy_edge_${String(child.id)}_${String(edge.id)}`,
 							sources: [sourceInside ? sourceId : proxy.ports[0].id],
 							targets: [sourceInside ? proxy.ports[0].id : targetId],
@@ -1749,6 +1805,13 @@ var ELK = class {
 			return (sourceConstraint === "FIRST" || sourceConstraint === "FIRST_SEPARATE") && (targetConstraint === "FIRST" || targetConstraint === "FIRST_SEPARATE");
 		})) throw new Error("org.eclipse.elk.core.UnsupportedConfigurationException: Layer constraints conflict");
 		const padding = parsePadding(getOption(layoutOptions, "padding"), algorithm === "layered" ? 12 : 0);
+		const parsedSettings = /* @__PURE__ */ new WeakMap();
+		const elementSettings = (elementOptions) => {
+			const key = elementOptions ?? noElementOptions;
+			let settings = parsedSettings.get(key);
+			if (!settings) parsedSettings.set(key, settings = getElementLayeredSettings(key));
+			return settings;
+		};
 		const options = {
 			direction: getDirection(layoutOptions),
 			spacing: {
@@ -1759,18 +1822,19 @@ var ELK = class {
 			constraints: { layer: () => void 0 },
 			settings: {
 				...getLayeredSettings(layoutOptions),
+				...arguments_[crossingModel] ? { [CROSSING_MODEL]: arguments_[crossingModel] } : {},
 				...compoundLayout || hasHierarchy && !separateHierarchy && !topdownLayout ? { separateConnectedComponents: false } : {},
 				...hierarchyHandling === "INCLUDE_CHILDREN" ? { "crossingMinimization.greedySwitch.type": String(getOption(layoutOptions, "layered.crossingMinimization.greedySwitchHierarchical.type") ?? "TWO_SIDED") } : {}
 			},
 			nodeSettings: (node) => {
 				const child = findById(graph.children, node.id)?.item;
-				return getElementLayeredSettings(child?.layoutOptions ?? {});
+				return elementSettings(child?.layoutOptions);
 			},
 			edgeSettings: (edge) => {
 				const elkEdge = findById(graph.edges, edge.id)?.item;
 				return {
-					...getElementLayeredSettings(elkEdge?.layoutOptions ?? {}),
-					...getElementLayeredSettings(elkEdge?.labels?.[0]?.layoutOptions ?? {}),
+					...elementSettings(elkEdge?.layoutOptions),
+					...elementSettings(elkEdge?.labels?.[0]?.layoutOptions),
 					"edge.hierarchyRank": elkEdge && hierarchySegmentRank.get(elkEdge)
 				};
 			},
@@ -1779,7 +1843,7 @@ var ELK = class {
 				const found = findById(child?.ports, port.name);
 				const elkPort = found?.item;
 				return {
-					...getElementLayeredSettings(elkPort?.layoutOptions ?? {}),
+					...elementSettings(elkPort?.layoutOptions),
 					"port.authoredIndex": found?.position,
 					"port.labelWidth": Math.max(0, ...(elkPort?.labels ?? []).map((label) => label.width ?? 0)),
 					"port.labelHeight": Math.max(0, ...(elkPort?.labels ?? []).map((label) => label.height ?? 0))
@@ -2030,7 +2094,7 @@ function coordinatePreparedScopes(root) {
 			const outputPorts = ports.filter((port) => parent.phase.input.portSettings?.(port, nativeParent)?.["port.side"] === flowSides.after).length;
 			const childScope = {
 				...scopes.get(child),
-				useBottomUp: useBottomUpHierarchySweep(childPhase.input, childPhase.orientation, childSession.snapshot().layers, {
+				useBottomUp: useBottomUpHierarchySweep(childPhase.input, childSession.crossingGraph(), {
 					portOrderFixed: parentPortOrderFixed,
 					inputPorts,
 					outputPorts,
@@ -2245,12 +2309,14 @@ function applyNodeMicroLayout(graph, globalOptions) {
 		node.height = height;
 	}
 }
+const exactKeysBySuffix = /* @__PURE__ */ new Map();
 function getOption(options, suffix) {
-	const exactKeys = [
+	let exactKeys = exactKeysBySuffix.get(suffix);
+	if (!exactKeys) exactKeysBySuffix.set(suffix, exactKeys = [
 		suffix,
 		`elk.${suffix}`,
 		`org.eclipse.elk.${suffix}`
-	];
+	]);
 	for (const key of exactKeys) if (options[key] !== void 0) return options[key];
 }
 const ergonomicallyMappedLayeredSettings = new Set([
@@ -2329,6 +2395,7 @@ function findById(items, id) {
 		position
 	};
 }
+const noElementOptions = {};
 function getElementLayeredSettings(options) {
 	const settings = {};
 	const chosen = /* @__PURE__ */ new Map();
@@ -2909,9 +2976,16 @@ function elkBoundaryEdgeOrder(group, scope, originals) {
 		for (const child of node.children ?? []) if (child.children?.length) {
 			for (const edge of order(child)) if (leaves(edge)) result.add(edge);
 		}
-		for (const child of node.children ?? []) for (const port of [...(child.ports ?? []).map((p) => String(p.id)), String(child.id)]) {
-			for (const edge of edges) if (endpoints(edge).sourceId === port && leaves(edge)) result.add(edge);
-			for (const edge of edges) if (endpoints(edge).targetId === port && leaves(edge)) result.add(edge);
+		for (const child of node.children ?? []) {
+			for (const port of (child.ports ?? []).map((p) => String(p.id))) {
+				for (const edge of edges) if (endpoints(edge).sourceId === port && leaves(edge)) result.add(edge);
+				for (const edge of edges) if (endpoints(edge).targetId === port && leaves(edge)) result.add(edge);
+			}
+			const id = String(child.id);
+			for (const edge of edges) {
+				const { sourceId, targetId } = endpoints(edge);
+				if ((sourceId === id || targetId === id) && leaves(edge)) result.add(edge);
+			}
 		}
 		return [...result];
 	};
@@ -2959,6 +3033,44 @@ function crossingVariants(options, graph) {
 	if (!(graph.children ?? []).some((child) => child.children?.length) || getOption(own, "hierarchyHandling") !== "INCLUDE_CHILDREN" || getOption(own, "layered.crossingMinimization.greedySwitchHierarchical.type") !== void 0) return [];
 	return [{ "elk.randomSeed": "2" }, { "elk.randomSeed": "3" }];
 }
+/**
+* Whether two edges between different ends can share a port: an explicit port
+* carrying two or more of them, or implicit ports that merge because some
+* scope merges edges or a node is a hypernode.
+*/
+function mayShareTracks(graph, options) {
+	const merging = (node, inherited = {}) => {
+		const settings = getElementLayeredSettings({
+			...inherited,
+			...node.properties,
+			...node.layoutOptions
+		});
+		return settings.mergeEdges === true || settings.hypernode === true;
+	};
+	const anyMerging = (node) => merging(node) || (node.children ?? []).some(anyMerging);
+	if (merging(graph, options) || (graph.children ?? []).some(anyMerging)) return true;
+	const ports = /* @__PURE__ */ new Set();
+	const collectPorts = (node) => {
+		for (const port of node.ports ?? []) ports.add(String(port.id));
+		for (const child of node.children ?? []) collectPorts(child);
+	};
+	collectPorts(graph);
+	if (!ports.size) return false;
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		for (const edge of node.edges ?? []) {
+			const source = String(edge.sources?.[0] ?? edge.source), target = String(edge.targets?.[0] ?? edge.target);
+			if (source === target) continue;
+			for (const end of [source, target]) {
+				if (!ports.has(end)) continue;
+				if (seen.has(end)) return true;
+				seen.add(end);
+			}
+		}
+		return (node.children ?? []).some(visit);
+	};
+	return visit(graph);
+}
 /** Whether the graph asks for more than ELK's default layered thoroughness (7). */
 function thorough(options, graph) {
 	const own = {