@statelyai/layout 0.3.0 → 0.4.1

package/dist/elkjs-DNfXDPup.cjs

@@ -0,0 +1,3104 @@
+const require_routing = require('./routing-QIdGGFBe.cjs');
+const require_layered = require('./layered-5RxQhryb.cjs');
+const require_layout_engine = require('./layout-engine-CLFySz3R.cjs');
+let _statelyai_graph = require("@statelyai/graph");
+
+//#region src/layered/hierarchy-sweepiness.ts
+/**
+* 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 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
+	}]));
+	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;
+	};
+	const outputSide = {
+		right: "EAST",
+		left: "WEST",
+		down: "SOUTH",
+		up: "NORTH"
+	}[input.direction];
+	for (const layer of graph.layers) {
+		const northSouth = [];
+		for (const node of layer) {
+			if (node.type === "NORTH_SOUTH_PORT") {
+				northSouth.push(node.id);
+				continue;
+			}
+			const state = infos.get(node.id);
+			const connected = (side) => node.ports.some((port) => port.side === side && degree.has(port.id));
+			const external = require_layered.externalPortDummyOf(nodes.get(node.id));
+			if (external) {
+				state.hierarchy = 1;
+				if (external.side === outputSide) hierarchyPaths += state.edges;
+			} 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) for (const target of targets.get(id) ?? []) transfer(id, target);
+	}
+	const all = randomPaths + hierarchyPaths;
+	return (all === 0 ? Number.POSITIVE_INFINITY : (randomPaths - hierarchyPaths) / all) >= boundary;
+}
+
+//#endregion
+//#region src/layered/compound-boundaries.ts
+/** Return both effects of ELK's transfer: parent port and corrected content-space dummy. */
+function transferExternalPort(input) {
+	const { contentSize: size, padding: p, offset: o, borderOffset: b, portSize } = input;
+	const dummy = {
+		x: input.dummy.x,
+		y: input.dummy.y
+	};
+	const port = {
+		x: dummy.x + input.dummy.width / 2,
+		y: dummy.y + input.dummy.height / 2
+	};
+	switch (input.side) {
+		case "NORTH":
+			port.x += p.left + o.x - portSize.width / 2;
+			port.y = -portSize.height - b;
+			dummy.y = -(p.top + b + o.y);
+			break;
+		case "EAST":
+			port.x = size.width + p.left + p.right + b;
+			port.y += p.top + o.y - portSize.height / 2;
+			dummy.x = size.width + p.right + b - o.x;
+			break;
+		case "SOUTH":
+			port.x += p.left + o.x - portSize.width / 2;
+			port.y = size.height + p.top + p.bottom + b;
+			dummy.y = size.height + p.bottom + b - o.y;
+			break;
+		case "WEST":
+			port.x = -portSize.width - b;
+			port.y += p.top + o.y - portSize.height / 2;
+			dummy.x = -(p.left + b + o.x);
+			break;
+	}
+	return {
+		port,
+		dummy
+	};
+}
+/** Segments are directed source-to-target and translated to one reference graph. */
+function joinCompoundRouteSegments(segments, unnecessaryBendpoints = false) {
+	const bends = [];
+	let start, end, last;
+	for (const segment of segments) {
+		if (segment.points.length < 2) throw new Error("Compound route segment needs two anchors");
+		const points = segment.points.map((p) => ({
+			x: p.x + segment.offset.x,
+			y: p.y + segment.offset.y
+		}));
+		const source = points[0], target = points.at(-1);
+		const inner = points.slice(1, -1);
+		if (!start) start = source;
+		if (last) {
+			const next = inner[0] ?? target;
+			const dx = Math.abs(last.x - next.x) > 1e-6;
+			const dy = Math.abs(last.y - next.y) > 1e-6;
+			if (unnecessaryBendpoints ? dx || dy : dx && dy) bends.push(source);
+		}
+		bends.push(...inner);
+		last = inner.at(-1) ?? source;
+		end = target;
+	}
+	if (!start || !end) return [];
+	const route = [
+		start,
+		...bends,
+		end
+	];
+	const straight = (a, b) => Math.abs(a.x - b.x) <= 1e-6 || Math.abs(a.y - b.y) <= 1e-6;
+	for (let index = 0; index + 1 < route.length; index++) {
+		const a = route[index], b = route[index + 1];
+		if (straight(a, b)) continue;
+		const next = route[index + 2], previous = route[index - 1];
+		const verticalFirst = next !== void 0 ? Math.abs(b.y - next.y) <= 1e-6 : previous !== void 0 && Math.abs(previous.x - a.x) <= 1e-6;
+		route.splice(index + 1, 0, verticalFirst ? {
+			x: a.x,
+			y: b.y
+		} : {
+			x: b.x,
+			y: a.y
+		});
+	}
+	return route;
+}
+
+//#endregion
+//#region src/elkjs/layout-quality.ts
+const EPS = 1e-6;
+/** Shared endpoint nodes get this clearance, so fan-in and fan-out are not penalized. */
+const TERMINAL_MARGIN = 12;
+const horizontal = (s) => Math.abs(s.a.y - s.b.y) < EPS;
+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]));
+/** 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
+	}]]);
+	const rects = /* @__PURE__ */ new Map();
+	const owner = /* @__PURE__ */ new Map();
+	const leaves = [];
+	const bounds = [];
+	const place = (parent, offset) => {
+		for (const child of parent.children ?? []) {
+			const id = String(child.id);
+			const at = {
+				x: offset.x + (child.x ?? 0),
+				y: offset.y + (child.y ?? 0)
+			};
+			const rect = {
+				...at,
+				width: child.width ?? 0,
+				height: child.height ?? 0
+			};
+			frames.set(id, at);
+			rects.set(id, rect);
+			owner.set(id, id);
+			for (const port of child.ports ?? []) owner.set(String(port.id), id);
+			bounds.push(at, {
+				x: at.x + rect.width,
+				y: at.y + rect.height
+			});
+			if (child.children?.length) place(child, at);
+			else leaves.push(rect);
+		}
+	};
+	place(root, {
+		x: 0,
+		y: 0
+	});
+	const routes = [];
+	let defects = 0, bends = 0, length = 0;
+	const collect = (parent) => {
+		for (const edge of parent.edges ?? []) {
+			const container = String(edge.container ?? parent.id);
+			const offset = frames.get(container) ?? {
+				x: 0,
+				y: 0
+			};
+			const ends = [edge.sources?.[0], edge.targets?.[0]].flatMap((end) => {
+				const node = owner.get(String(end));
+				return node === void 0 ? [] : [node];
+			});
+			const segments = [];
+			for (const section of edge.sections ?? []) {
+				const points = [
+					section.startPoint,
+					...section.bendPoints ?? [],
+					section.endPoint
+				].map((point) => ({
+					x: point.x + offset.x,
+					y: point.y + offset.y
+				}));
+				bounds.push(...points);
+				let direction;
+				for (let index = 0; index + 1 < points.length; index++) {
+					const segment = {
+						a: points[index],
+						b: points[index + 1]
+					};
+					const size = Math.hypot(segment.b.x - segment.a.x, segment.b.y - segment.a.y);
+					if (size < EPS) continue;
+					if (!horizontal(segment) && !vertical(segment)) defects++;
+					const next = {
+						x: Math.sign(segment.b.x - segment.a.x),
+						y: Math.sign(segment.b.y - segment.a.y)
+					};
+					if (direction && (direction.x !== next.x || direction.y !== next.y)) bends++;
+					direction = next;
+					length += size;
+					segments.push(segment);
+				}
+			}
+			const labels = (edge.labels ?? []).flatMap((label) => label.width && label.height ? [{
+				x: (label.x ?? 0) + offset.x,
+				y: (label.y ?? 0) + offset.y,
+				width: label.width,
+				height: label.height
+			}] : []);
+			for (const label of labels) bounds.push(label, {
+				x: label.x + label.width,
+				y: label.y + label.height
+			});
+			for (const segment of segments) for (const rect of leaves) if (horizontal(segment) && strictlyInside(segment.a.y, rect.y, rect.y + rect.height) && overlapLength(span(segment, "x"), [rect.x, rect.x + rect.width]) > EPS || vertical(segment) && strictlyInside(segment.a.x, rect.x, rect.x + rect.width) && overlapLength(span(segment, "y"), [rect.y, rect.y + rect.height]) > EPS) defects++;
+			for (const [index, first] of segments.entries()) for (const second of segments.slice(index + 1)) if (sharedLength(first, second) > EPS) defects++;
+			routes.push({
+				ends,
+				segments,
+				visible: labels.length && !defectsOnly ? segments.flatMap((s) => outsideAll(s, labels)) : segments,
+				labels
+			});
+		}
+		for (const child of parent.children ?? []) collect(child);
+	};
+	collect(root);
+	const allLabels = routes.flatMap((route) => route.labels);
+	const covers = (a, b) => a.x < b.x + b.width - EPS && a.x + a.width > b.x + EPS && a.y < b.y + b.height - EPS && a.y + a.height > b.y + EPS;
+	for (const [index, label] of allLabels.entries()) {
+		for (const rect of leaves) if (covers(label, rect)) defects++;
+		for (const other of allLabels.slice(index + 1)) if (covers(label, other)) defects++;
+	}
+	for (const route of routes) for (const other of routes) if (other !== route) {
+		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;
+	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));
+		let points;
+		const cross$1 = (s, t) => {
+			const h = horizontal(s) && vertical(t) ? s : horizontal(t) && vertical(s) ? t : void 0;
+			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;
+	return {
+		defects,
+		crossings,
+		overlap,
+		bends,
+		length,
+		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"));
+	return 0;
+}
+const TOLERANCE = .02;
+/** True when `candidate` is better at the first measure where the two layouts differ. */
+function isBetterLayout(candidate, current) {
+	for (const key of [
+		"defects",
+		"crossings",
+		"overlap",
+		"bends",
+		"length",
+		"area"
+	]) {
+		const limit = key === "overlap" || key === "length" || key === "area" ? Math.max(TOLERANCE * Math.abs(current[key]), EPS) : 0;
+		if (Math.abs(candidate[key] - current[key]) > limit) return candidate[key] < current[key];
+	}
+	return false;
+}
+
+//#endregion
+//#region src/elkjs/orthogonal-junctions.ts
+/** Reconstruct native segment spans from final orthogonal tracks, then emit ELK's unique junctions. */
+function applyOrthogonalJunctions(root, horizontal$1, increasing, mergeEdges, hypernodes, preservedEdges) {
+	const edges = root.edges ?? [], ports = [], byPort = /* @__PURE__ */ new Map();
+	const explicit = new Map((root.children ?? []).flatMap((n) => (n.ports ?? []).map((p) => [String(p.id), n])));
+	const owner = new Map((root.children ?? []).map((node) => [String(node.id), node]));
+	for (const [id, node] of explicit) owner.set(id, node);
+	const records = edges.flatMap((edge, index) => {
+		if (preservedEdges.has(String(edge.id))) return [];
+		const sourceOwner = owner.get(String(edge.sources?.[0] ?? edge.source));
+		if (sourceOwner !== void 0 && sourceOwner === owner.get(String(edge.targets?.[0] ?? edge.target))) return [];
+		const section = edge.sections?.[0];
+		if (!section || edge.sections?.length !== 1) return [];
+		let points = [
+			section.startPoint,
+			...section.bendPoints ?? [],
+			section.endPoint
+		];
+		if (points.some((p, i) => i > 0 && Math.abs(p.x - points[i - 1].x) > .001 && Math.abs(p.y - points[i - 1].y) > .001)) return [];
+		let source = String(edge.sources?.[0] ?? edge.source), target = String(edge.targets?.[0] ?? edge.target);
+		const flow$1 = (p) => horizontal$1 ? p.x : p.y;
+		if (flow$1(points[0]) > flow$1(points.at(-1)) === increasing) {
+			points = [...points].reverse();
+			[source, target] = [target, source];
+		}
+		const key = (ref, side) => explicit.has(ref) ? JSON.stringify(["port", ref]) : mergeEdges || hypernodes.has(ref) ? JSON.stringify([
+			"implicit",
+			ref,
+			side
+		]) : JSON.stringify([
+			"edge",
+			index,
+			side
+		]);
+		return [{
+			edge,
+			points,
+			source: key(source, "source"),
+			target: key(target, "target")
+		}];
+	});
+	const cross$1 = (p) => horizontal$1 ? p.y : p.x, flow = (p) => horizontal$1 ? p.x : p.y;
+	for (const side of ["source", "target"]) {
+		const ordered = [...records].sort((a, b) => cross$1(side === "source" ? a.points[0] : a.points.at(-1)) - cross$1(side === "source" ? b.points[0] : b.points.at(-1)));
+		for (const record of ordered) {
+			const id = record[side];
+			if (!byPort.has(id)) {
+				const port = {
+					id,
+					side,
+					position: cross$1(side === "source" ? record.points[0] : record.points.at(-1))
+				};
+				byPort.set(id, port);
+				ports.push(port);
+			}
+		}
+	}
+	const grouped = require_layered.createOrthogonalHypersegments(ports, records.map((r) => ({
+		source: r.source,
+		target: r.target
+	})));
+	const created = /* @__PURE__ */ new Set();
+	for (const group of grouped.segments) {
+		const members = records.filter((r) => group.ports.includes(r.source));
+		if (members.length === 1) {
+			delete members[0].edge.junctionPoints;
+			continue;
+		}
+		const tracks = /* @__PURE__ */ new Map();
+		const track = (point) => {
+			const key = flow(point);
+			let t = tracks.get(key);
+			if (!t) {
+				t = {
+					start: Infinity,
+					end: -Infinity,
+					incoming: [],
+					outgoing: []
+				};
+				tracks.set(key, t);
+			}
+			t.start = Math.min(t.start, cross$1(point));
+			t.end = Math.max(t.end, cross$1(point));
+			return t;
+		};
+		for (const r of members) {
+			const bends = r.points.slice(1, -1);
+			if (!bends.length) continue;
+			for (const p of bends) track(p);
+			track(bends[0]).incoming.push(cross$1(bends[0]));
+			track(bends.at(-1)).outgoing.push(cross$1(bends.at(-1)));
+			for (let i = 1; i < bends.length; i++) if (Math.abs(flow(bends[i]) - flow(bends[i - 1])) > .001) {
+				track(bends[i - 1]).outgoing.push(cross$1(bends[i - 1]));
+				track(bends[i]).incoming.push(cross$1(bends[i]));
+			}
+		}
+		for (const r of members.filter((r$1) => r$1.points.length === 2)) {
+			const start = Math.min(flow(r.points[0]), flow(r.points[1]));
+			const end = Math.max(flow(r.points[0]), flow(r.points[1]));
+			for (const [position, t] of tracks) {
+				if (position < start || position > end) continue;
+				t.incoming.push(cross$1(r.points[0]));
+				t.outgoing.push(cross$1(r.points[1]));
+			}
+		}
+		for (const r of members) for (let index = 1; index < r.points.length; index++) {
+			const a = r.points[index - 1], b = r.points[index];
+			if (Math.abs(cross$1(a) - cross$1(b)) >= .001) continue;
+			const start = Math.min(flow(a), flow(b)), end = Math.max(flow(a), flow(b));
+			for (const [position, t] of tracks) {
+				if (position <= start || position >= end) continue;
+				t.incoming.push(cross$1(a));
+				t.outgoing.push(cross$1(b));
+			}
+		}
+		for (const t of tracks.values()) {
+			t.start = Math.min(t.start, ...t.incoming, ...t.outgoing);
+			t.end = Math.max(t.end, ...t.incoming, ...t.outgoing);
+		}
+		for (const port of group.ports) for (const r of members.filter((r$1) => r$1.source === port)) {
+			delete r.edge.junctionPoints;
+			for (const p of r.points.slice(1, -1)) {
+				const t = tracks.get(flow(p)), value = cross$1(p), key = `${p.x}:${p.y}`;
+				const boundary = t.incoming.length && t.outgoing.length && (Math.abs(value - Math.min(...t.incoming)) < .001 && Math.abs(value - Math.min(...t.outgoing)) < .001 || Math.abs(value - Math.max(...t.incoming)) < .001 && Math.abs(value - Math.max(...t.outgoing)) < .001);
+				if (!created.has(key) && (value > t.start && value < t.end || boundary)) {
+					(r.edge.junctionPoints ??= []).push({ ...p });
+					created.add(key);
+				}
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/elkjs/opposing-tracks.ts
+const option$1 = (options, suffix) => Object.entries(options ?? {}).find(([key]) => key === suffix || key.endsWith(`.${suffix}`))?.[1];
+/**
+* Separate opposite-direction track sharing in a finished ELK JSON layout,
+* across nested containers, in world coordinates.
+*/
+function separateElkOpposingTracks(root, options) {
+	const orthogonal = (node, inherited) => {
+		const value = option$1(node.layoutOptions, "edgeRouting");
+		return value === void 0 ? inherited : String(value) === "ORTHOGONAL";
+	};
+	const rootOrthogonal = orthogonal(root, String(option$1(options, "edgeRouting") ?? "ORTHOGONAL") === "ORTHOGONAL");
+	const frames = new Map([[String(root.id), {
+		x: 0,
+		y: 0
+	}]]);
+	const routing = new Map([[String(root.id), rootOrthogonal]]);
+	const nodes = /* @__PURE__ */ new Map(), leaves = /* @__PURE__ */ new Set(), owner = /* @__PURE__ */ new Map(), ports = /* @__PURE__ */ new Map();
+	const place = (parent, offset) => {
+		for (const child of parent.children ?? []) {
+			const id = String(child.id);
+			const at = {
+				x: offset.x + (child.x ?? 0),
+				y: offset.y + (child.y ?? 0)
+			};
+			frames.set(id, at);
+			routing.set(id, orthogonal(child, routing.get(String(parent.id)) ?? rootOrthogonal));
+			nodes.set(id, {
+				...at,
+				width: child.width ?? 0,
+				height: child.height ?? 0
+			});
+			owner.set(id, id);
+			for (const port of child.ports ?? []) {
+				owner.set(String(port.id), id);
+				ports.set(String(port.id), {
+					node: id,
+					rect: {
+						x: at.x + (port.x ?? 0),
+						y: at.y + (port.y ?? 0),
+						width: port.width ?? 0,
+						height: port.height ?? 0
+					}
+				});
+			}
+			if (child.children?.length) place(child, at);
+			else leaves.add(id);
+		}
+	};
+	place(root, {
+		x: 0,
+		y: 0
+	});
+	const records = [];
+	const collect = (parent) => {
+		for (const edge of parent.edges ?? []) {
+			if ((edge.sections?.length ?? 0) > 1) continue;
+			const container = String(edge.container ?? parent.id);
+			const offset = frames.get(container) ?? {
+				x: 0,
+				y: 0
+			};
+			const points = (edge.sections ?? []).flatMap((section) => [
+				section.startPoint,
+				...section.bendPoints ?? [],
+				section.endPoint
+			].map((p) => ({
+				x: p.x + offset.x,
+				y: p.y + offset.y
+			})));
+			const axisParallel = points.every((p, i) => i === 0 || Math.abs(p.x - points[i - 1].x) < 1e-6 || Math.abs(p.y - points[i - 1].y) < 1e-6);
+			const ends = [edge.sources?.[0] ?? edge.source, edge.targets?.[0] ?? edge.target].flatMap((end) => {
+				const id = owner.get(String(end));
+				return id === void 0 ? [] : [id];
+			});
+			const portOf = (end) => ports.has(String(end)) ? String(end) : void 0;
+			records.push({
+				edge,
+				offset,
+				route: {
+					id: String(edge.id),
+					ends,
+					points,
+					ports: [portOf(edge.sources?.[0] ?? edge.source), portOf(edge.targets?.[0] ?? edge.target)],
+					labels: (edge.labels ?? []).flatMap((label) => label.width && label.height ? [{
+						x: (label.x ?? 0) + offset.x,
+						y: (label.y ?? 0) + offset.y,
+						width: label.width,
+						height: label.height
+					}] : []),
+					movable: points.length > 0 && axisParallel && (routing.get(container) ?? rootOrthogonal)
+				}
+			});
+		}
+		for (const child of parent.children ?? []) collect(child);
+	};
+	collect(root);
+	if (!records.some((record) => record.route.movable)) return;
+	const spacing = Number(option$1(options, "spacing.edgeEdge") ?? 10);
+	const changed = require_layered.separateOpposingTracks({
+		routes: records.map((record) => record.route),
+		nodes,
+		leaves,
+		ports,
+		spacing: Number.isFinite(spacing) && spacing > 0 ? spacing : 10
+	});
+	if (!changed.size) return;
+	const routes = new Map(records.map((record) => [record.route.id, changed.get(record.route.id) ?? record.route.points]));
+	const on = (point, points) => points.some((b, i) => {
+		const a = points[i - 1];
+		return a !== void 0 && point.x >= Math.min(a.x, b.x) - 1e-6 && point.x <= Math.max(a.x, b.x) + 1e-6 && point.y >= Math.min(a.y, b.y) - 1e-6 && point.y <= Math.max(a.y, b.y) + 1e-6;
+	});
+	for (const { edge, offset, route } of records) {
+		const points = changed.get(route.id);
+		if (points) {
+			const section = edge.sections[0];
+			const local = points.map((p) => ({
+				x: p.x - offset.x,
+				y: p.y - offset.y
+			}));
+			section.startPoint = local[0];
+			section.endPoint = local.at(-1);
+			section.bendPoints = local.slice(1, -1);
+		}
+		if (!edge.junctionPoints?.length) continue;
+		const own = routes.get(route.id);
+		edge.junctionPoints = edge.junctionPoints.filter((junction) => {
+			const point = {
+				x: junction.x + offset.x,
+				y: junction.y + offset.y
+			};
+			return on(point, own) && [...routes].some(([id, other]) => id !== route.id && on(point, other));
+		});
+		if (!edge.junctionPoints.length) delete edge.junctionPoints;
+	}
+}
+
+//#endregion
+//#region src/elkjs/statechart.ts
+function option(node, suffix) {
+	const settings = {
+		...node.properties,
+		...node.layoutOptions
+	};
+	return settings[suffix] ?? settings[`elk.${suffix}`] ?? settings[`org.eclipse.elk.${suffix}`];
+}
+const endpoint$1 = (edge, source) => source ? edge.sources?.[0] ?? edge.source : edge.targets?.[0] ?? edge.target;
+/** Compile semantic hints into settings implemented by this package's ELK adapter. */
+function compileStatechartLayout(input, scopes) {
+	const graph = structuredClone(input);
+	const paths = Object.create(null);
+	const commonExits = Object.create(null);
+	const containers = /* @__PURE__ */ new Map();
+	const edges = [];
+	const collect = (node) => {
+		if (node.id === void 0 || containers.has(String(node.id))) throw new Error("Statechart nodes require unique IDs");
+		containers.set(String(node.id), node);
+		edges.push(...node.edges ?? []);
+		node.children?.forEach(collect);
+	};
+	collect(graph);
+	for (const [id, scope] of Object.entries(scopes)) {
+		const container = containers.get(id);
+		if (!container) throw new Error(`Unknown statechart container: ${id}`);
+		const children = container.children ?? [];
+		const ids = new Set(children.map((node) => node.id));
+		const owner = /* @__PURE__ */ new Map();
+		const own = (node, childId) => {
+			owner.set(node.id, childId);
+			node.ports?.forEach((port) => owner.set(port.id, childId));
+			node.children?.forEach((descendant) => own(descendant, childId));
+		};
+		children.forEach((child) => own(child, child.id));
+		const localEdges = edges.filter((edge) => owner.has(endpoint$1(edge, true)) && owner.has(endpoint$1(edge, false)));
+		const successors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+		const predecessors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+		for (const edge of localEdges) {
+			const source = owner.get(endpoint$1(edge, true));
+			const target = owner.get(endpoint$1(edge, false));
+			if (source === target) continue;
+			successors.get(source).add(target);
+			predecessors.get(target).add(source);
+		}
+		const exits = children.filter((node) => successors.get(node.id).size === 0 && predecessors.get(node.id).size >= 2).map((node) => node.id);
+		commonExits[id] = exits;
+		const path = [...scope.preferredPath ?? (scope.initialNodeId === void 0 ? [] : [scope.initialNodeId])];
+		if (new Set(path).size !== path.length || path.some((nodeId) => !ids.has(nodeId))) throw new Error(`Path must contain distinct direct children of ${id}`);
+		if (scope.initialNodeId !== void 0 && (!ids.has(scope.initialNodeId) || path[0] !== scope.initialNodeId)) throw new Error(`Path must start at initial child of ${id}`);
+		if (scope.preferredPath) {
+			for (let i = 1; i < path.length; i++) if (!successors.get(path[i - 1])?.has(path[i])) throw new Error(`Disconnected preferred path in ${id}`);
+		} else while (path.length) {
+			const next = [...successors.get(path.at(-1))].filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId));
+			if (next.length !== 1) break;
+			path.push(next[0]);
+		}
+		paths[id] = path;
+		container.children = [
+			...path,
+			...children.map((node) => node.id).filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId)),
+			...exits.filter((nodeId) => !path.includes(nodeId))
+		].map((nodeId) => children.find((node) => node.id === nodeId));
+		container.layoutOptions = {
+			...path.length > 1 && option(container, "layered.cycleBreaking.strategy") === void 0 ? { "elk.layered.cycleBreaking.strategy": "MODEL_ORDER" } : {},
+			...path.length > 1 && option(container, "layered.feedbackEdges") === void 0 ? { "elk.layered.feedbackEdges": true } : {},
+			...container.layoutOptions,
+			...scope.direction ? { direction: scope.direction } : {}
+		};
+	}
+	return {
+		graph,
+		paths,
+		commonExits
+	};
+}
+const intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+/** Diagnostic objective, not a proof of geometric validity. Coordinates are container-relative. */
+function scoreStatechartLayout(graph, paths = {}) {
+	const score = {
+		invalid: 0,
+		overlaps: 0,
+		pathOrder: 0,
+		crossings: 0,
+		bends: 0,
+		routeLength: 0
+	};
+	const segments = [];
+	const boxes = [];
+	const rect = (shape, x, y) => {
+		if ([
+			shape.x,
+			shape.y,
+			shape.width,
+			shape.height
+		].some((value) => value === void 0 || !Number.isFinite(value)) || (shape.width ?? 0) < 0 || (shape.height ?? 0) < 0) score.invalid++;
+		return {
+			x: x + (shape.x ?? 0),
+			y: y + (shape.y ?? 0),
+			width: shape.width ?? 0,
+			height: shape.height ?? 0
+		};
+	};
+	const visit = (node, x, y, ancestors, inheritedDirection = "RIGHT") => {
+		const direction = String(option(node, "direction") ?? inheritedDirection).toUpperCase();
+		const horizontal$1 = direction === "RIGHT" || direction === "LEFT";
+		const sign = direction === "LEFT" || direction === "UP" ? -1 : 1;
+		const path = paths[String(node.id)] ?? [];
+		for (let i = 1; i < path.length; i++) {
+			const a = node.children?.find((child) => child.id === path[i - 1]);
+			const b = node.children?.find((child) => child.id === path[i]);
+			if (!a || !b || sign * (horizontal$1 ? b.x - a.x : b.y - a.y) <= 0) score.pathOrder++;
+		}
+		for (const child of node.children ?? []) {
+			if (String(option(child, "noLayout")).toLowerCase() === "true") continue;
+			const box = rect(child, x, y);
+			if ((child.x ?? 0) < 0 || (child.y ?? 0) < 0 || (child.x ?? 0) + (child.width ?? 0) > (node.width ?? Infinity) + .001 || (child.y ?? 0) + (child.height ?? 0) > (node.height ?? Infinity) + .001) score.invalid++;
+			boxes.push({
+				rect: box,
+				ancestors,
+				node: child
+			});
+			visit(child, box.x, box.y, [...ancestors, child], direction);
+		}
+		for (const edge of node.edges ?? []) {
+			if (String(option(edge, "noLayout")).toLowerCase() === "true") continue;
+			if (!edge.sections?.length) score.invalid++;
+			for (const label of edge.labels ?? []) {
+				if (String(option(label, "noLayout")).toLowerCase() === "true") continue;
+				boxes.push({
+					rect: rect(label, x, y),
+					ancestors
+				});
+			}
+			for (const section of edge.sections ?? []) {
+				const points = [
+					section.startPoint,
+					...section.bendPoints ?? [],
+					section.endPoint
+				];
+				score.bends += section.bendPoints?.length ?? 0;
+				for (const point of points) if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) score.invalid++;
+				for (let i = 1; i < points.length; i++) {
+					const a = {
+						x: x + points[i - 1].x,
+						y: y + points[i - 1].y
+					};
+					const b = {
+						x: x + points[i].x,
+						y: y + points[i].y
+					};
+					score.routeLength += Math.hypot(b.x - a.x, b.y - a.y);
+					segments.push({
+						a,
+						b,
+						edge
+					});
+				}
+			}
+		}
+	};
+	visit(graph, 0, 0, [graph]);
+	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
+		const a = boxes[i], b = boxes[j];
+		if (a.node && b.ancestors.includes(a.node) || b.node && a.ancestors.includes(b.node)) continue;
+		if (intersects(a.rect, b.rect)) score.overlaps++;
+	}
+	for (let i = 0; i < segments.length; i++) for (let j = i + 1; j < segments.length; j++) {
+		const a = segments[i], b = segments[j];
+		if (a.edge === b.edge) continue;
+		if (cross(a.a, a.b, b.a) * cross(a.a, a.b, b.b) < 0 && cross(b.a, b.b, a.a) * cross(b.a, b.b, a.b) < 0) score.crossings++;
+	}
+	if (!Number.isFinite(score.routeLength)) score.routeLength = Number.MAX_VALUE;
+	return score;
+}
+const objectives = [
+	"invalid",
+	"overlaps",
+	"pathOrder",
+	"crossings",
+	"bends",
+	"routeLength"
+];
+function better(a, b) {
+	for (const key of objectives) if (a[key] !== b[key]) return a[key] < b[key];
+	return false;
+}
+/** Each attempt starts from original input. No post-layout geometry edits. */
+async function layoutStatechart(input, options) {
+	const maxAttempts = options.maxAttempts ?? 3;
+	if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3) throw new RangeError("maxAttempts must be an integer from 1 to 3");
+	const plan = compileStatechartLayout(input, options.scopes);
+	const attempts = [];
+	let selected;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const candidate = structuredClone(attempt === 0 ? input : plan.graph);
+		const configure = (node) => {
+			const scope = Object.hasOwn(options.scopes, String(node.id)) ? options.scopes[String(node.id)] : void 0;
+			if (scope?.direction) node.layoutOptions = {
+				...node.layoutOptions,
+				direction: scope.direction
+			};
+			if (attempt === 2 && scope) node.layoutOptions = {
+				...node.layoutOptions,
+				"spacing.nodeNode": Math.max(40, Number(option(node, "spacing.nodeNode") ?? 20) * 1.5),
+				"layered.spacing.nodeNodeBetweenLayers": Math.max(60, Number(option(node, "layered.spacing.nodeNodeBetweenLayers") ?? 20) * 1.5)
+			};
+			if (attempt === 2 && scope) {
+				const groups = /* @__PURE__ */ new Map();
+				for (const edge of node.edges ?? []) {
+					if (!edge.labels?.length) continue;
+					const key = JSON.stringify([endpoint$1(edge, true), endpoint$1(edge, false)]);
+					const group = groups.get(key) ?? [];
+					group.push(edge);
+					groups.set(key, group);
+				}
+				for (const group of groups.values()) for (let i = 1; i < Math.min(group.length, 3); i++) {
+					const edge = group[i];
+					if (option(edge, "edgeLabels.placement") === void 0 && edge.labels.every((label) => option(label, "edgeLabels.placement") === void 0)) {
+						const placement = i === 1 ? "HEAD" : "TAIL";
+						edge.layoutOptions = {
+							...edge.layoutOptions,
+							"elk.edgeLabels.placement": placement
+						};
+						edge.labels = edge.labels.map((label) => ({
+							...label,
+							layoutOptions: {
+								...label.layoutOptions,
+								"elk.edgeLabels.placement": placement
+							}
+						}));
+					}
+				}
+			}
+			node.children?.forEach(configure);
+		};
+		configure(candidate);
+		const graph = await new ELK().layout(candidate);
+		const score = scoreStatechartLayout(graph, plan.paths);
+		attempts.push({
+			kind: attempt === 0 ? "baseline" : attempt === 1 ? "policy" : "spacing",
+			score
+		});
+		if (!selected || better(score, selected.score)) selected = {
+			graph,
+			score,
+			attempt
+		};
+	}
+	return {
+		...selected,
+		attempts,
+		paths: plan.paths,
+		commonExits: plan.commonExits
+	};
+}
+
+//#endregion
+//#region src/elkjs/routes.ts
+/** Normalize any ELK layout's section geometry, preserving ports and hyperedge junctions. */
+function getElkRoutes(graph, options = {}) {
+	const shapes = /* @__PURE__ */ new Map(), frames = /* @__PURE__ */ new Map();
+	const edges = [];
+	function visit(node, offset, inherited) {
+		const position = {
+			x: offset.x + (node.x ?? 0),
+			y: offset.y + (node.y ?? 0)
+		};
+		const routing = node.layoutOptions?.["elk.edgeRouting"] ?? node.layoutOptions?.["org.eclipse.elk.edgeRouting"] ?? inherited;
+		frames.set(node.id, position);
+		shapes.set(node.id, {
+			ref: {
+				kind: "node",
+				nodeId: node.id
+			},
+			center: {
+				x: position.x + (node.width ?? 0) / 2,
+				y: position.y + (node.height ?? 0) / 2
+			}
+		});
+		for (const port of node.ports ?? []) shapes.set(port.id, {
+			ref: {
+				kind: "node",
+				nodeId: node.id,
+				port: port.id
+			},
+			center: {
+				x: position.x + (port.x ?? 0) + (port.width ?? 0) / 2,
+				y: position.y + (port.y ?? 0) + (port.height ?? 0) / 2
+			}
+		});
+		for (const edge of node.edges ?? []) edges.push({
+			edge,
+			offset: position,
+			routing: edge.layoutOptions?.["elk.edgeRouting"] ?? edge.layoutOptions?.["org.eclipse.elk.edgeRouting"] ?? routing
+		});
+		for (const child of node.children ?? []) visit(child, position, routing);
+	}
+	visit(graph, {
+		x: 0,
+		y: 0
+	}, options.routing ?? "POLYLINE");
+	const result = /* @__PURE__ */ new Map();
+	for (const { edge, offset: inheritedOffset, routing } of edges) {
+		const offset = edge.container ? frames.get(edge.container) ?? inheritedOffset : inheritedOffset;
+		const point = (p) => ({
+			x: p.x + offset.x,
+			y: p.y + offset.y
+		});
+		const parents = /* @__PURE__ */ new Map();
+		const root = (key) => {
+			let current = key;
+			while (parents.has(current)) current = parents.get(current);
+			return current;
+		};
+		const join = (a, b) => {
+			const x = root(a), y = root(b);
+			if (x !== y) parents.set(x < y ? y : x, x < y ? x : y);
+		};
+		for (const section of edge.sections ?? []) {
+			for (const id of section.outgoingSections ?? []) join(`${section.id}:end`, `${id}:start`);
+			for (const id of section.incomingSections ?? []) join(`${id}:end`, `${section.id}:start`);
+		}
+		const sections = [];
+		let malformed = false;
+		for (const section of edge.sections ?? []) {
+			const points = [
+				section.startPoint,
+				...section.bendPoints ?? [],
+				section.endPoint
+			].map(point);
+			let path;
+			if (points.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))) {
+				malformed = true;
+				for (let i = 0; i < points.length; i++) if (!Number.isFinite(points[i].x) || !Number.isFinite(points[i].y)) points[i] = {
+					x: offset.x + i * 20,
+					y: offset.y
+				};
+			}
+			if (routing === "SPLINES") if ((points.length - 1) % 3 || points.length < 4) {
+				malformed = true;
+				path = require_routing.pathFromPoints([points[0], points.at(-1)]);
+			} else path = require_routing.pathFromSplinePoints(points);
+			else path = require_routing.pathFromPoints(points);
+			const fromShape = section.incomingShape ?? (!section.incomingSections?.length && edge.sources.length === 1 ? edge.sources[0] : void 0);
+			const toShape = section.outgoingShape ?? (!section.outgoingSections?.length && edge.targets.length === 1 ? edge.targets[0] : void 0);
+			sections.push({
+				id: section.id,
+				from: fromShape ? shapes.get(fromShape)?.ref ?? {
+					kind: "node",
+					nodeId: fromShape
+				} : {
+					kind: "junction",
+					id: `${edge.id}:${root(`${section.id}:start`)}`
+				},
+				to: toShape ? shapes.get(toShape)?.ref ?? {
+					kind: "node",
+					nodeId: toShape
+				} : {
+					kind: "junction",
+					id: `${edge.id}:${root(`${section.id}:end`)}`
+				},
+				path
+			});
+		}
+		if (!sections.length) {
+			malformed = true;
+			const source = shapes.get(edge.sources[0] ?? ""), origin = source?.center ?? {
+				x: 0,
+				y: 0
+			};
+			const targets = [...edge.targets, ...edge.sources.slice(1)];
+			for (const [i, id] of (targets.length ? targets : [""]).entries()) {
+				const target = shapes.get(id);
+				sections.push({
+					id: `${edge.id}:fallback:${i}`,
+					from: source?.ref ?? {
+						kind: "node",
+						nodeId: edge.sources[0] ?? ""
+					},
+					to: target?.ref ?? {
+						kind: "node",
+						nodeId: id
+					},
+					path: require_routing.pathFromPoints([origin, target?.center ?? {
+						x: origin.x + 40,
+						y: origin.y + 40
+					}])
+				});
+			}
+		}
+		result.set(edge.id, require_routing.freeze({
+			edgeId: edge.id,
+			sections,
+			status: malformed ? "fallback" : "routed",
+			diagnostics: malformed ? [{
+				code: "MISSING_GEOMETRY",
+				edgeId: edge.id,
+				message: "ELK sections contain missing or invalid geometry; rendered fallback paths"
+			}] : []
+		}));
+	}
+	return result;
+}
+
+//#endregion
+//#region src/elkjs/index.ts
+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;
+	constructor(options = {}) {
+		this.#options = options;
+		this.#algorithmIds = new Set([
+			"box",
+			"fixed",
+			"random",
+			"rectpacking",
+			"sporeCompaction",
+			"sporeOverlap",
+			...(options.algorithms ?? ["layered"]).filter((id) => id === "layered")
+		]);
+	}
+	async knownLayoutAlgorithms() {
+		return [...this.#algorithmIds].map((id) => ({
+			id: id === "layered" ? "org.eclipse.elk.layered" : id,
+			name: {
+				layered: "Layered",
+				box: "Box",
+				fixed: "Fixed",
+				random: "Random",
+				rectpacking: "Rectangle Packing",
+				sporeCompaction: "SPOrE Compaction",
+				sporeOverlap: "SPOrE Overlap Removal"
+			}[id],
+			category: id === "layered" ? "layered" : "other",
+			knownOptions: id === "layered" ? require_layered.elkLayeredOptionDefinitions.map((definition) => definition.elkId) : id === "box" ? [
+				"padding",
+				"spacing.nodeNode",
+				"aspectRatio",
+				"box.packingMode"
+			] : id === "random" ? [
+				"padding",
+				"spacing.nodeNode",
+				"aspectRatio",
+				"randomSeed"
+			] : ["position", "bendPoints"]
+		}));
+	}
+	async knownLayoutOptions() {
+		return [{
+			id: "org.eclipse.elk.algorithm",
+			name: "Layout Algorithm",
+			type: "STRING"
+		}, ...require_layered.elkLayeredOptionDefinitions.map((definition) => ({
+			id: definition.elkId,
+			name: definition.name,
+			type: definition.type,
+			targets: [...definition.targets]
+		}))];
+	}
+	async knownLayoutCategories() {
+		return [{
+			id: "layered",
+			name: "Layered",
+			knownLayouters: this.#algorithmIds.has("layered") ? ["layered"] : []
+		}, {
+			id: "other",
+			name: "Other",
+			knownLayouters: [
+				"box",
+				"fixed",
+				"random"
+			]
+		}];
+	}
+	terminateWorker() {}
+	async layout(graph, arguments_ = {}) {
+		const options = {
+			...this.#options.defaultLayoutOptions,
+			...arguments_.layoutOptions
+		};
+		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;
+		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
+				}
+			}))
+		];
+		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;
+				quality = candidateQuality;
+			}
+		}
+		return best;
+	}
+	async #layoutWithoutDefectiveCompaction(graph, arguments_) {
+		const pristine = usesPostCompaction({
+			...this.#options.defaultLayoutOptions,
+			...arguments_.layoutOptions
+		}, graph) ? structuredClone(graph) : void 0;
+		const result = await this.#layout(graph, arguments_);
+		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), {
+			...arguments_,
+			layoutOptions: {
+				...arguments_.layoutOptions,
+				...strategy
+			}
+		});
+		return measureLayout(uncompacted, true).defects < defects ? uncompacted : result;
+	}
+	async #layout(graph, arguments_ = {}, compoundLayout = false) {
+		const prepared = await this.#prepareLayout(graph, arguments_, compoundLayout);
+		const orders = coordinatePreparedScopes(prepared);
+		return await prepared.finish(orders);
+	}
+	async #prepareLayout(graph, arguments_ = {}, compoundLayout = false) {
+		const startedAt = performance.now();
+		if (graph === void 0 || graph === null) throw new TypeError("Missing mandatory parameter: graph");
+		if (typeof graph.id !== "string" && !(typeof graph.id === "number" && Number.isInteger(graph.id))) throw new TypeError("Graph id must be a string or integer");
+		delete graph.logging;
+		const layoutOptions = {
+			...this.#options.defaultLayoutOptions,
+			...arguments_.layoutOptions,
+			...graph.properties,
+			...graph.layoutOptions
+		};
+		getOption(layoutOptions, "debugMode");
+		getOption(layoutOptions, "interactiveLayout");
+		getOption(layoutOptions, "layered.generatePositionAndLayerIds");
+		getOption(layoutOptions, "topdown.scaleFactor");
+		getOption(layoutOptions, "contentAlignment");
+		for (const child of graph.children ?? []) {
+			const childOptions = child.layoutOptions ?? {};
+			getOption(childOptions, "layered.layering.layerId");
+			getOption(childOptions, "layered.crossingMinimization.positionId");
+			getOption(childOptions, "layered.layering.layerChoiceConstraint");
+			getOption(childOptions, "layered.crossingMinimization.positionChoiceConstraint");
+			getOption(childOptions, "layered.crossingMinimization.inLayerPredOf");
+			getOption(childOptions, "layered.crossingMinimization.inLayerSuccOf");
+			getOption(childOptions, "topdown.scaleFactor");
+			getOption(childOptions, "layered.considerModelOrder.groupModelOrder.componentGroupId");
+			for (const port of child.ports ?? []) getOption(port.layoutOptions ?? {}, "layered.considerModelOrder.groupModelOrder.componentGroupId");
+		}
+		for (const edge of graph.edges ?? []) getOption(edge.layoutOptions ?? {}, "layered.considerModelOrder.groupModelOrder.componentGroupId");
+		const requestedAlgorithm = String(getOption(layoutOptions, "algorithm") ?? "layered");
+		const algorithm = requestedAlgorithm.replace(/^(?:org\.eclipse\.)?elk\./, "");
+		if (algorithm !== "layered" && algorithm !== "box" && algorithm !== "fixed" && algorithm !== "random" && algorithm !== "rectpacking" && algorithm !== "sporeCompaction" && algorithm !== "sporeOverlap") throw new Error(`org.eclipse.elk.core.UnsupportedConfigurationException: Layout algorithm '${requestedAlgorithm}' not found`);
+		const preparedChildren = /* @__PURE__ */ new Map();
+		const finishChildren = [];
+		const hasHierarchy = (graph.children ?? []).some((child) => (child.children?.length ?? 0) > 0);
+		const insideSelfLoopBaseHeightByNodeId = /* @__PURE__ */ new Map();
+		const hierarchyRestorations = [];
+		const boundaryRoutes = /* @__PURE__ */ new Map();
+		const syntheticPortIds = /* @__PURE__ */ new Set();
+		const authoredPortsByCompound = /* @__PURE__ */ new Map();
+		const authoredOptionsByCompound = /* @__PURE__ */ new Map();
+		const originalHierarchyEndpoints = new Map((graph.edges ?? []).map((edge) => [edge, {
+			sourceId: String(edge.sources?.[0] ?? edge.source),
+			targetId: String(edge.targets?.[0] ?? edge.target),
+			sources: edge.sources,
+			targets: edge.targets,
+			source: edge.source,
+			target: edge.target
+		}]));
+		const hierarchyHandling = getOption(layoutOptions, "hierarchyHandling");
+		const topdownLayout = getBooleanOption(layoutOptions, "topdownLayout") === true;
+		const separateHierarchy = hasHierarchy && hierarchyHandling !== void 0 && hierarchyHandling !== "INCLUDE_CHILDREN";
+		if (hasHierarchy && topdownLayout && hierarchyHandling === "INCLUDE_CHILDREN") throw new Error("org.eclipse.elk.core.UnsupportedConfigurationException: Topdown layout cannot be used together with hierarchy handling.");
+		if (separateHierarchy) {
+			const hasCrossHierarchyEdge = (container) => {
+				const directEndpointIds = /* @__PURE__ */ new Set();
+				for (const child of container.children ?? []) {
+					directEndpointIds.add(String(child.id));
+					for (const port of child.ports ?? []) directEndpointIds.add(String(port.id));
+				}
+				if ((container.edges ?? []).some((edge) => {
+					const sourceId = String(edge.sources?.[0] ?? edge.source);
+					const targetId = String(edge.targets?.[0] ?? edge.target);
+					return !directEndpointIds.has(sourceId) || !directEndpointIds.has(targetId);
+				})) return true;
+				return (container.children ?? []).some((child) => hasCrossHierarchyEdge(child));
+			};
+			if (hasCrossHierarchyEdge(graph)) throw new Error("org.eclipse.elk.core.UnsupportedGraphException: Hierarchical edges require INCLUDE_CHILDREN");
+			for (const child of graph.children ?? []) {
+				if ((child.children?.length ?? 0) === 0) continue;
+				await this.#layout(child, {
+					...arguments_,
+					layoutOptions: {
+						...arguments_.layoutOptions,
+						...child.layoutOptions,
+						hierarchyHandling
+					},
+					logging: false,
+					measureExecutionTime: false
+				});
+			}
+		}
+		if (hasHierarchy && topdownLayout) {
+			if (getOption(layoutOptions, "topdown.nodeType") === void 0) throw new Error(`${String(graph.id)} has not been assigned a top-down node type.`);
+			for (const child of graph.children ?? []) {
+				if ((child.children?.length ?? 0) === 0) continue;
+				const childOptions = {
+					...layoutOptions,
+					...child.layoutOptions
+				};
+				const childPadding = parsePadding(getOption(childOptions, "padding"), 12);
+				const parallelNode = getOption(childOptions, "topdown.nodeType") === "PARALLEL_NODE";
+				const width = getNumberOption(childOptions, "topdown.hierarchicalNodeWidth") ?? (parallelNode ? 150 : 0);
+				const aspectRatio = getNumberOption(childOptions, "topdown.hierarchicalNodeAspectRatio") ?? (parallelNode ? 1.414 : 1 / Math.sqrt(2));
+				child.width = Math.max(child.width ?? 0, width + childPadding.left + childPadding.right);
+				child.height = Math.max(child.height ?? 0, width / aspectRatio + childPadding.top + childPadding.bottom);
+			}
+		} else if (hasHierarchy && !separateHierarchy) {
+			const scopeSegmentOrder = segmentOrderByScope.get(graph) ?? elkSegmentOrder(graph, graph, originalHierarchyEndpoints, false);
+			for (const child of graph.children ?? []) {
+				if ((child.children?.length ?? 0) === 0) continue;
+				const descendantOwnerByEndpointId = /* @__PURE__ */ new Map();
+				const collectDescendants = (node) => {
+					for (const descendant of node.children ?? []) {
+						descendantOwnerByEndpointId.set(String(descendant.id), descendant);
+						for (const port of descendant.ports ?? []) descendantOwnerByEndpointId.set(String(port.id), descendant);
+						collectDescendants(descendant);
+					}
+				};
+				collectDescendants(child);
+				const internalEdges = (graph.edges ?? []).filter((edge) => {
+					const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
+					return descendantOwnerByEndpointId.has(sourceId) && descendantOwnerByEndpointId.has(targetId);
+				});
+				for (const edge of child.edges ?? []) if (!originalHierarchyEndpoints.has(edge)) originalHierarchyEndpoints.set(edge, {
+					sourceId: String(edge.sources?.[0] ?? edge.source),
+					targetId: String(edge.targets?.[0] ?? edge.target),
+					sources: edge.sources,
+					targets: edge.targets,
+					source: edge.source,
+					target: edge.target
+				});
+				const crossingEdges = [...graph.edges ?? [], ...child.edges ?? []].filter((edge) => {
+					const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
+					return descendantOwnerByEndpointId.has(sourceId) !== descendantOwnerByEndpointId.has(targetId);
+				});
+				const boundaryRank = new Map(elkBoundaryEdgeOrder(child, graph, originalHierarchyEndpoints).map((edge, index) => [edge, index]));
+				crossingEdges.sort((a, b) => (boundaryRank.get(a) ?? Number.MAX_SAFE_INTEGER) - (boundaryRank.get(b) ?? Number.MAX_SAFE_INTEGER));
+				const mergeHierarchyEdges = getBooleanOption(layoutOptions, "layered.mergeHierarchyEdges") !== false;
+				const proxyByKind = /* @__PURE__ */ new Map();
+				const implicitOwnPorts = /* @__PURE__ */ new Map();
+				const ownPortFor = (edge) => {
+					const e = originalHierarchyEndpoints.get(edge);
+					const outside = descendantOwnerByEndpointId.has(e.sourceId) ? e.targetId : e.sourceId;
+					if (e.sourceId === String(child.id) || e.targetId === String(child.id)) {
+						let port = implicitOwnPorts.get(edge);
+						if (!port) {
+							const direction = getDirection(layoutOptions);
+							const side = e.sourceId === String(child.id) ? {
+								right: "EAST",
+								left: "WEST",
+								down: "SOUTH",
+								up: "NORTH"
+							}[direction] : {
+								right: "WEST",
+								left: "EAST",
+								down: "NORTH",
+								up: "SOUTH"
+							}[direction];
+							port = {
+								id: `__native_hierarchy_own_${String(child.id)}_${implicitOwnPorts.size}`,
+								width: 0,
+								height: 0,
+								layoutOptions: { "elk.port.side": side }
+							};
+							implicitOwnPorts.set(edge, port);
+							syntheticPortIds.add(String(port.id));
+						}
+						return child.ports?.find((p) => p.id === port.id) ?? port;
+					}
+					return child.ports?.find((p) => String(p.id) === outside);
+				};
+				const proxyKey = (kind, edge) => {
+					const own = ownPortFor(edge);
+					if (own) return JSON.stringify(["authored", own.id]);
+					const endpoints = originalHierarchyEndpoints.get(edge);
+					const endpoint$2 = kind === "output" ? endpoints.sourceId : endpoints.targetId;
+					const explicitPort = descendantOwnerByEndpointId.get(endpoint$2)?.ports?.some((port) => String(port.id) === endpoint$2);
+					return JSON.stringify([kind, mergeHierarchyEdges && explicitPort ? endpoint$2 : String(edge.id)]);
+				};
+				const createBoundaryProxy = (key, kind, own, netFlow) => {
+					let proxy = proxyByKind.get(key);
+					if (!proxy) {
+						const direction = getDirection({
+							...layoutOptions,
+							...child.layoutOptions
+						});
+						const authoredAnchor = own ? getElementLayeredSettings(own.layoutOptions ?? {})["port.anchor"] : void 0;
+						const origin = require_layered.createExternalPortDummy({
+							constraints: getOption(child.layoutOptions ?? {}, "portConstraints") ?? "FREE",
+							side: own ? getOption(own.layoutOptions ?? {}, "port.side") ?? (kind === "output" ? "EAST" : "WEST") : kind === "output" ? "EAST" : "WEST",
+							position: {
+								x: own?.x ?? 0,
+								y: own?.y ?? 0
+							},
+							anchor: authoredAnchor,
+							index: own ? getNumberOption(own.layoutOptions ?? {}, "port.index") : void 0,
+							direction: direction.toUpperCase(),
+							netFlow,
+							borderOffset: own ? getNumberOption(own.layoutOptions ?? {}, "port.borderOffset") ?? 0 : (getNumberOption(layoutOptions, "spacing.edgeEdge") ?? 10) / 2,
+							size: {
+								width: own?.width ?? 0,
+								height: own?.height ?? 0
+							}
+						});
+						if (own) origin.parentPortId = String(own.id);
+						const id = `__native_hierarchy_${String(child.id)}_${proxyByKind.size}`;
+						proxy = require_layered.attachExternalPortDummy({
+							id,
+							width: origin.width,
+							height: origin.height,
+							layoutOptions: {
+								"elk.portConstraints": origin.constraints,
+								"elk.layered.layering.layerConstraint": origin.side === {
+									right: "EAST",
+									left: "WEST",
+									down: "SOUTH",
+									up: "NORTH"
+								}[direction] ? "LAST_SEPARATE" : origin.side === {
+									right: "WEST",
+									left: "EAST",
+									down: "NORTH",
+									up: "SOUTH"
+								}[direction] ? "FIRST_SEPARATE" : void 0
+							},
+							ports: [{
+								id: `${id}:boundary`,
+								x: origin.port.x,
+								y: origin.port.y,
+								width: 0,
+								height: 0,
+								layoutOptions: { "elk.port.side": origin.port.side }
+							}]
+						}, origin);
+						proxyByKind.set(key, proxy);
+					}
+					return proxy;
+				};
+				const ownedPortNetFlow = (id) => {
+					let votes = 0;
+					for (const edge of originalHierarchyEndpoints.values()) {
+						if (edge.sourceId === id) votes += descendantOwnerByEndpointId.has(edge.targetId) ? -1 : 1;
+						if (edge.targetId === id) votes += descendantOwnerByEndpointId.has(edge.sourceId) ? 1 : -1;
+					}
+					return votes;
+				};
+				const proxyFor = (kind, edge) => {
+					const own = ownPortFor(edge);
+					const flow = implicitOwnPorts.has(edge) ? kind === "output" ? 1 : -1 : own ? ownedPortNetFlow(String(own.id)) : kind === "output" ? 1 : -1;
+					return createBoundaryProxy(proxyKey(kind, edge), kind, own, flow);
+				};
+				const temporaryEdges = [
+					...crossingEdges.map((edge) => {
+						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],
+							source: void 0,
+							target: void 0,
+							sections: void 0
+						};
+						originalEdgeId.set(segment, originalEdgeId.get(edge) ?? String(edge.id));
+						return segment;
+					}),
+					...(child.edges ?? []).filter((edge) => !crossingEdges.includes(edge)),
+					...internalEdges.filter((edge) => !(child.edges ?? []).some((candidate) => String(candidate.id) === String(edge.id)))
+				];
+				const hasExternalPorts = proxyByKind.size > 0;
+				const inactiveAuthoredPorts = [];
+				if (hasExternalPorts) for (const port of child.ports ?? []) {
+					const key = JSON.stringify(["authored", port.id]);
+					if (proxyByKind.has(key)) continue;
+					const flow = ownedPortNetFlow(String(port.id));
+					inactiveAuthoredPorts.push({
+						port,
+						proxy: createBoundaryProxy(key, flow >= 0 ? "output" : "input", port, flow)
+					});
+				}
+				const outsideNodeEdges = !hasExternalPorts ? [] : (graph.edges ?? []).filter((edge) => {
+					const e = originalHierarchyEndpoints.get(edge);
+					return (e.sourceId === String(child.id) || e.targetId === String(child.id)) && !descendantOwnerByEndpointId.has(e.sourceId) && !descendantOwnerByEndpointId.has(e.targetId);
+				});
+				for (const edge of outsideNodeEdges) proxyFor(originalHierarchyEndpoints.get(edge).sourceId === String(child.id) ? "output" : "input", edge);
+				const temporaryChild = {
+					...child,
+					layoutOptions: proxyByKind.size ? {
+						...child.layoutOptions,
+						"elk.portConstraints": "FIXED_SIDE"
+					} : child.layoutOptions,
+					children: [...child.children ?? [], ...proxyByKind.values()],
+					edges: temporaryEdges
+				};
+				const childSegmentOrder = elkSegmentOrder(child, graph, originalHierarchyEndpoints, true);
+				segmentOrderByScope.set(temporaryChild, childSegmentOrder);
+				for (const edge of temporaryEdges) {
+					const id = originalEdgeId.get(edge);
+					const rank = id === void 0 ? void 0 : childSegmentOrder.get(id);
+					if (rank !== void 0) hierarchySegmentRank.set(edge, rank);
+				}
+				const preparedChild = await this.#prepareLayout(temporaryChild, {
+					...arguments_,
+					layoutOptions: {
+						...arguments_.layoutOptions,
+						direction: getDirection(getOption(child.layoutOptions ?? {}, "direction") === void 0 ? layoutOptions : child.layoutOptions).toUpperCase(),
+						hierarchyHandling: "INCLUDE_CHILDREN"
+					},
+					logging: false,
+					measureExecutionTime: false
+				}, true);
+				preparedChildren.set(String(child.id), preparedChild);
+				authoredPortsByCompound.set(child, child.ports);
+				authoredOptionsByCompound.set(child, child.layoutOptions);
+				const initialPorts = (child.ports ?? []).map((port) => ({
+					...port,
+					layoutOptions: port.layoutOptions ? { ...port.layoutOptions } : void 0
+				}));
+				for (const edge of crossingEdges) {
+					const own = ownPortFor(edge);
+					if (own) {
+						const original$1 = originalHierarchyEndpoints.get(edge);
+						const sourceInside$1 = descendantOwnerByEndpointId.has(original$1.sourceId);
+						const origin$1 = require_layered.externalPortDummyOf(proxyByKind.get(proxyKey(sourceInside$1 ? "output" : "input", edge)));
+						let port = initialPorts.find((p) => p.id === own.id);
+						if (!port) {
+							port = {
+								...own,
+								layoutOptions: { ...own.layoutOptions }
+							};
+							initialPorts.push(port);
+						}
+						port.layoutOptions = {
+							...port.layoutOptions,
+							"elk.port.side": origin$1.side
+						};
+						continue;
+					}
+					const original = originalHierarchyEndpoints.get(edge);
+					const sourceInside = descendantOwnerByEndpointId.has(original.sourceId);
+					const proxy = proxyByKind.get(proxyKey(sourceInside ? "output" : "input", edge));
+					const origin = require_layered.externalPortDummyOf(proxy);
+					const portId = `${String(proxy.id)}:parent`;
+					syntheticPortIds.add(portId);
+					if (!initialPorts.some((port) => port.id === portId)) initialPorts.push({
+						id: portId,
+						width: origin.externalSize.width,
+						height: origin.externalSize.height,
+						x: 0,
+						y: 0,
+						layoutOptions: {
+							"elk.port.side": origin.side,
+							"elk.port.borderOffset": origin.borderOffset
+						}
+					});
+					if (!hierarchyRestorations.some((restoration) => restoration.edge === edge)) hierarchyRestorations.push({
+						edge,
+						...original
+					});
+					if (sourceInside) edge.sources = [portId];
+					else edge.targets = [portId];
+					const rank = scopeSegmentOrder.get(originalEdgeId.get(edge) ?? String(edge.id));
+					if (rank !== void 0) hierarchySegmentRank.set(edge, rank);
+					edge.source = void 0;
+					edge.target = void 0;
+				}
+				for (const { port, proxy } of inactiveAuthoredPorts) {
+					const actual = initialPorts.find((p) => p.id === port.id);
+					actual.layoutOptions = {
+						...actual.layoutOptions,
+						"elk.port.side": require_layered.externalPortDummyOf(proxy).side
+					};
+				}
+				for (const edge of outsideNodeEdges) {
+					const original = originalHierarchyEndpoints.get(edge);
+					const source = original.sourceId === String(child.id);
+					const proxy = proxyFor(source ? "output" : "input", edge), own = ownPortFor(edge);
+					const origin = require_layered.externalPortDummyOf(proxy);
+					if (!initialPorts.some((p) => p.id === own.id)) initialPorts.push({
+						...own,
+						layoutOptions: {
+							...own.layoutOptions,
+							"elk.port.side": origin.side
+						}
+					});
+					if (!hierarchyRestorations.some((r) => r.edge === edge)) hierarchyRestorations.push({
+						edge,
+						...original
+					});
+					if (source) edge.sources = [own.id];
+					else edge.targets = [own.id];
+					edge.source = void 0;
+					edge.target = void 0;
+				}
+				child.ports = initialPorts;
+				child.layoutOptions = {
+					...child.layoutOptions,
+					"elk.portConstraints": crossingEdges.length > 0 || outsideNodeEdges.length > 0 ? "FIXED_SIDE" : getOption(authoredOptionsByCompound.get(child) ?? {}, "portConstraints") ?? "FREE"
+				};
+				finishChildren.push(async () => {
+					await preparedChild.finish(activeOrders);
+					const childPadding = parsePadding(getOption({
+						...layoutOptions,
+						...child.layoutOptions
+					}, "padding"), 12);
+					for (const internalEdge of internalEdges) {
+						const temporary = temporaryEdges.find((candidate) => String(candidate.id) === String(internalEdge.id));
+						if (temporary?.sections) {
+							internalEdge.sections = temporary.sections;
+							internalEdge.container = temporary.container ?? child.id;
+						}
+					}
+					const childDirection = getDirection({
+						...layoutOptions,
+						...child.layoutOptions
+					});
+					const horizontalChild = childDirection === "right" || childDirection === "left";
+					const restoredPerpendicular = [...proxyByKind.values()].some(require_layered.isPerpendicularPortRestored);
+					child.width = restoredPerpendicular ? temporaryChild.width : horizontalChild ? Math.max(0, ...(temporaryChild.children ?? []).map((node) => (node.x ?? 0) + (node.width ?? 0))) + childPadding.right : temporaryChild.width;
+					child.height = restoredPerpendicular ? temporaryChild.height : horizontalChild ? temporaryChild.height : Math.max(0, ...(temporaryChild.children ?? []).map((node) => (node.y ?? 0) + (node.height ?? 0))) + childPadding.bottom;
+					const relativeRect = (id) => {
+						const owner = descendantOwnerByEndpointId.get(id);
+						if (!owner) return void 0;
+						const path = [];
+						const visit = (parent) => {
+							for (const candidate of parent.children ?? []) {
+								path.push(candidate);
+								if (candidate === owner || visit(candidate)) return true;
+								path.pop();
+							}
+							return false;
+						};
+						if (!visit(child)) return void 0;
+						const port = owner.ports?.find((candidate) => String(candidate.id) === id);
+						const ownerX = path.reduce((sum, node) => sum + (node.x ?? 0), 0);
+						const ownerY = path.reduce((sum, node) => sum + (node.y ?? 0), 0);
+						if (port) return {
+							x: ownerX + (port.x ?? 0) + (port.width ?? 0) / 2,
+							y: ownerY + (port.y ?? 0) + (port.height ?? 0) / 2,
+							width: 0,
+							height: 0
+						};
+						return {
+							x: ownerX,
+							y: ownerY,
+							width: path.at(-1)?.width ?? 0,
+							height: path.at(-1)?.height ?? 0
+						};
+					};
+					const ports = (authoredPortsByCompound.get(child) ?? []).map((original) => child.ports?.find((port) => port.id === original.id) ?? original);
+					for (const edge of crossingEdges) {
+						const original = originalHierarchyEndpoints.get(edge);
+						const { sourceId, targetId } = original;
+						const sourceInside = descendantOwnerByEndpointId.has(sourceId);
+						if (!relativeRect(sourceInside ? sourceId : targetId)) continue;
+						const internalEdge = temporaryEdges.find((candidate) => String(candidate.id) === `__native_hierarchy_edge_${String(child.id)}_${String(edge.id)}`);
+						const internalRoute = internalEdge?.sections;
+						const kind = sourceInside ? "output" : "input";
+						const proxy = proxyByKind.get(proxyKey(kind, edge));
+						const origin = require_layered.externalPortDummyOf(proxy);
+						const endpoint$2 = sourceInside ? internalRoute?.at(-1)?.endPoint : internalRoute?.[0]?.startPoint;
+						if (!endpoint$2) throw new Error(`Missing compound boundary route for ${String(edge.id)}`);
+						const transferred = transferExternalPort({
+							contentSize: {
+								width: child.width - childPadding.left - childPadding.right,
+								height: child.height - childPadding.top - childPadding.bottom
+							},
+							padding: childPadding,
+							offset: {
+								x: 0,
+								y: 0
+							},
+							dummy: {
+								x: endpoint$2.x - childPadding.left - (ownPortFor(edge) ? origin.port.x : 0),
+								y: endpoint$2.y - childPadding.top - (ownPortFor(edge) ? origin.port.y : 0),
+								width: origin.width,
+								height: origin.height
+							},
+							side: origin.side,
+							borderOffset: origin.borderOffset,
+							portSize: origin.externalSize
+						});
+						const points = internalRoute.flatMap((section, index) => [
+							...index === 0 ? [section.startPoint] : [],
+							...section.bendPoints ?? [],
+							section.endPoint
+						]).map((point) => ({ ...point }));
+						const boundary = sourceInside ? points.at(-1) : points[0];
+						boundary.x = transferred.dummy.x + childPadding.left;
+						boundary.y = transferred.dummy.y + childPadding.top;
+						const own = ownPortFor(edge);
+						if (own) {
+							if (implicitOwnPorts.has(edge) && !ports.some((p) => p.id === own.id)) ports.push(own);
+							own.x = transferred.port.x;
+							own.y = transferred.port.y;
+							const anchor = getElementLayeredSettings(own.layoutOptions ?? {})["port.anchor"] ?? {
+								x: origin.side === "EAST" ? own.width ?? 0 : origin.side === "WEST" ? 0 : (own.width ?? 0) / 2,
+								y: origin.side === "SOUTH" ? own.height ?? 0 : origin.side === "NORTH" ? 0 : (own.height ?? 0) / 2
+							};
+							boundary.x = own.x + anchor.x;
+							boundary.y = own.y + anchor.y;
+							edge.sections = [{
+								id: `${String(edge.id)}_s0`,
+								startPoint: points[0],
+								endPoint: points.at(-1),
+								...points.length > 2 ? { bendPoints: points.slice(1, -1) } : {},
+								incomingShape: sourceId,
+								outgoingShape: targetId
+							}];
+							if (internalEdge?.junctionPoints?.length) edge.junctionPoints = internalEdge.junctionPoints.map((point) => ({ ...point }));
+							else delete edge.junctionPoints;
+							edge.container = child.id;
+							continue;
+						}
+						const routes = boundaryRoutes.get(edge) ?? {};
+						routes[sourceInside ? "source" : "target"] = {
+							owner: child,
+							points,
+							junctionPoints: internalEdge?.junctionPoints
+						};
+						boundaryRoutes.set(edge, routes);
+						const portId = `${String(proxy.id)}:parent`;
+						syntheticPortIds.add(portId);
+						if (!ports.some((port) => port.id === portId)) ports.push({
+							id: portId,
+							width: origin.externalSize.width,
+							height: origin.externalSize.height,
+							x: transferred.port.x,
+							y: transferred.port.y,
+							layoutOptions: {
+								"elk.port.side": origin.side,
+								"elk.port.borderOffset": origin.borderOffset
+							}
+						});
+						if (!hierarchyRestorations.some((restoration) => restoration.edge === edge)) hierarchyRestorations.push({
+							edge,
+							...original
+						});
+						if (sourceInside) edge.sources = [portId];
+						else edge.targets = [portId];
+						edge.source = void 0;
+						edge.target = void 0;
+					}
+					for (const { port, proxy } of inactiveAuthoredPorts) {
+						const origin = require_layered.externalPortDummyOf(proxy);
+						const actual = ports.find((p) => p.id === port.id);
+						const transferred = transferExternalPort({
+							contentSize: {
+								width: child.width - childPadding.left - childPadding.right,
+								height: child.height - childPadding.top - childPadding.bottom
+							},
+							padding: childPadding,
+							offset: {
+								x: 0,
+								y: 0
+							},
+							dummy: {
+								x: (proxy.x ?? 0) - childPadding.left,
+								y: (proxy.y ?? 0) - childPadding.top,
+								width: origin.width,
+								height: origin.height
+							},
+							side: origin.side,
+							borderOffset: origin.borderOffset,
+							portSize: origin.externalSize
+						});
+						actual.x = transferred.port.x;
+						actual.y = transferred.port.y;
+					}
+					for (const edge of outsideNodeEdges) {
+						const proxy = proxyFor(originalHierarchyEndpoints.get(edge).sourceId === String(child.id) ? "output" : "input", edge), origin = require_layered.externalPortDummyOf(proxy), own = ownPortFor(edge);
+						const transferred = transferExternalPort({
+							contentSize: {
+								width: child.width - childPadding.left - childPadding.right,
+								height: child.height - childPadding.top - childPadding.bottom
+							},
+							padding: childPadding,
+							offset: {
+								x: 0,
+								y: 0
+							},
+							dummy: {
+								x: (proxy.x ?? 0) - childPadding.left,
+								y: (proxy.y ?? 0) - childPadding.top,
+								width: origin.width,
+								height: origin.height
+							},
+							side: origin.side,
+							borderOffset: origin.borderOffset,
+							portSize: origin.externalSize
+						});
+						own.x = transferred.port.x;
+						own.y = transferred.port.y;
+						if (!ports.some((p) => p.id === own.id)) ports.push(own);
+					}
+					child.ports = ports;
+					child.layoutOptions = {
+						...child.layoutOptions,
+						"elk.portConstraints": "FIXED_POS"
+					};
+					const insideLoopCount = (graph.edges ?? []).filter((edge) => isInsideSelfLoop(graph, edge, String(child.id))).length;
+					if (insideLoopCount > 0) {
+						const baseHeight = child.height ?? 0;
+						insideSelfLoopBaseHeightByNodeId.set(String(child.id), baseHeight);
+						child.height = baseHeight + insideLoopCount * 11;
+					}
+				});
+			}
+		}
+		applyNodeMicroLayout(graph, layoutOptions);
+		const graph_ = toGraph(graph, layoutOptions);
+		const hierarchyProxyIds = new Set((graph.children ?? []).filter((node) => String(node.id).startsWith("__native_hierarchy_")).map((node) => String(node.id)));
+		const layerConstraintByNodeId = new Map((graph.children ?? []).map((node) => [String(node.id), String(getOption(node.layoutOptions ?? {}, "layered.layering.layerConstraint") ?? getOption(node.layoutOptions ?? {}, "layerConstraint") ?? "NONE")]));
+		if (algorithm === "layered" && graph_.edges.some((edge) => {
+			if (edge.sourceId === edge.targetId) return false;
+			if (hierarchyProxyIds.has(edge.sourceId) || hierarchyProxyIds.has(edge.targetId)) return false;
+			const sourceConstraint = layerConstraintByNodeId.get(edge.sourceId);
+			const targetConstraint = layerConstraintByNodeId.get(edge.targetId);
+			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 options = {
+			direction: getDirection(layoutOptions),
+			spacing: {
+				node: getNumberOption(layoutOptions, "spacing.nodeNode") ?? getNumberOption(layoutOptions, "layered.spacing.baseValue"),
+				layer: getNumberOption(layoutOptions, "layered.spacing.nodeNodeBetweenLayers") ?? getNumberOption(layoutOptions, "layered.spacing.baseValue") ?? 20
+			},
+			padding,
+			constraints: { layer: () => void 0 },
+			settings: {
+				...getLayeredSettings(layoutOptions),
+				...arguments_[crossingModel] ? { [require_layered.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 ?? {});
+			},
+			edgeSettings: (edge) => {
+				const elkEdge = findById(graph.edges, edge.id)?.item;
+				return {
+					...getElementLayeredSettings(elkEdge?.layoutOptions ?? {}),
+					...getElementLayeredSettings(elkEdge?.labels?.[0]?.layoutOptions ?? {}),
+					"edge.hierarchyRank": elkEdge && hierarchySegmentRank.get(elkEdge)
+				};
+			},
+			portSettings: (port, node) => {
+				const child = findById(graph.children, node.id)?.item;
+				const found = findById(child?.ports, port.name);
+				const elkPort = found?.item;
+				return {
+					...getElementLayeredSettings(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))
+				};
+			}
+		};
+		const pipeline = algorithm === "layered" ? require_layered.createLayeredScopePipeline(graph_, options) : void 0;
+		const initial = pipeline?.next();
+		const phase = initial && !initial.done ? initial.value : void 0;
+		let activeOrders;
+		let finished;
+		const prepared = {
+			graph,
+			native: graph_,
+			phase,
+			options,
+			children: preparedChildren,
+			finish: (orders) => {
+				if (finished) return finished;
+				activeOrders = orders;
+				finished = finish();
+				return finished;
+			}
+		};
+		const finishLayered = () => {
+			if (!pipeline || !initial) throw new Error("Missing layered pipeline");
+			if (initial.done) return initial.value;
+			const completed = pipeline.next(activeOrders?.has(prepared) ? initial.value.finishOrder(activeOrders.get(prepared)) : initial.value.minimize());
+			if (!completed.done) throw new Error("Layered scope yielded more than one crossing phase");
+			return completed.value;
+		};
+		const finish = async () => {
+			for (const complete of finishChildren) await complete();
+			for (const nativeGraph of new Set([graph_, phase?.input.graph].filter((value) => value !== void 0))) for (const child of graph.children ?? []) {
+				const native = nativeGraph.nodes.find((node) => node.id === String(child.id));
+				if (!native || !preparedChildren.has(String(child.id))) continue;
+				phase?.updateNodeSize(native.id, {
+					width: child.width ?? 0,
+					height: child.height ?? 0
+				});
+				Object.assign(native, {
+					width: child.width,
+					height: child.height
+				});
+				for (const port of native.ports ?? []) {
+					const actual = child.ports?.find((candidate) => String(candidate.id) === port.name);
+					if (actual) Object.assign(port, {
+						x: actual.x,
+						y: actual.y,
+						width: actual.width,
+						height: actual.height
+					});
+				}
+			}
+			const laidOut = await (algorithm === "sporeCompaction" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "sporeCompaction",
+				graph: graph_,
+				options: {
+					padding,
+					spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
+				}
+			}) : algorithm === "sporeOverlap" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "sporeOverlap",
+				graph: graph_,
+				options: {
+					padding,
+					spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
+				}
+			}) : algorithm === "rectpacking" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "rectpacking",
+				graph: graph_,
+				options: {
+					padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
+					spacing: getNumberOption(layoutOptions, "spacing.nodeNode") ?? 15
+				}
+			}) : algorithm === "random" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "random",
+				graph: graph_,
+				options: {
+					padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
+					spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
+					aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
+					seed: getNumberOption(layoutOptions, "randomSeed")
+				}
+			}) : algorithm === "box" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "box",
+				graph: graph_,
+				options: {
+					padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
+					spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
+					aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
+					interactive: getBooleanOption(layoutOptions, "interactive"),
+					expandNodes: getBooleanOption(layoutOptions, "expandNodes"),
+					priority: (node) => {
+						const child = graph.children?.find((candidate) => String(candidate.id) === node.id);
+						return getNumberOption(child?.layoutOptions ?? {}, "priority");
+					}
+				}
+			}) : algorithm === "fixed" ? require_layout_engine.executeElkjs0111Layout({
+				algorithm: "fixed",
+				graph: graph_,
+				options: { direction: getDirection(layoutOptions) }
+			}) : finishLayered());
+			const resultPolicy = laidOut[require_layered.elkjs0111ResultPolicy];
+			applyLayout(graph, laidOut, padding, layoutOptions, resultPolicy);
+			if (resultPolicy?.providerBounds) {
+				graph.width = resultPolicy.providerBounds.width;
+				graph.height = resultPolicy.providerBounds.height;
+			}
+			for (const restoration of hierarchyRestorations) {
+				const splits = boundaryRoutes.get(restoration.edge);
+				const sections = restoration.edge.sections;
+				if (splits && sections?.length) {
+					const parentPoints = sections.flatMap((section, index) => [
+						...index === 0 ? [section.startPoint] : [],
+						...section.bendPoints ?? [],
+						section.endPoint
+					]);
+					const points = joinCompoundRouteSegments([
+						...splits.source ? [{
+							points: splits.source.points,
+							offset: {
+								x: splits.source.owner.x ?? 0,
+								y: splits.source.owner.y ?? 0
+							}
+						}] : [],
+						{
+							points: parentPoints,
+							offset: {
+								x: 0,
+								y: 0
+							}
+						},
+						...splits.target ? [{
+							points: splits.target.points,
+							offset: {
+								x: splits.target.owner.x ?? 0,
+								y: splits.target.owner.y ?? 0
+							}
+						}] : []
+					], getBooleanOption(layoutOptions, "unnecessaryBendpoints") === true);
+					const childJunctions = (split) => (split?.junctionPoints ?? []).map((point) => ({
+						x: point.x + (split?.owner.x ?? 0),
+						y: point.y + (split?.owner.y ?? 0)
+					}));
+					const junctions = [
+						...childJunctions(splits.source),
+						...restoration.edge.junctionPoints ?? [],
+						...childJunctions(splits.target)
+					];
+					if (junctions.length) restoration.edge.junctionPoints = junctions;
+					else delete restoration.edge.junctionPoints;
+					restoration.edge.sections = [{
+						...sections[0],
+						startPoint: points[0],
+						endPoint: points.at(-1),
+						bendPoints: points.slice(1, -1)
+					}];
+				}
+				restoration.edge.sources = restoration.sources;
+				restoration.edge.targets = restoration.targets;
+				restoration.edge.source = restoration.source;
+				restoration.edge.target = restoration.target;
+				for (const section of restoration.edge.sections ?? []) {
+					if (section.incomingShape != null && syntheticPortIds.has(String(section.incomingShape))) section.incomingShape = restoration.sources?.[0] ?? restoration.source;
+					if (section.outgoingShape != null && syntheticPortIds.has(String(section.outgoingShape))) section.outgoingShape = restoration.targets?.[0] ?? restoration.target;
+				}
+			}
+			for (const [compound, ports] of authoredPortsByCompound) {
+				for (const port of ports ?? []) {
+					const actual = compound.ports?.find((p) => p.id === port.id);
+					if (actual) Object.assign(port, {
+						x: actual.x,
+						y: actual.y,
+						width: actual.width,
+						height: actual.height
+					});
+				}
+				compound.ports = ports;
+			}
+			for (const [compound, options_] of authoredOptionsByCompound) compound.layoutOptions = options_;
+			if (hasHierarchy && topdownLayout) for (const child of graph.children ?? []) {
+				if ((child.children?.length ?? 0) === 0) continue;
+				const position = {
+					x: child.x,
+					y: child.y
+				};
+				await this.#layout(child, {
+					...arguments_,
+					logging: false,
+					measureExecutionTime: false
+				});
+				child.x = position.x;
+				child.y = position.y;
+			}
+			applyInsideSelfLoops(graph, insideSelfLoopBaseHeightByNodeId);
+			if (arguments_.logging || arguments_.measureExecutionTime) graph.logging = {
+				name: "Native TypeScript layout",
+				children: [{ name: String(algorithm) }],
+				...arguments_.measureExecutionTime ? { executionTime: (performance.now() - startedAt) / 1e3 } : {}
+			};
+			return graph;
+		};
+		return prepared;
+	}
+};
+/** Move opposite-direction track sharing apart on the finished layout. */
+function separated(graph, options) {
+	separateElkOpposingTracks(graph, {
+		...options,
+		...graph.layoutOptions
+	});
+	return graph;
+}
+function coordinatePreparedScopes(root) {
+	if (!root.phase || root.children.size === 0) return void 0;
+	const prepared = [root];
+	for (let i = 0; i < prepared.length; i++) prepared.push(...prepared[i].children.values());
+	if (prepared.some((scope) => !scope.phase || !["LAYER_SWEEP", "MEDIAN_LAYER_SWEEP"].includes(scope.options?.settings?.["crossingMinimization.strategy"] ?? "LAYER_SWEEP"))) return void 0;
+	const scopes = /* @__PURE__ */ new Map();
+	for (const scope of prepared) {
+		const phase = scope.phase;
+		scopes.set(scope, {
+			session: require_layered.createLayerSweepSession(phase.input, phase.orientation, phase.assignment, scope.options?.settings?.["crossingMinimization.strategy"] === "MEDIAN_LAYER_SWEEP" ? "median" : "mean", 7, { resetSeed: scope === root }),
+			childrenByNodeId: /* @__PURE__ */ new Map(),
+			useBottomUp: true,
+			independentRandom: scope !== root
+		});
+	}
+	for (const parent of prepared) {
+		const parentScope = scopes.get(parent);
+		for (const [id, child] of parent.children) {
+			const nativeParent = parent.phase.input.graph.nodes.find((node) => node.id === id);
+			const parentPortOrderFixed = [
+				"FIXED_ORDER",
+				"FIXED_POS",
+				"FIXED_RATIO"
+			].includes(parent.phase.input.nodeSettings?.(nativeParent)?.portConstraints ?? "FREE");
+			const ports = nativeParent.ports ?? [];
+			const childPhase = child.phase;
+			const childSession = scopes.get(child).session;
+			const childNodeById = /* @__PURE__ */ new Map();
+			for (const node of childPhase.input.graph.nodes) if (!childNodeById.has(node.id)) childNodeById.set(node.id, node);
+			const parentEdgeById = /* @__PURE__ */ new Map();
+			for (const edge of parent.phase.input.graph.edges) if (!parentEdgeById.has(edge.id)) parentEdgeById.set(edge.id, edge);
+			const flowSides = require_layered.hierarchicalPortSides(parent.phase.input);
+			const inputPorts = ports.filter((port) => parent.phase.input.portSettings?.(port, nativeParent)?.["port.side"] === flowSides.before).length;
+			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, childSession.crossingGraph(), {
+					portOrderFixed: parentPortOrderFixed,
+					inputPorts,
+					outputPorts,
+					deterministic: child.options?.settings?.["crossingMinimization.strategy"] === "MEDIAN_LAYER_SWEEP"
+				}),
+				alignBoundary: (forward) => {
+					const childLayers = childSession.currentLayers();
+					const layerIndex = forward ? 0 : childLayers.length - 1;
+					const layer = childLayers[layerIndex];
+					if (!layer.every((id$1) => require_layered.externalPortDummyOf(childNodeById.get(id$1)))) return false;
+					const physical = parentScope.session.physicalPortOrder(id);
+					const dummyByParentPort = new Map(childPhase.input.graph.nodes.filter((n) => require_layered.externalPortDummyOf(n)).map((n) => [require_layered.externalPortDummyOf(n).parentPortId ?? `${n.id}:parent`, n.id]));
+					const ordered = physical.flatMap((portId) => {
+						const [nodeId, portName] = JSON.parse(portId);
+						const dummy = nodeId === id ? dummyByParentPort.get(portName) : void 0;
+						return dummy && layer.includes(dummy) ? [dummy] : [];
+					});
+					if (forward) ordered.reverse();
+					const unique = [...new Set(ordered)];
+					if (unique.length !== layer.length) throw new Error(`Incomplete hierarchical port order for ${id}`);
+					childSession.replaceLayer(layerIndex, unique);
+					return true;
+				},
+				publishBoundary: (forward) => {
+					const childLayers = childSession.currentLayers();
+					const layer = childLayers[forward ? childLayers.length - 1 : 0];
+					if (!layer.every((id$1) => require_layered.externalPortDummyOf(childNodeById.get(id$1)))) return;
+					const rank = new Map(layer.map((dummy, index) => [require_layered.externalPortDummyOf(childNodeById.get(dummy)).parentPortId ?? `${dummy}:parent`, index]));
+					const physical = parentScope.session.physicalPortOrder(id);
+					const boundarySlots = physical.flatMap((portId, index) => {
+						const [nodeId, portName] = JSON.parse(portId);
+						return nodeId === id && rank.has(portName) ? [index] : [];
+					});
+					const boundaryPorts = boundarySlots.map((index) => physical[index]).sort((a, b) => {
+						const portA = JSON.parse(a)[1];
+						const portB = JSON.parse(b)[1];
+						const result = rank.get(portA) - rank.get(portB);
+						return forward ? result : -result;
+					});
+					const updatedPhysical = [...physical];
+					boundarySlots.forEach((slot, index) => {
+						updatedPhysical[slot] = boundaryPorts[index];
+					});
+					const edgePortRank = (edgeId) => {
+						const edge = parentEdgeById.get(edgeId);
+						const portName = edge.sourceId === id ? edge.sourcePort : edge.targetPort;
+						return updatedPhysical.indexOf(JSON.stringify([id, portName]));
+					};
+					const { incoming, outgoing } = parentScope.session.edgeOrders(id);
+					const byPort = (current) => [...current].sort((a, b) => edgePortRank(a) - edgePortRank(b));
+					parentScope.session.reorderNodePorts(id, updatedPhysical, byPort(incoming), byPort(outgoing));
+				}
+			};
+			childScope.publishBottomUp = () => {
+				childScope.publishBoundary(true);
+				childScope.publishBoundary(false);
+				parentScope.session.lockPortOrder(id);
+			};
+			scopes.set(child, childScope);
+			parentScope.childrenByNodeId.set(id, childScope);
+		}
+	}
+	const orders = require_layered.minimizeHierarchyCrossings(scopes.get(root));
+	return new Map(prepared.map((scope) => [scope, orders.get(scopes.get(scope))]));
+}
+function parsePadding(value, fallback = 0) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	if (typeof value !== "string") return {
+		top: fallback,
+		right: fallback,
+		bottom: fallback,
+		left: fallback
+	};
+	const padding = {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	for (const match of value.matchAll(/(top|right|bottom|left)\s*=\s*(-?\d+(?:\.\d+)?)/g)) {
+		const side = match[1];
+		padding[side] = Number(match[2]);
+	}
+	return padding;
+}
+function parseVector(value) {
+	if (typeof value === "object" && value !== null && "x" in value && "y" in value) return {
+		x: Number(value.x),
+		y: Number(value.y)
+	};
+	if (typeof value !== "string") return void 0;
+	const match = value.match(/^\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*$/);
+	return match ? {
+		x: Number(match[1]),
+		y: Number(match[2])
+	} : void 0;
+}
+function applyNodeMicroLayout(graph, globalOptions) {
+	const labelPadding = parsePadding(getOption(globalOptions, "nodeLabels.padding"), 5);
+	for (const node of graph.children ?? []) {
+		const constraints = String(getOption(node.layoutOptions ?? {}, "nodeSize.constraints") ?? "");
+		if (!constraints) continue;
+		const configuredSizeOptions = getOption(node.layoutOptions ?? {}, "nodeSize.options");
+		const sizeOptions = new Set(configuredSizeOptions === void 0 ? ["DEFAULT_MINIMUM_SIZE"] : String(configuredSizeOptions).split(/[\s,;]+/).filter(Boolean));
+		const effectivelyFixedPortLabelSize = constraints.includes("PORT_LABELS") && !constraints.includes("NODE_LABELS") && !constraints.includes("MINIMUM_SIZE");
+		const preserveComputedCompoundSize = (node.children?.length ?? 0) > 0;
+		let width = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.width ?? 0 : 0;
+		let height = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.height ?? 0 : 0;
+		let insideHorizontalInset = 0;
+		let insideVerticalInset = 0;
+		const insideLabelCells = /* @__PURE__ */ new Map();
+		if (constraints.includes("PORTS")) {
+			const spacing = getNumberOption(globalOptions, "spacing.portPort") ?? 10;
+			const sideCounts = {
+				NORTH: 0,
+				EAST: 0,
+				SOUTH: 0,
+				WEST: 0
+			};
+			for (const port of node.ports ?? []) {
+				const side = String(getOption(port.layoutOptions ?? {}, "port.side") ?? "EAST");
+				if (side in sideCounts) sideCounts[side]++;
+			}
+			const nodeId = String(node.id);
+			for (const edge of graph.edges ?? []) {
+				const source = String(edge.sources?.[0] ?? edge.source);
+				const target = String(edge.targets?.[0] ?? edge.target);
+				if (source === nodeId) sideCounts.EAST++;
+				if (target === nodeId) sideCounts.WEST++;
+			}
+			width = Math.max(width, (Math.max(sideCounts.NORTH, sideCounts.SOUTH) + 1) * spacing);
+			height = Math.max(height, (Math.max(sideCounts.EAST, sideCounts.WEST) + 1) * spacing);
+			if (!preserveComputedCompoundSize && sideCounts.NORTH === 0 && sideCounts.SOUTH === 0) width = 0;
+			if (!preserveComputedCompoundSize && sideCounts.EAST === 0 && sideCounts.WEST === 0) height = 0;
+		}
+		if (constraints.includes("NODE_LABELS")) {
+			for (const label of node.labels ?? []) {
+				if (!label.text) continue;
+				const placement = String(getOption({
+					...globalOptions,
+					...node.layoutOptions,
+					...label.layoutOptions
+				}, "nodeLabels.placement") ?? "");
+				if (!placement) continue;
+				const labelWidth = label.width ?? 0;
+				const labelHeight = label.height ?? 0;
+				if (placement.includes("OUTSIDE")) {
+					if (!sizeOptions.has("OUTSIDE_NODE_LABELS_OVERHANG")) width = Math.max(width, labelWidth);
+				} else {
+					width = Math.max(width, labelWidth + labelPadding.left + labelPadding.right);
+					const verticalInset = labelHeight * (placement.includes("V_CENTER") ? 1 : 2) + labelPadding.top + labelPadding.bottom;
+					height = Math.max(height, verticalInset);
+					insideHorizontalInset = Math.max(insideHorizontalInset, labelPadding.left + labelPadding.right);
+					insideVerticalInset = Math.max(insideVerticalInset, verticalInset);
+					const key = `${placement.includes("V_CENTER") ? "center" : placement.includes("V_BOTTOM") ? "bottom" : "top"}:${placement.includes("H_CENTER") ? "center" : placement.includes("H_RIGHT") ? "right" : "left"}`;
+					const cell = insideLabelCells.get(key) ?? {
+						width: 0,
+						height: 0
+					};
+					cell.width = Math.max(cell.width, labelWidth);
+					cell.height += labelHeight;
+					insideLabelCells.set(key, cell);
+				}
+			}
+			if (insideLabelCells.size > 0) {
+				const rows = [
+					"top",
+					"center",
+					"bottom"
+				];
+				const columns = [
+					"left",
+					"center",
+					"right"
+				];
+				const cellWidth = (row, column) => insideLabelCells.get(`${row}:${column}`)?.width ?? 0;
+				const forceTabular = sizeOptions.has("FORCE_TABULAR_NODE_LABELS");
+				const asymmetrical = sizeOptions.has("ASYMMETRICAL");
+				const globalColumns = columns.map((column) => Math.max(...rows.map((row) => cellWidth(row, column))));
+				const labelGridWidth = forceTabular ? globalColumns.reduce((sum, value) => sum + value, 0) : Math.max(...rows.map((row) => {
+					const left = cellWidth(row, "left");
+					const center = cellWidth(row, "center");
+					const right = cellWidth(row, "right");
+					return asymmetrical ? left + center + right : 2 * Math.max(left, right) + center;
+				}));
+				const labelGridHeight = rows.reduce((sum, row) => sum + Math.max(...columns.map((column) => insideLabelCells.get(`${row}:${column}`)?.height ?? 0)), 0);
+				width = Math.max(width, labelGridWidth + labelPadding.left + labelPadding.right);
+				height = Math.max(height, labelGridHeight + labelPadding.top + labelPadding.bottom);
+			}
+		}
+		if (constraints.includes("MINIMUM_SIZE")) {
+			const configuredMinimum = parseVector(getOption(node.layoutOptions ?? {}, "nodeSize.minimum"));
+			const minimum = {
+				x: configuredMinimum?.x && configuredMinimum.x > 0 ? configuredMinimum.x : sizeOptions.has("DEFAULT_MINIMUM_SIZE") ? 20 : 0,
+				y: configuredMinimum?.y && configuredMinimum.y > 0 ? configuredMinimum.y : sizeOptions.has("DEFAULT_MINIMUM_SIZE") ? 20 : 0
+			};
+			if (sizeOptions.has("MINIMUM_SIZE_ACCOUNTS_FOR_PADDING")) {
+				width = Math.max(width, minimum.x + insideHorizontalInset);
+				height = Math.max(height, minimum.y + insideVerticalInset);
+			} else {
+				width = Math.max(width, minimum.x);
+				height = Math.max(height, minimum.y);
+			}
+		}
+		sizeOptions.has("COMPUTE_PADDING");
+		node.width = width;
+		node.height = height;
+	}
+}
+function getOption(options, suffix) {
+	const 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([
+	"direction",
+	"padding",
+	"spacing.node",
+	"spacing.layer"
+]);
+function coerceLayeredOptionValue(value, type) {
+	if (type === "BOOLEAN") {
+		if (typeof value === "boolean") return value;
+		if (typeof value === "string") return value.toLowerCase() === "true";
+	}
+	if (type === "DOUBLE" || type === "INT") {
+		if (typeof value === "number") return value;
+		if (typeof value === "string" && value.trim() !== "") return Number(value);
+	}
+	return value;
+}
+function parseIndividualSpacing(value) {
+	if (typeof value === "object" && value !== null) return value;
+	if (typeof value !== "string") return value;
+	const result = {};
+	for (const entry of value.split(/;,;|;/)) {
+		const match = entry.match(/^\s*(?:org\.eclipse\.elk\.)?(?:layered\.)?([^:]+)\s*:\s*(-?\d+(?:\.\d+)?)\s*$/);
+		if (!match) continue;
+		const sourceName = match[1];
+		const definition = require_layered.elkLayeredOptionDefinitions.find((candidate) => {
+			const suffix = candidate.elkId.replace(/^org\.eclipse\.elk\./, "");
+			return candidate.name === sourceName || suffix === sourceName;
+		});
+		if (definition) result[definition.name] = Number(match[2]);
+	}
+	return result;
+}
+function parseMargin(value) {
+	if (typeof value === "object" && value !== null) return value;
+	if (typeof value !== "string") return value;
+	return parsePadding(value, 0);
+}
+const layeredOptionAliases = /* @__PURE__ */ new Map();
+for (const definition of require_layered.elkLayeredOptionDefinitions) {
+	const suffix = definition.elkId.replace(/^org\.eclipse\.elk\./, "");
+	[
+		definition.name,
+		suffix,
+		`elk.${suffix}`,
+		definition.elkId
+	].forEach((key, rank) => {
+		const current = layeredOptionAliases.get(key);
+		if (!current || rank < current.rank) layeredOptionAliases.set(key, {
+			definition,
+			rank
+		});
+	});
+}
+const indexByIdCache = /* @__PURE__ */ new WeakMap();
+/** First element whose stringified id matches, like `find`, via a per-array index. */
+function findById(items, id) {
+	if (!items) return void 0;
+	let cached = indexByIdCache.get(items);
+	if (!cached || cached.length !== items.length) {
+		const index = /* @__PURE__ */ new Map();
+		items.forEach((item, position$1) => {
+			const key = String(item.id);
+			if (!index.has(key)) index.set(key, position$1);
+		});
+		indexByIdCache.set(items, cached = {
+			length: items.length,
+			index
+		});
+	}
+	const position = cached.index.get(id);
+	return position === void 0 ? void 0 : {
+		item: items[position],
+		position
+	};
+}
+function getElementLayeredSettings(options) {
+	const settings = {};
+	const chosen = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(options)) {
+		const alias = layeredOptionAliases.get(key);
+		if (!alias || value === void 0) continue;
+		const current = chosen.get(alias.definition);
+		if (!current || alias.rank < current.rank) chosen.set(alias.definition, {
+			rank: alias.rank,
+			value
+		});
+	}
+	for (const [definition, { value }] of chosen) {
+		const vectorMatch = definition.name === "port.anchor" && typeof value === "string" ? value.match(/^\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*$/) : void 0;
+		settings[definition.name] = vectorMatch ? {
+			x: Number(vectorMatch[1]),
+			y: Number(vectorMatch[2])
+		} : definition.name === "spacing.individual" ? parseIndividualSpacing(value) : definition.name === "spacing.portsSurrounding" ? parseMargin(value) : coerceLayeredOptionValue(value, definition.type);
+	}
+	return settings;
+}
+function getLayeredSettings(options) {
+	const settings = getElementLayeredSettings(options);
+	const baseValue = settings["spacing.baseValue"];
+	if (baseValue !== void 0) for (const [name, defaultValue] of [
+		["spacing.componentComponent", 20],
+		["spacing.edgeEdge", 10],
+		["spacing.edgeLabel", 2],
+		["spacing.edgeNode", 10],
+		["spacing.labelLabel", 0],
+		["spacing.labelNode", 5],
+		["spacing.labelPortHorizontal", 1],
+		["spacing.labelPortVertical", 1],
+		["spacing.nodeSelfLoop", 10],
+		["spacing.portPort", 10],
+		["spacing.edgeEdgeBetweenLayers", 10],
+		["spacing.edgeNodeBetweenLayers", 10]
+	]) settings[name] ??= baseValue * defaultValue / 20;
+	for (const name of ergonomicallyMappedLayeredSettings) delete settings[name];
+	return settings;
+}
+function getNumberOption(options, suffix) {
+	const value = getOption(options, suffix);
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+}
+function getBooleanOption(options, suffix) {
+	const value = getOption(options, suffix);
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (value.toLowerCase() === "true") return true;
+		if (value.toLowerCase() === "false") return false;
+	}
+}
+function getDirection(options) {
+	const direction = String(getOption(options, "direction") ?? "RIGHT").toLowerCase();
+	return direction === "up" || direction === "left" || direction === "down" ? direction : "right";
+}
+function endpoint(value, portOwnerById) {
+	const id = String(value);
+	const ownerId = portOwnerById.get(id);
+	return ownerId === void 0 ? { nodeId: id } : {
+		nodeId: ownerId,
+		port: id
+	};
+}
+function isInsideSelfLoop(root, edge, expectedNodeId) {
+	const source = String(edge.sources?.[0] ?? edge.source);
+	if (source !== String(edge.targets?.[0] ?? edge.target) || expectedNodeId !== void 0 && source !== expectedNodeId) return false;
+	const node = root.children?.find((child) => String(child.id) === source);
+	return getBooleanOption(node?.layoutOptions ?? {}, "insideSelfLoops.activate") === true && getBooleanOption(edge.layoutOptions ?? {}, "insideSelfLoops.yo") === true;
+}
+function applyInsideSelfLoops(root, baseHeightByNodeId) {
+	const indexByNodeId = /* @__PURE__ */ new Map();
+	for (const edge of root.edges ?? []) {
+		if (!isInsideSelfLoop(root, edge)) continue;
+		const nodeId = String(edge.sources?.[0] ?? edge.source);
+		const node = root.children?.find((child) => String(child.id) === nodeId);
+		const baseHeight = baseHeightByNodeId.get(nodeId);
+		if (!node || baseHeight === void 0) continue;
+		const index = indexByNodeId.get(nodeId) ?? 0;
+		indexByNodeId.set(nodeId, index + 1);
+		const y = (node.y ?? 0) + baseHeight - 2 + index * 11;
+		edge.sections = [{
+			id: `${String(edge.id)}_s0`,
+			startPoint: {
+				x: node.x ?? 0,
+				y
+			},
+			endPoint: {
+				x: (node.x ?? 0) + (node.width ?? 0),
+				y
+			},
+			incomingShape: edge.sources?.[0] ?? edge.source,
+			outgoingShape: edge.targets?.[0] ?? edge.target
+		}];
+	}
+}
+function toGraph(root, globalOptions = {}) {
+	const children = (root.children ?? []).filter((child) => getBooleanOption(child.layoutOptions ?? {}, "noLayout") !== true);
+	const nodeIds = new Set(children.map((child) => String(child.id)));
+	const portOwnerById = /* @__PURE__ */ new Map();
+	for (const child of children) for (const port of child.ports ?? []) if (port.id !== void 0) portOwnerById.set(String(port.id), String(child.id));
+	const sourcePortIds = new Set((root.edges ?? []).flatMap((edge) => (edge.sources ?? (edge.source === void 0 ? [] : [edge.source])).map(String)));
+	const targetPortIds = new Set((root.edges ?? []).flatMap((edge) => (edge.targets ?? (edge.target === void 0 ? [] : [edge.target])).map(String)));
+	const sourcePortDegree = /* @__PURE__ */ new Map();
+	const targetPortDegree = /* @__PURE__ */ new Map();
+	const edgeModelOrderByPortId = /* @__PURE__ */ new Map();
+	for (const [edgeIndex, edge] of (root.edges ?? []).entries()) {
+		for (const source of edge.sources ?? (edge.source === void 0 ? [] : [edge.source])) {
+			const id = String(source);
+			sourcePortDegree.set(id, (sourcePortDegree.get(id) ?? 0) + 1);
+			if (portOwnerById.has(id) && !edgeModelOrderByPortId.has(id)) edgeModelOrderByPortId.set(id, edgeIndex);
+		}
+		for (const target of edge.targets ?? (edge.target === void 0 ? [] : [edge.target])) {
+			const id = String(target);
+			targetPortDegree.set(id, (targetPortDegree.get(id) ?? 0) + 1);
+			if (portOwnerById.has(id) && !edgeModelOrderByPortId.has(id)) edgeModelOrderByPortId.set(id, edgeIndex);
+		}
+	}
+	const orderedPorts = (child) => {
+		const ports = [...child.ports ?? []];
+		if (String(getOption(child.layoutOptions ?? {}, "portConstraints")) !== "FIXED_SIDE") return ports;
+		const canonicalSides = getDirection(globalOptions) === "left" ? {
+			NORTH: "NORTH",
+			EAST: "WEST",
+			SOUTH: "SOUTH",
+			WEST: "EAST"
+		} : getDirection(globalOptions) === "down" ? {
+			NORTH: "WEST",
+			EAST: "SOUTH",
+			SOUTH: "EAST",
+			WEST: "NORTH"
+		} : getDirection(globalOptions) === "up" ? {
+			NORTH: "EAST",
+			EAST: "SOUTH",
+			SOUTH: "WEST",
+			WEST: "NORTH"
+		} : {
+			NORTH: "NORTH",
+			EAST: "EAST",
+			SOUTH: "SOUTH",
+			WEST: "WEST"
+		};
+		const side = (port) => canonicalSides[String(getOption(port.layoutOptions ?? {}, "port.side"))] ?? "UNDEFINED";
+		const sideOrder = [
+			"NORTH",
+			"EAST",
+			"SOUTH",
+			"WEST"
+		];
+		ports.sort((left, right) => {
+			const leftSide = side(left);
+			const rightSide = side(right);
+			const sideDifference = sideOrder.indexOf(leftSide) - sideOrder.indexOf(rightSide);
+			if (sideDifference !== 0) return sideDifference;
+			if (String(getOption(globalOptions, "layered.portSortingStrategy")) === "PORT_DEGREE") {
+				if (leftSide === "EAST") return (sourcePortDegree.get(String(right.id)) ?? 0) - (sourcePortDegree.get(String(left.id)) ?? 0);
+				if (leftSide === "WEST") return (targetPortDegree.get(String(left.id)) ?? 0) - (targetPortDegree.get(String(right.id)) ?? 0);
+			}
+			const modelOrderStrategy = String(getOption(globalOptions, "layered.considerModelOrder.strategy") ?? "NONE");
+			const usePortModelOrder = getBooleanOption(globalOptions, "layered.considerModelOrder.portModelOrder") === true;
+			if (modelOrderStrategy !== "NONE" && !usePortModelOrder) {
+				const leftOrder = edgeModelOrderByPortId.get(String(left.id));
+				const rightOrder = edgeModelOrderByPortId.get(String(right.id));
+				if (leftOrder === void 0 && rightOrder === void 0) return 0;
+				if (leftOrder !== rightOrder) return (leftOrder ?? Infinity) - (rightOrder ?? Infinity);
+			}
+			return (leftSide === "WEST" ? -1 : 1) * ((child.ports?.indexOf(left) ?? 0) - (child.ports?.indexOf(right) ?? 0));
+		});
+		return ports;
+	};
+	const native = (0, _statelyai_graph.createGraph)({
+		id: String(root.id),
+		nodes: children.map((child) => ({
+			id: String(child.id),
+			x: child.x,
+			y: child.y,
+			...parsePosition(getOption(child.layoutOptions ?? {}, "position")),
+			width: child.width,
+			height: child.height,
+			label: child.labels?.[0]?.text,
+			ports: orderedPorts(child).filter((port) => getBooleanOption(port.layoutOptions ?? {}, "noLayout") !== true).map((port) => ({
+				name: String(port.id),
+				direction: sourcePortIds.has(String(port.id)) ? targetPortIds.has(String(port.id)) ? "inout" : "out" : targetPortIds.has(String(port.id)) ? "in" : "inout",
+				x: port.x,
+				y: port.y,
+				width: port.width,
+				height: port.height
+			}))
+		})),
+		edges: (root.edges ?? []).flatMap((edge) => {
+			if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true) return [];
+			if (isInsideSelfLoop(root, edge)) return [];
+			const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
+			const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
+			const labels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
+			const labelLabelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
+			const labelWidth = Math.max(0, ...labels.map((label) => label.width ?? 0));
+			const labelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelLabelSpacing;
+			return nodeIds.has(source.nodeId) && nodeIds.has(target.nodeId) ? [{
+				id: String(edge.id),
+				sourceId: source.nodeId,
+				targetId: target.nodeId,
+				sourcePort: source.port,
+				targetPort: target.port,
+				label: edge.labels?.[0]?.text,
+				width: labelWidth,
+				height: labelHeight,
+				points: parsePoints(getOption(edge.layoutOptions ?? {}, "bendPoints"))
+			}] : [];
+		})
+	});
+	for (const node of native.nodes) {
+		const child = children.find((candidate) => String(candidate.id) === node.id);
+		const origin = child && require_layered.externalPortDummyOf(child);
+		if (origin) require_layered.attachExternalPortDummy(node, origin);
+	}
+	return native;
+}
+function parsePoints(value) {
+	if (typeof value !== "string") return void 0;
+	const points = [...value.matchAll(/\{\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\}/g)].map((match) => ({
+		x: Number(match[1]),
+		y: Number(match[2])
+	}));
+	return points.length > 0 ? points : void 0;
+}
+function parsePosition(value) {
+	if (typeof value !== "string") return void 0;
+	const match = value.match(/\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/);
+	return match ? {
+		x: Number(match[1]),
+		y: Number(match[2])
+	} : void 0;
+}
+function toSection(edge, points) {
+	const startPoint = points[0];
+	const endPoint = points.at(-1);
+	if (!startPoint || !endPoint) return void 0;
+	return {
+		id: `${String(edge.id)}_s0`,
+		startPoint: { ...startPoint },
+		endPoint: { ...endPoint },
+		incomingShape: edge.sources?.[0] ?? edge.source,
+		outgoingShape: edge.targets?.[0] ?? edge.target,
+		...points.length > 2 ? { bendPoints: points.slice(1, -1).map((point) => ({ ...point })) } : {}
+	};
+}
+function applyLayout(root, graph, padding, layoutOptions, resultPolicy) {
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const edgeById = new Map(graph.edges.map((edge) => [edge.id, edge]));
+	for (const child of root.children ?? []) {
+		const node = nodeById.get(String(child.id));
+		if (!node) continue;
+		child.x = node.x;
+		child.y = node.y;
+		child.width = node.width;
+		child.height = node.height;
+		placeNodeLabels(child, layoutOptions);
+		for (const port of child.ports ?? []) {
+			if (getBooleanOption(port.layoutOptions ?? {}, "noLayout") === true) continue;
+			const laidOutPort = node.ports?.find((candidate) => candidate.name === String(port.id));
+			if (!laidOutPort) continue;
+			port.x = laidOutPort.x;
+			port.y = laidOutPort.y;
+			port.width = laidOutPort.width;
+			port.height = laidOutPort.height;
+		}
+		placePortLabels(child, layoutOptions);
+	}
+	for (const edge of root.edges ?? []) {
+		if (resultPolicy?.preserveEdgeSections) {
+			for (const section$1 of edge.sections ?? []) {
+				section$1.incomingShape ??= edge.sources?.[0] ?? edge.source;
+				section$1.outgoingShape ??= edge.targets?.[0] ?? edge.target;
+			}
+			continue;
+		}
+		const laidOutEdge = edgeById.get(String(edge.id));
+		if (!laidOutEdge) {
+			if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true) {
+				for (const section$2 of edge.sections ?? []) {
+					section$2.incomingShape ??= edge.sources?.[0] ?? edge.source;
+					section$2.outgoingShape ??= edge.targets?.[0] ?? edge.target;
+				}
+				continue;
+			}
+			const section$1 = getParentEdgeSection(root, edge);
+			if (section$1) {
+				edge.sections = [section$1];
+				edge.container = root.id;
+			}
+			continue;
+		}
+		const nativeJunctions = resultPolicy?.junctionPointsByEdgeId?.get(String(edge.id));
+		if (nativeJunctions) if (nativeJunctions.length) edge.junctionPoints = nativeJunctions.map((point) => ({ ...point }));
+		else delete edge.junctionPoints;
+		const section = toSection(edge, laidOutEdge.points ?? []);
+		edge.sections = section ? [section] : [];
+		if (section) edge.container = root.id;
+		const target = root.children?.find((child) => String(child.id) === String(edge.targets?.[0] ?? edge.target));
+		if (getBooleanOption(target?.layoutOptions ?? {}, "hypernode") === true && (section?.bendPoints?.length ?? 0) > 0) edge.junctionPoints = [section.bendPoints.at(-1)];
+		let labelY = laidOutEdge.y ?? 0;
+		const points = laidOutEdge.points ?? [];
+		const firstPoint = points[0] ?? {
+			x: laidOutEdge.x ?? 0,
+			y: laidOutEdge.y ?? 0
+		};
+		const lastPoint = points.at(-1) ?? firstPoint;
+		const midpointX = (laidOutEdge.x ?? 0) + (laidOutEdge.width ?? 0) / 2;
+		const edgeLabelSpacing = getNumberOption(layoutOptions, "spacing.edgeLabel") ?? 2;
+		const labelLabelSpacing = getNumberOption(layoutOptions, "spacing.labelLabel") ?? 0;
+		const loneLabel = (edge.labels ?? []).filter(isLayoutEdgeLabel).length === 1;
+		for (const label of edge.labels ?? []) {
+			if (getBooleanOption(label.layoutOptions ?? {}, "noLayout") === true) {
+				label.x ??= 0;
+				label.y ??= 0;
+				continue;
+			}
+			if (!isLayoutEdgeLabel(label)) {
+				label.x ??= 0;
+				label.y ??= 0;
+				continue;
+			}
+			const placement = String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER");
+			const width = label.width ?? 0;
+			label.x = loneLabel && placement !== "CENTER" && laidOutEdge.x !== void 0 ? laidOutEdge.x : placement === "TAIL" ? firstPoint.x + edgeLabelSpacing : placement === "HEAD" ? lastPoint.x - width - edgeLabelSpacing : midpointX - width / 2;
+			label.y = labelY;
+			labelY += (label.height ?? 0) + labelLabelSpacing;
+		}
+	}
+	if (!resultPolicy?.skipBoundsNormalization) normalizeElkGraphBounds(root, padding, layoutOptions, resultPolicy?.normalizationBounds, resultPolicy?.placementCrossBounds);
+	if (!resultPolicy?.preserveEdgeSections && String(getOption(layoutOptions, "edgeRouting") ?? "ORTHOGONAL") === "ORTHOGONAL") {
+		const direction = getDirection(layoutOptions);
+		applyOrthogonalJunctions(root, direction === "right" || direction === "left", direction === "right" || direction === "down", getBooleanOption(layoutOptions, "layered.mergeEdges") === true, new Set((root.children ?? []).filter((n) => getBooleanOption(n.layoutOptions ?? {}, "hypernode") === true).map((n) => String(n.id))), new Set((root.edges ?? []).filter((e) => getBooleanOption(e.layoutOptions ?? {}, "noLayout") === true || resultPolicy?.junctionPointsByEdgeId?.has(String(e.id)) === true).map((e) => String(e.id))));
+	}
+}
+function normalizeElkGraphBounds(root, padding, layoutOptions = {}, compactionBounds, placementCrossBounds) {
+	const layoutEdges = (root.edges ?? []).filter((edge) => edge.container == null || String(edge.container) === String(root.id));
+	const authoredWidth = root.width;
+	const authoredHeight = root.height;
+	const fixedGraphSize = getBooleanOption(layoutOptions, "nodeSize.fixedGraphSize") === true;
+	const layoutChildren = (root.children ?? []).filter((node) => getBooleanOption(node.layoutOptions ?? {}, "noLayout") !== true);
+	let minimumX = compactionBounds?.left ?? Number.POSITIVE_INFINITY;
+	let minimumY = compactionBounds?.top ?? Number.POSITIVE_INFINITY;
+	for (const node of layoutChildren) {
+		minimumX = Math.min(minimumX, node.x ?? 0, ...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0)), ...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0))));
+		minimumY = Math.min(minimumY, node.y ?? 0, ...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0)), ...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0))));
+	}
+	for (const edge of layoutEdges) {
+		const laidOutLabels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
+		minimumX = Math.min(minimumX, ...laidOutLabels.map((label) => label.x ?? 0));
+		minimumY = Math.min(minimumY, ...laidOutLabels.map((label) => label.y ?? 0));
+		if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") !== true) {
+			const points = (edge.sections ?? []).flatMap((section) => [
+				section.startPoint,
+				...section.bendPoints ?? [],
+				section.endPoint
+			]);
+			minimumX = Math.min(minimumX, ...points.map((point) => point.x));
+			minimumY = Math.min(minimumY, ...points.map((point) => point.y));
+		}
+	}
+	const shiftX = Number.isFinite(minimumX) ? Math.max(0, padding.left - minimumX) : 0;
+	const shiftY = Number.isFinite(minimumY) ? Math.max(0, padding.top - minimumY) : 0;
+	if (shiftX !== 0 || shiftY !== 0) {
+		for (const node of layoutChildren) {
+			node.x = (node.x ?? 0) + shiftX;
+			node.y = (node.y ?? 0) + shiftY;
+		}
+		for (const edge of layoutEdges) {
+			for (const section of edge.sections ?? []) for (const point of [
+				section.startPoint,
+				...section.bendPoints ?? [],
+				section.endPoint
+			]) {
+				point.x += shiftX;
+				point.y += shiftY;
+			}
+			for (const point of edge.junctionPoints ?? []) {
+				point.x += shiftX;
+				point.y += shiftY;
+			}
+			for (const label of (edge.labels ?? []).filter(isLayoutEdgeLabel)) {
+				label.x = (label.x ?? 0) + shiftX;
+				label.y = (label.y ?? 0) + shiftY;
+			}
+		}
+	}
+	const maximumNodeX = Math.max(0, ...layoutChildren.map((node) => (node.x ?? 0) + (node.width ?? 0)));
+	const maximumNodeY = Math.max(0, ...layoutChildren.map((node) => (node.y ?? 0) + (node.height ?? 0)));
+	const layoutEdgePoints = layoutEdges.flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+		section.startPoint,
+		...section.bendPoints ?? [],
+		section.endPoint
+	]));
+	const wrappingStrategy = String(getOption(layoutOptions, "layered.wrapping.strategy") ?? "OFF");
+	const direction = getDirection(layoutOptions);
+	const laidOutChildById = new Map((root.children ?? []).map((child) => [String(child.id), child]));
+	const childByEndpointId = new Map(laidOutChildById);
+	for (const child of root.children ?? []) for (const port of child.ports ?? []) childByEndpointId.set(String(port.id), child);
+	const wrappedEdgeCount = layoutEdges.filter((edge) => {
+		const source = childByEndpointId.get(String(edge.sources?.[0] ?? edge.source));
+		const target = childByEndpointId.get(String(edge.targets?.[0] ?? edge.target));
+		if (!source || !target) return false;
+		return direction === "right" ? (source.x ?? 0) > (target.x ?? 0) : direction === "left" ? (source.x ?? 0) < (target.x ?? 0) : direction === "down" ? (source.y ?? 0) > (target.y ?? 0) : (source.y ?? 0) < (target.y ?? 0);
+	}).length;
+	const hasWrappedEdge = wrappedEdgeCount > 0;
+	const retainPlacementBounds = wrappingStrategy !== "MULTI_EDGE" && !(wrappingStrategy === "SINGLE_EDGE" && hasWrappedEdge) && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") === "NONE" && getBooleanOption(layoutOptions, "layered.feedbackEdges") !== true && String(getOption(layoutOptions, "layered.layering.nodePromotion.strategy") ?? "NONE") !== "MODEL_ORDER_LEFT_TO_RIGHT";
+	const addBoundaryPixel = retainPlacementBounds && !(root.children ?? []).some((child) => (child.children?.length ?? 0) > 0);
+	const isSelfLoop = (edge) => {
+		const source = childByEndpointId.get(String(edge.sources?.[0] ?? edge.source));
+		return source !== void 0 && source === childByEndpointId.get(String(edge.targets?.[0] ?? edge.target));
+	};
+	const hasSelfLoops = layoutEdges.some(isSelfLoop);
+	const edgeBoundsExtraX = addBoundaryPixel && placementCrossBounds?.axis !== "x" && !(hasSelfLoops && (direction === "right" || direction === "left")) && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.x)) >= maximumNodeX - 1e-9 ? 1 : 0;
+	const edgeBoundsExtraY = addBoundaryPixel && placementCrossBounds?.axis !== "y" && !(hasSelfLoops && (direction === "down" || direction === "up")) && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) >= maximumNodeY - 1e-9 ? 1 : 0;
+	const singleMultiEdgeCutBoundsExtraY = wrappingStrategy === "MULTI_EDGE" && wrappedEdgeCount === 1 && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) >= maximumNodeY - 1e-9 ? 1 : 0;
+	const postCompactionBoundsExtraX = !compactionBounds && !addBoundaryPixel && !hasWrappedEdge && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") !== "NONE" && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.x)) > maximumNodeX + 1e-9 ? .04 : 0;
+	const postCompactionBoundsExtraY = !compactionBounds && !addBoundaryPixel && !hasWrappedEdge && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") !== "NONE" && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) > maximumNodeY + 1e-9 ? .04 : 0;
+	const calculatedWidth = Math.max(compactionBounds ? compactionBounds.right + shiftX : 0, retainPlacementBounds && placementCrossBounds?.axis === "x" ? placementCrossBounds.maximum + shiftX : 0, ...layoutChildren.flatMap((node) => [
+		(node.x ?? 0) + (node.width ?? 0),
+		...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)),
+		...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0) + (port.width ?? 0)),
+		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)))
+	]), ...layoutEdges.flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...layoutEdges.flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+		section.startPoint.x + (isSelfLoop(edge) ? 0 : edgeBoundsExtraX),
+		...(section.bendPoints ?? []).map((point) => point.x + (isSelfLoop(edge) ? 0 : edgeBoundsExtraX)),
+		section.endPoint.x + (isSelfLoop(edge) ? 0 : edgeBoundsExtraX)
+	]))) + padding.right + postCompactionBoundsExtraX + (getBooleanOption(layoutOptions, "layered.feedbackEdges") === true && (getDirection(layoutOptions) === "down" || getDirection(layoutOptions) === "up") ? 1 : 0);
+	const calculatedHeight = Math.max(compactionBounds ? compactionBounds.bottom + shiftY : 0, retainPlacementBounds && placementCrossBounds?.axis === "y" ? placementCrossBounds.maximum + shiftY : 0, ...layoutChildren.flatMap((node) => [
+		(node.y ?? 0) + (node.height ?? 0),
+		...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)),
+		...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0) + (port.height ?? 0)),
+		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)))
+	]), ...layoutEdges.flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" && childByEndpointId.get(String(edge.sources?.[0] ?? edge.source)) !== childByEndpointId.get(String(edge.targets?.[0] ?? edge.target)) ? 1 : 0))), ...layoutEdges.flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+		section.startPoint.y + (isSelfLoop(edge) ? 0 : edgeBoundsExtraY),
+		...(section.bendPoints ?? []).map((point) => point.y + (isSelfLoop(edge) ? 0 : edgeBoundsExtraY)),
+		section.endPoint.y + (isSelfLoop(edge) ? 0 : edgeBoundsExtraY)
+	]))) + padding.bottom + singleMultiEdgeCutBoundsExtraY + postCompactionBoundsExtraY + (getBooleanOption(layoutOptions, "layered.feedbackEdges") === true && (getDirection(layoutOptions) === "right" || getDirection(layoutOptions) === "left") ? 1 : 0);
+	root.width = fixedGraphSize ? authoredWidth ?? 0 : calculatedWidth;
+	root.height = fixedGraphSize ? authoredHeight ?? 0 : calculatedHeight;
+}
+function getParentEdgeSection(root, edge) {
+	const sourceId = String(edge.sources?.[0] ?? edge.source);
+	const targetId = String(edge.targets?.[0] ?? edge.target);
+	const rootId = String(root.id);
+	const source = root.children?.find((child) => String(child.id) === sourceId);
+	const target = root.children?.find((child) => String(child.id) === targetId);
+	if (source && targetId === rootId) {
+		const startPoint = {
+			x: (source.x ?? 0) + (source.width ?? 0) / 2,
+			y: (source.y ?? 0) + (source.height ?? 0)
+		};
+		return {
+			id: `${String(edge.id)}_s0`,
+			startPoint,
+			endPoint: {
+				x: startPoint.x,
+				y: 0
+			}
+		};
+	}
+	if (sourceId === rootId && target) {
+		const endPoint = {
+			x: (target.x ?? 0) + (target.width ?? 0) / 2,
+			y: target.y ?? 0
+		};
+		return {
+			id: `${String(edge.id)}_s0`,
+			startPoint: {
+				x: endPoint.x,
+				y: 0
+			},
+			endPoint
+		};
+	}
+}
+function placeNodeLabels(node, globalOptions) {
+	const labelPadding = parsePadding(getOption(globalOptions, "nodeLabels.padding"), 5);
+	for (const label of node.labels ?? []) {
+		if (!label.text) continue;
+		if (getBooleanOption(label.layoutOptions ?? {}, "noLayout") === true) continue;
+		const placement = String(getOption({
+			...globalOptions,
+			...node.layoutOptions,
+			...label.layoutOptions
+		}, "nodeLabels.placement") ?? "");
+		if (!placement) continue;
+		const width = label.width ?? 0;
+		const height = label.height ?? 0;
+		const nodeWidth = node.width ?? 0;
+		const nodeHeight = node.height ?? 0;
+		label.x = placement.includes("H_CENTER") ? (nodeWidth - width + labelPadding.left - labelPadding.right) / 2 : placement.includes("H_RIGHT") ? nodeWidth - width - labelPadding.right : labelPadding.left;
+		if (placement.includes("OUTSIDE") && placement.includes("V_TOP")) label.y = -height - Number(getOption(globalOptions, "spacing.labelNode") ?? 5);
+		else if (placement.includes("OUTSIDE") && placement.includes("V_BOTTOM")) label.y = nodeHeight + Number(getOption(globalOptions, "spacing.labelNode") ?? 5);
+		else if (placement.includes("V_CENTER")) label.y = (nodeHeight - height + labelPadding.top - labelPadding.bottom) / 2;
+		else if (placement.includes("V_BOTTOM")) label.y = nodeHeight - height - labelPadding.bottom;
+		else label.y = labelPadding.top;
+	}
+}
+function placePortLabels(node, globalOptions) {
+	const placement = String(getOption({
+		...globalOptions,
+		...node.layoutOptions
+	}, "portLabels.placement") ?? "OUTSIDE");
+	const inside = placement.includes("INSIDE");
+	const alwaysOtherSide = placement.includes("ALWAYS_OTHER_SAME_SIDE");
+	const spaceEfficient = placement.includes("SPACE_EFFICIENT") || String(getOption(node.layoutOptions ?? {}, "nodeSize.options") ?? "").includes("SPACE_EFFICIENT_PORT_LABELS");
+	const horizontalSpacing = getNumberOption(globalOptions, "spacing.labelPortHorizontal") ?? 1;
+	const verticalSpacing = getNumberOption(globalOptions, "spacing.labelPortVertical") ?? 1;
+	const labelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
+	const treatAsGroup = getBooleanOption(node.layoutOptions ?? {}, "portLabels.treatAsGroup") ?? false;
+	const placeNextToPort = placement.includes("NEXT_TO_PORT_IF_POSSIBLE") || getBooleanOption(node.layoutOptions ?? {}, "portLabels.nextToPortIfPossible") === true;
+	const nodeWidth = node.width ?? 0;
+	for (const port of node.ports ?? []) {
+		if (getBooleanOption(port.layoutOptions ?? {}, "noLayout") === true) continue;
+		const portWidth = port.width ?? 0;
+		const portHeight = port.height ?? 0;
+		const side = (port.x ?? 0) < 0 ? "WEST" : (port.x ?? 0) >= nodeWidth ? "EAST" : (port.y ?? 0) < 0 ? "NORTH" : "SOUTH";
+		const portsOnSide = (node.ports ?? []).filter((candidate) => {
+			return ((candidate.x ?? 0) < 0 ? "WEST" : (candidate.x ?? 0) >= nodeWidth ? "EAST" : (candidate.y ?? 0) < 0 ? "NORTH" : "SOUTH") === side;
+		});
+		const labels = (port.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
+		const totalLabelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelSpacing;
+		let stackedY = labels.length > 1 ? inside || placeNextToPort ? treatAsGroup ? (portHeight - totalLabelHeight) / 2 : (portHeight - (labels[0]?.height ?? 0)) / 2 : portHeight + verticalSpacing : void 0;
+		for (const label of labels) {
+			if (!label.text) continue;
+			const width = label.width ?? 0;
+			const height = label.height ?? 0;
+			if (side === "EAST") {
+				label.x = inside ? -width - horizontalSpacing : portWidth + horizontalSpacing;
+				label.y = stackedY ?? (inside || placeNextToPort ? (portHeight - height) / 2 : alwaysOtherSide ? -height - verticalSpacing : portHeight + verticalSpacing);
+			} else if (side === "WEST") {
+				label.x = inside ? portWidth + horizontalSpacing : -width - horizontalSpacing;
+				label.y = stackedY ?? (inside || placeNextToPort ? (portHeight - height) / 2 : alwaysOtherSide ? -height - verticalSpacing : portHeight + verticalSpacing);
+			} else if (side === "NORTH") {
+				label.x = inside || placeNextToPort ? (portWidth - width) / 2 : alwaysOtherSide ? -width - horizontalSpacing : portWidth + horizontalSpacing;
+				label.y = inside ? portHeight + verticalSpacing : -height - verticalSpacing;
+			} else {
+				label.x = inside || placeNextToPort ? (portWidth - width) / 2 : alwaysOtherSide ? -width - horizontalSpacing : portWidth + horizontalSpacing;
+				label.y = inside ? -height - verticalSpacing : portHeight + verticalSpacing;
+			}
+			if (spaceEfficient && portsOnSide[0] === port && portsOnSide.length >= 2 && !placeNextToPort) if (side === "EAST" || side === "WEST") label.y = -height - verticalSpacing;
+			else label.x = -width - horizontalSpacing;
+			if (stackedY !== void 0) stackedY += height + labelSpacing;
+		}
+	}
+}
+/** Edges crossing `group`, in the order ELK's CompoundGraphPreprocessor creates its boundary ports. */
+function elkBoundaryEdgeOrder(group, scope, originals) {
+	const edges = [];
+	const collect = (node) => {
+		edges.push(...node.edges ?? []);
+		for (const child of node.children ?? []) collect(child);
+	};
+	collect(scope);
+	const endpoints = (edge) => originals.get(edge) ?? {
+		sourceId: String(edge.sources?.[0] ?? edge.source),
+		targetId: String(edge.targets?.[0] ?? edge.target)
+	};
+	const order = (node) => {
+		const inside = /* @__PURE__ */ new Set();
+		const mark = (parent) => {
+			for (const child of parent.children ?? []) {
+				inside.add(String(child.id));
+				for (const port of child.ports ?? []) inside.add(String(port.id));
+				mark(child);
+			}
+		};
+		mark(node);
+		const leaves = (edge) => inside.has(endpoints(edge).sourceId) !== inside.has(endpoints(edge).targetId);
+		const result = /* @__PURE__ */ new Set();
+		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))) {
+				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];
+	};
+	return order(group);
+}
+/** Creation order of hierarchy segments in ELK's CompoundGraphPreprocessor. */
+const hierarchySegmentRank = /* @__PURE__ */ new WeakMap();
+const segmentOrderByScope = /* @__PURE__ */ new WeakMap();
+const originalEdgeId = /* @__PURE__ */ new WeakMap();
+/**
+* Segments inside `group`, in creation order: the inner pass connects child
+* groups' exported ports first, then the outer pass leaves `group` itself.
+*/
+function elkSegmentOrder(group, scope, originals, ownBoundary) {
+	const order = /* @__PURE__ */ new Map();
+	const add = (edge) => {
+		const id = originalEdgeId.get(edge) ?? String(edge.id);
+		if (!order.has(id)) order.set(id, order.size);
+	};
+	for (const child of group.children ?? []) if (child.children?.length) for (const edge of elkBoundaryEdgeOrder(child, scope, originals)) add(edge);
+	if (ownBoundary) for (const edge of elkBoundaryEdgeOrder(group, scope, originals)) add(edge);
+	return order;
+}
+const isPostCompactionKey = (key) => /(^|\.)compaction\.postCompaction\.strategy$/.test(key);
+function usesPostCompaction(options, node) {
+	const active = (values) => Object.entries(values ?? {}).some(([key, value]) => isPostCompactionKey(key) && String(value) !== "NONE");
+	const visit = (current) => active(current.layoutOptions) || active(current.properties) || (current.children ?? []).some(visit);
+	return active(options) || visit(node);
+}
+function disablePostCompaction(node) {
+	for (const values of [node.layoutOptions, node.properties]) for (const key of Object.keys(values ?? {})) if (isPostCompactionKey(key)) values[key] = "NONE";
+	for (const child of node.children ?? []) disablePostCompaction(child);
+	return node;
+}
+/**
+* Alternative random seeds worth trying for a compound layout, unless the
+* graph chooses its hierarchical greedy switch explicitly.
+*/
+function crossingVariants(options, graph) {
+	const own = {
+		...options,
+		...graph.properties,
+		...graph.layoutOptions
+	};
+	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 = {
+		...options,
+		...graph.properties,
+		...graph.layoutOptions
+	};
+	return Number(getOption(own, "layered.thoroughness") ?? 7) > 7;
+}
+
+//#endregion
+Object.defineProperty(exports, 'ELK', {
+  enumerable: true,
+  get: function () {
+    return ELK;
+  }
+});
+Object.defineProperty(exports, 'compileStatechartLayout', {
+  enumerable: true,
+  get: function () {
+    return compileStatechartLayout;
+  }
+});
+Object.defineProperty(exports, 'getElkRoutes', {
+  enumerable: true,
+  get: function () {
+    return getElkRoutes;
+  }
+});
+Object.defineProperty(exports, 'layoutStatechart', {
+  enumerable: true,
+  get: function () {
+    return layoutStatechart;
+  }
+});
+Object.defineProperty(exports, 'scoreStatechartLayout', {
+  enumerable: true,
+  get: function () {
+    return scoreStatechartLayout;
+  }
+});