@statelyai/layout 0.2.0 → 0.3.0

package/dist/{layered-Bz2nWmVp.mjs → layered-DGFTeQSl.mjs}

@@ -1,21 +1,6 @@
+import { F as UnsupportedLayoutError, M as routeCrosses, N as routeOrthogonal, P as LayoutError, _ as routeToPolylines, b as recordRouteGeometry, c as orthogonalRouting, j as overlaps, v as nativeGeometry, y as worldGeometry } from "./routing-A2hrK9MP.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
-//#region src/errors.ts
-var LayoutError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "LayoutError";
-	}
-};
-var UnsupportedLayoutError = class extends LayoutError {
-	constructor(message) {
-		super(message, "UNSUPPORTED_LAYOUT");
-		this.name = "UnsupportedLayoutError";
-	}
-};
-
-//#endregion
 //#region src/java-random.ts
 /** Java's 48-bit `java.util.Random`, used by ELK for seeded tie-breaking. */
 var JavaRandom = class JavaRandom {
@@ -2229,15 +2214,15 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		const hypernode = nodeSettings?.hypernode;
 		const unzipping = (input.settings["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING";
 		const crossingStrategy = input.settings["crossingMinimization.strategy"] ?? "LAYER_SWEEP";
-		const interactiveTargetOrder = crossingStrategy === "INTERACTIVE" && entries.every(({ endpoint: endpoint$1 }) => endpoint$1 === "target") && entries.some(({ edge }) => edge.sourceId.startsWith("__layout_dummy:"));
-		const verticalNoneTargetOrder = !horizontal && crossingStrategy === "NONE" && input.settings["layering.strategy"] === "STRETCH_WIDTH" && entries.every(({ endpoint: endpoint$1 }) => endpoint$1 === "target") && !input.graph.edges.some(({ sourceId }) => sourceId === nodeId) && entries.some(({ edge }) => edge.sourceId.startsWith("__layout_dummy:"));
-		const interactiveLeftSourceOrder = crossingStrategy === "INTERACTIVE" && input.direction === "left" && entries.length >= 3 && entries.every(({ endpoint: endpoint$1 }) => endpoint$1 === "source") ? [...entries].sort((left, right) => {
+		const interactiveTargetOrder = crossingStrategy === "INTERACTIVE" && entries.every(({ endpoint }) => endpoint === "target") && entries.some(({ edge }) => edge.sourceId.startsWith("__layout_dummy:"));
+		const verticalNoneTargetOrder = !horizontal && crossingStrategy === "NONE" && input.settings["layering.strategy"] === "STRETCH_WIDTH" && entries.every(({ endpoint }) => endpoint === "target") && !input.graph.edges.some(({ sourceId }) => sourceId === nodeId) && entries.some(({ edge }) => edge.sourceId.startsWith("__layout_dummy:"));
+		const interactiveLeftSourceOrder = crossingStrategy === "INTERACTIVE" && input.direction === "left" && entries.length >= 3 && entries.every(({ endpoint }) => endpoint === "source") ? [...entries].sort((left, right) => {
 			const leftRect = placement.rectByNodeId.get(left.edge.targetId);
 			const rightRect = placement.rectByNodeId.get(right.edge.targetId);
 			const leftCross = (leftRect?.y ?? 0) + (leftRect?.height ?? 0) / 2;
 			return (rightRect?.y ?? 0) + (rightRect?.height ?? 0) / 2 - leftCross || (edgeModelOrder.get(left.edge.id) ?? 0) - (edgeModelOrder.get(right.edge.id) ?? 0);
 		}).map(({ edge }) => edge.id) : void 0;
-		const interactiveForwardLongEdgeSource = input.direction !== "left" && crossingStrategy === "INTERACTIVE" && entries.every(({ endpoint: endpoint$1 }) => endpoint$1 === "source") && entries.some(({ edge }) => edge.targetId.startsWith("__layout_dummy:"));
+		const interactiveForwardLongEdgeSource = input.direction !== "left" && crossingStrategy === "INTERACTIVE" && entries.every(({ endpoint }) => endpoint === "source") && entries.some(({ edge }) => edge.targetId.startsWith("__layout_dummy:"));
 		const layerOrdered = unzipping || interactiveTargetOrder || verticalNoneTargetOrder || input.settings.hierarchyHandling !== "INCLUDE_CHILDREN" && (crossingStrategy === "LAYER_SWEEP" || crossingStrategy === "MEDIAN_LAYER_SWEEP");
 		entries.sort((left, right) => {
 			if (interactiveLeftSourceOrder) {
@@ -2290,8 +2275,8 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		const constraints = nodeSettings?.portConstraints;
 		const portSpacing = Number(input.settings["spacing.portPort"] ?? 10);
 		const fixedWrapAnchor = nodeId.startsWith("__layout_dummy:wrap:");
-		entries.forEach(({ edge, endpoint: endpoint$1 }, index) => {
-			const ordinal = endpoint$1 === "target" && input.settings["crossingMinimization.strategy"] !== "INTERACTIVE" && !layerOrdered && !(input.settings.directionCongruency === "ROTATION" && (input.direction === "down" || input.direction === "left")) ? entries.length - index : index + 1;
+		entries.forEach(({ edge, endpoint }, index) => {
+			const ordinal = endpoint === "target" && input.settings["crossingMinimization.strategy"] !== "INTERACTIVE" && !layerOrdered && !(input.settings.directionCongruency === "ROTATION" && (input.direction === "down" || input.direction === "left")) ? entries.length - index : index + 1;
 			const orderedIndex = ordinal - 1;
 			const crossPosition = mergeEdges || hypernode === true ? axisSize / 2 : constraints === "FIXED_RATIO" || constraints === "FIXED_POS" ? 0 : alignment === "BEGIN" ? axisStart + orderedIndex * portSpacing : alignment === "END" ? axisStart + availableAxisSize - (entries.length - orderedIndex - 1) * portSpacing : alignment === "CENTER" ? axisStart + (availableAxisSize - (entries.length - 1) * portSpacing) / 2 + orderedIndex * portSpacing : alignment === "JUSTIFIED" ? entries.length === 1 ? axisStart + availableAxisSize / 2 : axisStart + orderedIndex * availableAxisSize / (entries.length - 1) : axisStart + availableAxisSize * ordinal / (entries.length + 1);
 			let point = horizontal ? {
@@ -2312,7 +2297,7 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 				source: point,
 				target: point
 			};
-			pair[endpoint$1] = point;
+			pair[endpoint] = point;
 			result.set(edge.id, pair);
 		});
 	}
@@ -2497,12 +2482,12 @@ function routeEdges(style) {
 			flowLayerByNodeId.set(interval.id, flowLayers.length - 1);
 		}
 		const increasing = input.direction === "right" || input.direction === "down";
-		const flowPortProtrusion = (edge, endpoint$1) => {
-			const node = nodeById.get(endpoint$1 === "source" ? edge.sourceId : edge.targetId);
-			const portName = endpoint$1 === "source" ? edge.sourcePort : edge.targetPort;
+		const flowPortProtrusion = (edge, endpoint) => {
+			const node = nodeById.get(endpoint === "source" ? edge.sourceId : edge.targetId);
+			const portName = endpoint === "source" ? edge.sourcePort : edge.targetPort;
 			const port = node?.ports?.find((candidate) => candidate.name === portName);
 			if (!node || !port) return 0;
-			return input.portSettings?.(port, node)?.["port.side"] === (horizontal ? endpoint$1 === "source" ? input.direction === "right" ? "EAST" : "WEST" : input.direction === "right" ? "WEST" : "EAST" : endpoint$1 === "source" ? input.direction === "down" ? "SOUTH" : "NORTH" : input.direction === "down" ? "NORTH" : "SOUTH") ? horizontal ? port.width ?? 0 : port.height ?? 0 : 0;
+			return input.portSettings?.(port, node)?.["port.side"] === (horizontal ? endpoint === "source" ? input.direction === "right" ? "EAST" : "WEST" : input.direction === "right" ? "WEST" : "EAST" : endpoint === "source" ? input.direction === "down" ? "SOUTH" : "NORTH" : input.direction === "down" ? "NORTH" : "SOUTH") ? horizontal ? port.width ?? 0 : port.height ?? 0 : 0;
 		};
 		const adjacentNodeIds = /* @__PURE__ */ new Map();
 		for (const edge of input.graph.edges) {
@@ -3821,108 +3806,355 @@ function getPolylineMidpoint(points) {
 }
 
 //#endregion
-//#region src/authoring/coordinates.ts
-/** Native compound nodes and sibling edges are parent-relative; crossing edges are world-relative. */
-function frames(graph) {
-	const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
-	const offsets = /* @__PURE__ */ new Map();
-	const visiting = /* @__PURE__ */ new Set();
-	function offset(id) {
-		const cached = offsets.get(id);
-		if (cached) return cached;
-		if (visiting.has(id)) throw new LayoutError(`Cyclic parent hierarchy at ${id}`, "INVALID_GRAPH");
-		visiting.add(id);
-		const parentId = nodes.get(id)?.parentId;
-		if (parentId == null) {
-			const origin = {
-				x: 0,
-				y: 0
-			};
-			visiting.delete(id);
-			offsets.set(id, origin);
-			return origin;
-		}
-		const parent = nodes.get(parentId);
-		const ancestor = offset(parentId);
-		const result = {
-			x: ancestor.x + parent.x,
-			y: ancestor.y + parent.y
+//#region src/layered/compound.ts
+const paddingOf = (value) => ({
+	top: typeof value === "number" ? value : value?.top ?? 12,
+	right: typeof value === "number" ? value : value?.right ?? 12,
+	bottom: typeof value === "number" ? value : value?.bottom ?? 12,
+	left: typeof value === "number" ? value : value?.left ?? 12
+});
+/** Solve each scope's occupied envelope bottom-up; never repair returned sibling positions. */
+function layoutCompounds(graph, options, flat) {
+	const nodes = graph.nodes.map((node) => {
+		const size = options.measure?.(node);
+		return {
+			...node,
+			width: size?.width ?? node.width ?? 0,
+			height: size?.height ?? node.height ?? 0
 		};
-		visiting.delete(id);
-		offsets.set(id, result);
-		return result;
+	});
+	const byId = new Map(nodes.map((node) => [node.id, node]));
+	const ancestry = (id) => {
+		const chain = [];
+		let current = id;
+		while (current != null) {
+			if (chain.includes(current)) throw new Error(`Cyclic compound hierarchy at ${current}`);
+			chain.push(current);
+			current = byId.get(current)?.parentId ?? null;
+		}
+		return [...chain, null];
+	};
+	const branch = (id, scope) => {
+		const chain = ancestry(id);
+		return chain[chain.indexOf(scope) - 1];
+	};
+	const owner = (edge) => {
+		const a = ancestry(edge.sourceId), b = ancestry(edge.targetId);
+		if (edge.sourceId !== edge.targetId && b.includes(edge.sourceId)) return edge.sourceId;
+		if (edge.sourceId !== edge.targetId && a.includes(edge.targetId)) return edge.targetId;
+		return a.slice(1).find((id) => b.slice(1).includes(id)) ?? null;
+	};
+	const owned = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const scope = owner(edge);
+		owned.set(scope, [...owned.get(scope) ?? [], edge]);
 	}
-	for (const node of graph.nodes) offsets.set(node.id, offset(node.id));
-	return {
-		nodes: offsets,
-		edges: new Map(graph.edges.map((edge) => {
-			const source = nodes.get(edge.sourceId);
-			const target = nodes.get(edge.targetId);
-			return [edge.id, (source.parentId ?? null) === (target.parentId ?? null) ? offset(source.id) : {
-				x: 0,
-				y: 0
+	const edges = new Map(graph.edges.map((e) => [e.id, {
+		...e,
+		x: 0,
+		y: 0,
+		width: e.width ?? 0,
+		height: e.height ?? 0
+	}]));
+	const localLabels = /* @__PURE__ */ new Map();
+	const compoundGeometry = /* @__PURE__ */ new Map();
+	const childScopes = [...new Set(nodes.flatMap((n) => n.parentId == null ? [] : [n.parentId]))].sort((a, b) => ancestry(b).length - ancestry(a).length);
+	const solve = (scope) => {
+		const children = nodes.filter((n) => (n.parentId ?? null) === scope);
+		if (!children.length) return;
+		const container = scope == null ? void 0 : byId.get(scope);
+		const config = container && options.compound?.(container);
+		const direction = config?.direction ?? options.direction ?? graph.direction ?? "right";
+		const horizontal = direction === "left" || direction === "right";
+		const padding = paddingOf(config?.padding ?? options.padding);
+		const insets = { ...padding };
+		const header = config?.header;
+		const side = header?.side ?? "top";
+		if (header) insets[side] += side === "top" || side === "bottom" ? header.height : header.width;
+		const scopeEdges = owned.get(scope) ?? [];
+		const boundary = /* @__PURE__ */ new Map();
+		const projected = [];
+		for (const edge of scopeEdges) if (edge.sourceId === scope || edge.targetId === scope) {
+			const id = branch(edge.sourceId === scope ? edge.targetId : edge.sourceId, scope);
+			boundary.set(id, [...boundary.get(id) ?? [], edge]);
+		} else projected.push({
+			...edge,
+			sourceId: branch(edge.sourceId, scope),
+			targetId: branch(edge.targetId, scope),
+			points: void 0
+		});
+		const gap = options.settings?.["spacing.labelNode"] ?? options.spacing?.node ?? 20;
+		const labelGap = options.settings?.["spacing.labelLabel"] ?? 8;
+		const sizes = new Map(children.map((n) => {
+			const labels$1 = boundary.get(n.id) ?? [];
+			const labelWidth = Math.max(0, ...labels$1.map((e) => e.width ?? 0));
+			const labelHeight = labels$1.reduce((sum, e) => sum + (e.height ?? 0), 0) + Math.max(0, labels$1.length - 1) * labelGap;
+			return [n.id, {
+				width: labels$1.length && !horizontal ? n.width + gap + labelWidth : Math.max(n.width, labelWidth),
+				height: labels$1.length && horizontal ? n.height + gap + labelHeight : Math.max(n.height, labelHeight)
 			}];
-		}))
+		}));
+		const labels = projected.filter((edge) => (edge.width ?? 0) > 0 && (edge.height ?? 0) > 0);
+		const used = new Set([...graph.nodes, ...graph.edges].map((entity) => entity.id));
+		const labelIds = /* @__PURE__ */ new Map();
+		for (const edge of labels) {
+			let id = `__layout_label_${edge.id}`;
+			while ([
+				id,
+				`${id}_source`,
+				`${id}_target`
+			].some((key) => used.has(key))) id += "_";
+			for (const key of [
+				id,
+				`${id}_source`,
+				`${id}_target`
+			]) used.add(key);
+			labelIds.set(edge.id, id);
+			sizes.set(id, {
+				width: edge.width,
+				height: edge.height
+			});
+		}
+		const originalEdges = new Map(graph.edges.map((edge) => [edge.id, edge]));
+		for (const edge of labels) {
+			originalEdges.set(`${labelIds.get(edge.id)}_source`, edges.get(edge.id));
+			originalEdges.set(`${labelIds.get(edge.id)}_target`, edges.get(edge.id));
+		}
+		const placementOrder = new Map(children.map((node, index) => [node.id, index]));
+		for (const edge of labels) placementOrder.set(labelIds.get(edge.id), ((placementOrder.get(edge.sourceId) ?? 0) + (placementOrder.get(edge.targetId) ?? 0)) / 2 + (edge.sourceId === edge.targetId ? .25 : 0));
+		const result$1 = flat({
+			...graph,
+			nodes: [...children.map((n) => ({
+				...n,
+				parentId: null
+			})), ...labels.map((edge) => ({
+				type: "node",
+				id: labelIds.get(edge.id),
+				data: void 0
+			}))].sort((a, b) => placementOrder.get(a.id) - placementOrder.get(b.id)),
+			edges: projected.flatMap((edge) => {
+				const labelId = labelIds.get(edge.id);
+				return labelId ? [{
+					...edge,
+					id: `${labelId}_source`,
+					targetId: labelId,
+					targetPort: void 0,
+					width: 0,
+					height: 0
+				}, {
+					...edge,
+					id: `${labelId}_target`,
+					sourceId: labelId,
+					sourcePort: void 0,
+					width: 0,
+					height: 0
+				}] : [edge];
+			})
+		}, {
+			...options,
+			compound: void 0,
+			direction,
+			padding: insets,
+			measure: (node) => sizes.get(node.id),
+			nodeSettings: (node) => {
+				const original = byId.get(node.id);
+				return original ? options.nodeSettings?.(original) : void 0;
+			},
+			edgeSettings: (edge) => options.edgeSettings?.(originalEdges.get(edge.id) ?? edge)
+		});
+		for (const placed of result$1.nodes) {
+			const node = byId.get(placed.id);
+			if (node) Object.assign(node, {
+				x: placed.x,
+				y: placed.y,
+				ports: placed.ports
+			});
+		}
+		for (const edge of projected) {
+			const labelId = labelIds.get(edge.id);
+			if (labelId) {
+				const label = result$1.nodes.find((n) => n.id === labelId);
+				localLabels.set(edge.id, {
+					scope,
+					rect: {
+						x: label.x,
+						y: label.y,
+						width: label.width,
+						height: label.height
+					}
+				});
+			}
+		}
+		for (const [id, labels$1] of boundary) {
+			const node = byId.get(id);
+			const totalHeight = labels$1.reduce((sum, e) => sum + (e.height ?? 0), 0) + Math.max(0, labels$1.length - 1) * labelGap;
+			let cross = horizontal ? 0 : (Math.max(node.height, totalHeight) - totalHeight) / 2;
+			for (const edge of labels$1) {
+				const width = edge.width ?? 0, height = edge.height ?? 0;
+				localLabels.set(edge.id, {
+					scope,
+					rect: {
+						x: node.x + (horizontal ? (Math.max(node.width, width) - width) / 2 : node.width + gap),
+						y: node.y + (horizontal ? node.height + gap : 0) + cross,
+						width,
+						height
+					}
+				});
+				cross += height + labelGap;
+			}
+		}
+		const boxes = [...children.map((n) => ({
+			x: n.x,
+			y: n.y,
+			...sizes.get(n.id)
+		})), ...[...localLabels.values()].filter((l) => l.scope === scope).map((l) => l.rect)];
+		let dx = Math.max(0, insets.left - Math.min(...boxes.map((b) => b.x)));
+		let dy = Math.max(0, insets.top - Math.min(...boxes.map((b) => b.y)));
+		if (header && (side === "top" || side === "bottom")) {
+			const occupiedWidth = Math.max(...boxes.map((b) => b.x + b.width)) - Math.min(...boxes.map((b) => b.x)) + padding.left + padding.right;
+			dx += Math.max(0, (header.width - occupiedWidth) / 2);
+		}
+		if (header && (side === "left" || side === "right")) {
+			const occupiedHeight = Math.max(...boxes.map((b) => b.y + b.height)) - Math.min(...boxes.map((b) => b.y)) + padding.top + padding.bottom;
+			dy += Math.max(0, (header.height - occupiedHeight) / 2);
+		}
+		const right = Math.max(...boxes.map((b) => b.x + dx + b.width));
+		const bottom = Math.max(...boxes.map((b) => b.y + dy + b.height));
+		for (const n of children) {
+			n.x += dx;
+			n.y += dy;
+		}
+		for (const l of localLabels.values()) if (l.scope === scope) {
+			l.rect.x += dx;
+			l.rect.y += dy;
+		}
+		if (container) {
+			const width = Math.max(header?.width ?? 0, config?.minContentSize?.width ? config.minContentSize.width + insets.left + insets.right : 0, right + insets.right);
+			const height = Math.max(header?.height ?? 0, config?.minContentSize?.height ? config.minContentSize.height + insets.top + insets.bottom : 0, bottom + insets.bottom);
+			container.width = Math.max(container.width, width);
+			container.height = Math.max(container.height, height);
+			compoundGeometry.set(container.id, {
+				bounds: {
+					x: 0,
+					y: 0,
+					width: container.width,
+					height: container.height
+				},
+				content: {
+					x: insets.left,
+					y: insets.top,
+					width: container.width - insets.left - insets.right,
+					height: container.height - insets.top - insets.bottom
+				},
+				...header ? { header: {
+					x: side === "right" ? container.width - header.width : 0,
+					y: side === "bottom" ? container.height - header.height : 0,
+					width: side === "top" || side === "bottom" ? container.width : header.width,
+					height: side === "left" || side === "right" ? container.height : header.height
+				} } : {}
+			});
+		}
 	};
-}
-function worldGeometry(graph) {
-	const offsets = frames(graph);
-	return {
+	for (const scope of childScopes) solve(scope);
+	const roots = nodes.filter((n) => n.parentId == null);
+	if (roots.length === 1 && compoundGeometry.has(roots[0].id) && !owned.get(null)?.length) Object.assign(roots[0], {
+		x: 0,
+		y: 0
+	});
+	else solve(null);
+	const origin = (id) => {
+		if (id == null) return {
+			x: 0,
+			y: 0
+		};
+		return ancestry(id).slice(0, -1).reduce((p, key) => ({
+			x: p.x + byId.get(key).x,
+			y: p.y + byId.get(key).y
+		}), {
+			x: 0,
+			y: 0
+		});
+	};
+	for (const [id, label] of localLabels) {
+		const offset = origin(label.scope);
+		Object.assign(edges.get(id), {
+			...label.rect,
+			x: label.rect.x + offset.x,
+			y: label.rect.y + offset.y
+		});
+	}
+	const attachmentSettings = {};
+	for (const edge of edges.values()) {
+		const sourceGeometry = compoundGeometry.get(edge.sourceId), targetGeometry = compoundGeometry.get(edge.targetId);
+		const intent = options.edgeAttachment?.(edge);
+		attachmentSettings[edge.id] = {
+			...sourceGeometry && edge.sourceId !== edge.targetId && ancestry(edge.targetId).includes(edge.sourceId) ? { sourceAttachment: {
+				bounds: intent?.source === "outer" ? {
+					x: 0,
+					y: 0,
+					width: sourceGeometry.bounds.width,
+					height: sourceGeometry.bounds.height
+				} : sourceGeometry.content,
+				facing: intent?.source === "outer" ? "outward" : "inward"
+			} } : {},
+			...targetGeometry && intent?.target === "content" ? { targetAttachment: {
+				bounds: targetGeometry.content,
+				facing: "inward"
+			} } : {}
+		};
+	}
+	const worldNodes = nodes.map((n) => ({
+		...n,
+		...origin(n.id)
+	}));
+	const usedIds = new Set(nodes.map((n) => n.id));
+	const headers = [...compoundGeometry].flatMap(([id, geometry]) => {
+		if (!geometry.header) return [];
+		const p = origin(id);
+		let key = `__layout_header_${id}`;
+		while (usedIds.has(key)) key += "_";
+		usedIds.add(key);
+		return [{
+			type: "node",
+			id: key,
+			parentId: id,
+			data: void 0,
+			...geometry.header,
+			x: p.x + geometry.header.x,
+			y: p.y + geometry.header.y
+		}];
+	});
+	const snapshot = orthogonalRouting.route({
 		...graph,
-		nodes: graph.nodes.map((n) => {
-			const p = offsets.nodes.get(n.id);
-			return p.x === 0 && p.y === 0 ? n : {
-				...n,
-				x: n.x + p.x,
-				y: n.y + p.y
-			};
-		}),
-		edges: graph.edges.map((e) => {
-			const p = offsets.edges.get(e.id);
-			return p.x === 0 && p.y === 0 ? e : {
-				...e,
-				x: e.x + p.x,
-				y: e.y + p.y,
-				...e.points ? { points: e.points.map((v) => ({
-					x: v.x + p.x,
-					y: v.y + p.y
-				})) } : {}
-			};
-		})
+		nodes: [...worldNodes, ...headers],
+		edges: [...edges.values()]
+	}, {
+		coordinateSpace: "world",
+		edges: attachmentSettings
+	});
+	for (const [id, route] of snapshot.routes) {
+		const polylines = routeToPolylines(route);
+		Object.assign(edges.get(id), {
+			points: polylines.flatMap((p) => p.map((point) => ({ ...point }))),
+			routing: "orthogonal"
+		});
+	}
+	for (const [id, geometry] of compoundGeometry) geometry.bounds = {
+		...geometry.bounds,
+		x: byId.get(id).x,
+		y: byId.get(id).y
 	};
-}
-/** Ancestor frames stay fixed during authoring. Preserve untouched coordinates exactly. */
-function nativeGeometry(graph, original) {
-	const offsets = frames(original);
-	const world = worldGeometry(original);
-	const originalNodes = new Map(original.nodes.map((n) => [n.id, n]));
-	const originalEdges = new Map(original.edges.map((e) => [e.id, e]));
-	const worldNodes = new Map(world.nodes.map((n) => [n.id, n]));
-	const worldEdges = new Map(world.edges.map((e) => [e.id, e]));
-	return {
+	const result = {
 		...graph,
-		nodes: graph.nodes.map((n) => {
-			const p = offsets.nodes.get(n.id), before = originalNodes.get(n.id), prior = worldNodes.get(n.id);
-			return {
-				...n,
-				x: n.x === prior.x ? before.x : n.x - p.x,
-				y: n.y === prior.y ? before.y : n.y - p.y
-			};
-		}),
-		edges: graph.edges.map((e) => {
-			const p = offsets.edges.get(e.id), before = originalEdges.get(e.id), prior = worldEdges.get(e.id);
-			const points = JSON.stringify(e.points) === JSON.stringify(prior.points) ? before.points : e.points?.map((v) => ({
-				x: v.x - p.x,
-				y: v.y - p.y
-			}));
-			return {
-				...e,
-				x: e.x === prior.x ? before.x : e.x - p.x,
-				y: e.y === prior.y ? before.y : e.y - p.y,
-				...points === void 0 ? {} : { points }
-			};
-		})
+		edgeCoordinateSpace: "world",
+		direction: options.direction ?? graph.direction ?? "right",
+		nodes,
+		edges: graph.edges.map((e) => edges.get(e.id)),
+		compoundGeometry,
+		compoundRoutes: snapshot.routes
 	};
+	recordRouteGeometry(result, snapshot.routes);
+	return result;
 }
 
 //#endregion
@@ -5431,173 +5663,6 @@ function solveGeometryConstraints(graph, constraints, movableNodes, movableLabel
 	};
 }
 
-//#endregion
-//#region src/authoring/routing.ts
-function overlaps(a, b, gap = 0) {
-	return a.width > 0 && a.height > 0 && b.width > 0 && b.height > 0 && a.x < b.x + b.width + gap && a.x + a.width + gap > b.x && a.y < b.y + b.height + gap && a.y + a.height + gap > b.y;
-}
-/** Open-interior intersection: travelling along a rectangle boundary is allowed. */
-function crossesRect(a, b, rect) {
-	let low = 0, high = 1;
-	for (const axis of ["x", "y"]) {
-		const delta = b[axis] - a[axis];
-		const min = rect[axis], max = min + (axis === "x" ? rect.width : rect.height);
-		if (Math.abs(delta) < 1e-10) {
-			if (a[axis] <= min || a[axis] >= max) return false;
-		} else {
-			const t1 = (min - a[axis]) / delta, t2 = (max - a[axis]) / delta;
-			low = Math.max(low, Math.min(t1, t2));
-			high = Math.min(high, Math.max(t1, t2));
-		}
-	}
-	return low < high - 1e-10;
-}
-function routeCrosses(points, rect) {
-	return points?.some((point, i) => i > 0 && crossesRect(points[i - 1], point, rect)) ?? false;
-}
-function endpoint(node, portName, direction, source) {
-	if (portName !== void 0) {
-		const port = node.ports?.find((p) => p.name === portName);
-		if (port?.x !== void 0 && port.y !== void 0) return {
-			x: node.x + port.x + (port.width ?? 0) / 2,
-			y: node.y + port.y + (port.height ?? 0) / 2
-		};
-		throw new LayoutError(`Port ${portName} on ${node.id} requires positioned geometry`, "MISSING_GEOMETRY");
-	}
-	const horizontal = direction === "left" || direction === "right";
-	const far = source === (direction === "right" || direction === "down");
-	return horizontal ? {
-		x: node.x + (far ? node.width : 0),
-		y: node.y + node.height / 2
-	} : {
-		x: node.x + node.width / 2,
-		y: node.y + (far ? node.height : 0)
-	};
-}
-/** Deterministic orthogonal visibility-grid search around fixed rectangles. */
-function connect(start, end, obstacles, check) {
-	if (start.x === end.x && start.y === end.y) return [start];
-	for (let attempt = 0; attempt < 8; attempt++) {
-		check();
-		const margin = 64 * 2 ** attempt;
-		const left = Math.min(start.x, end.x) - margin;
-		const right = Math.max(start.x, end.x) + margin;
-		const top = Math.min(start.y, end.y) - margin;
-		const bottom = Math.max(start.y, end.y) + margin;
-		const local = obstacles.filter((r) => r.x <= right && r.x + r.width >= left && r.y <= bottom && r.y + r.height >= top);
-		const result = search(start, end, local, obstacles, check);
-		if (result || local.length === obstacles.length) return result;
-	}
-}
-function search(start, end, gridObstacles, obstacles, check) {
-	const xs = [...new Set([
-		start.x,
-		end.x,
-		...gridObstacles.flatMap((r) => [r.x, r.x + r.width])
-	])].sort((a, b) => a - b);
-	const ys = [...new Set([
-		start.y,
-		end.y,
-		...gridObstacles.flatMap((r) => [r.y, r.y + r.height])
-	])].sort((a, b) => a - b);
-	if (xs.length * ys.length > 4e4) return void 0;
-	const width = xs.length;
-	const point = (id) => ({
-		x: xs[id % width],
-		y: ys[Math.floor(id / width)]
-	});
-	const from = ys.indexOf(start.y) * width + xs.indexOf(start.x);
-	const to = ys.indexOf(end.y) * width + xs.indexOf(end.x);
-	const distances = new Map([[from, 0]]);
-	const previous = /* @__PURE__ */ new Map();
-	const queue = [];
-	function push(item) {
-		queue.push(item);
-		let i = queue.length - 1;
-		while (i > 0) {
-			const parent = i - 1 >> 1;
-			if (queue[parent].cost <= item.cost) break;
-			queue[i] = queue[parent];
-			i = parent;
-		}
-		queue[i] = item;
-	}
-	function pop() {
-		const first = queue[0];
-		const last = queue.pop();
-		if (queue.length) {
-			let i = 0;
-			while (i * 2 + 1 < queue.length) {
-				let child = i * 2 + 1;
-				if (child + 1 < queue.length && queue[child + 1].cost < queue[child].cost) child++;
-				if (last.cost <= queue[child].cost) break;
-				queue[i] = queue[child];
-				i = child;
-			}
-			queue[i] = last;
-		}
-		return first;
-	}
-	push({
-		id: from,
-		cost: 0
-	});
-	let visits = 0;
-	while (queue.length) {
-		if (++visits % 128 === 0) check();
-		const current = pop();
-		if (current.cost !== distances.get(current.id)) continue;
-		if (current.id === to) {
-			const result = [end];
-			let id = to;
-			while (id !== from) {
-				id = previous.get(id);
-				result.push(point(id));
-			}
-			return result.reverse();
-		}
-		const x = current.id % width, y = Math.floor(current.id / width);
-		const neighbors = [
-			x > 0 ? current.id - 1 : -1,
-			x + 1 < width ? current.id + 1 : -1,
-			y > 0 ? current.id - width : -1,
-			y + 1 < ys.length ? current.id + width : -1
-		];
-		const a = point(current.id);
-		for (const next of neighbors) {
-			if (next < 0) continue;
-			const b = point(next);
-			if (obstacles.some((rect) => crossesRect(a, b, rect))) continue;
-			const cost = current.cost + Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-			if (cost >= (distances.get(next) ?? Infinity)) continue;
-			distances.set(next, cost);
-			previous.set(next, current.id);
-			push({
-				id: next,
-				cost
-			});
-		}
-	}
-}
-function routeOrthogonal(edge, source, target, direction, obstacles, waypoints, check) {
-	const anchors = [
-		endpoint(source, edge.sourcePort, direction, true),
-		...waypoints,
-		endpoint(target, edge.targetPort, direction, false)
-	];
-	const points = [];
-	for (let i = 1; i < anchors.length; i++) {
-		const segment = connect(anchors[i - 1], anchors[i], obstacles, check);
-		if (!segment) return void 0;
-		points.push(...points.length ? segment.slice(1) : segment);
-	}
-	return points.filter((p, i) => {
-		if (i === 0 || i === points.length - 1) return true;
-		const before = points[i - 1], after = points[i + 1];
-		return !(before.x === p.x && p.x === after.x && (p.y - before.y) * (after.y - p.y) >= 0 || before.y === p.y && p.y === after.y && (p.x - before.x) * (after.x - p.x) >= 0);
-	});
-}
-
 //#endregion
 //#region src/authoring/partial.ts
 const geometryKeys = [
@@ -10556,7 +10621,7 @@ function runCommentBoxPipeline(graph, options, context) {
 			x: horizontal ? point.x : point.x + crossShift,
 			y: horizontal ? point.y + crossShift : point.y
 		}));
-		const endpoint$1 = (source) => {
+		const endpoint = (source) => {
 			if (horizontal) return {
 				x: direction === "right" === source ? (targetRect.x ?? 0) + (targetRect.width ?? 0) : targetRect.x ?? 0,
 				y: (targetRect.y ?? 0) + (targetRect.height ?? 0) / 2
@@ -10566,8 +10631,8 @@ function runCommentBoxPipeline(graph, options, context) {
 				y: direction === "down" === source ? (targetRect.y ?? 0) + (targetRect.height ?? 0) : targetRect.y ?? 0
 			};
 		};
-		if (edge.sourceId === targetId && points.length > 0) points[0] = endpoint$1(true);
-		if (edge.targetId === targetId && points.length > 0) points[points.length - 1] = endpoint$1(false);
+		if (edge.sourceId === targetId && points.length > 0) points[0] = endpoint(true);
+		if (edge.targetId === targetId && points.length > 0) points[points.length - 1] = endpoint(false);
 		return [edge.id, {
 			...edge,
 			x: horizontal ? edge.x : (edge.x ?? 0) + crossShift,
@@ -10769,126 +10834,16 @@ function runSeparatedComponents(graph, options, context) {
 	};
 }
 function runCompoundPipeline(graph, options, context) {
-	const nodes = graph.nodes.map((node) => ({ ...node }));
-	const nodeById = new Map(nodes.map((node) => [node.id, node]));
-	const depth = (node) => {
-		let value = 0;
-		let parentId = node.parentId;
-		const seen = /* @__PURE__ */ new Set();
-		while (parentId != null && !seen.has(parentId)) {
-			seen.add(parentId);
-			value++;
-			parentId = nodeById.get(parentId)?.parentId;
-		}
-		return value;
-	};
-	const parentIds = [...new Set(nodes.flatMap((node) => node.parentId == null ? [] : [node.parentId]))].sort((left, right) => depth(nodeById.get(right)) - depth(nodeById.get(left)));
-	const edgeById = new Map(graph.edges.map((edge) => [edge.id, { ...edge }]));
-	const padding = typeof options.padding === "number" ? options.padding : 12;
-	const layoutSiblings = (parentId) => {
-		const siblings = nodes.filter((node) => (node.parentId ?? null) === parentId);
-		if (siblings.length === 0) return;
-		const siblingIds = new Set(siblings.map((node) => node.id));
-		const siblingEdges = graph.edges.filter((edge) => siblingIds.has(edge.sourceId) && siblingIds.has(edge.targetId));
-		const flatNodes = siblings.map((node) => ({
-			...node,
-			parentId: null
-		}));
-		const result = runLayeredPipeline({
-			...graph,
-			nodes: flatNodes,
-			edges: siblingEdges
-		}, options, context);
-		for (const laidOut of result.nodes) {
-			const node = nodeById.get(laidOut.id);
-			if (!node) continue;
-			Object.assign(node, laidOut, { parentId });
-		}
-		for (const edge of result.edges) edgeById.set(edge.id, edge);
-	};
-	for (const parentId of parentIds) {
-		layoutSiblings(parentId);
-		const parent = nodeById.get(parentId);
-		if (!parent) continue;
-		const children = nodes.filter((node) => node.parentId === parentId);
-		const right = Math.max(0, ...children.map((node) => (node.x ?? 0) + (node.width ?? 0)));
-		const bottom = Math.max(0, ...children.map((node) => (node.y ?? 0) + (node.height ?? 0)));
-		parent.width = Math.max(parent.width ?? 0, right + padding);
-		parent.height = Math.max(parent.height ?? 0, bottom + padding);
-	}
-	const roots = nodes.filter((node) => node.parentId == null);
-	if (roots.length === 1 && parentIds.includes(roots[0].id)) Object.assign(roots[0], {
-		x: 0,
-		y: 0
+	const result = layoutCompounds(graph, options, (scope, local) => runLayeredPipeline(scope, local, context));
+	for (const route of result.compoundRoutes.values()) for (const diagnostic of route.diagnostics) context?.diagnostics.push({
+		severity: "warning",
+		code: diagnostic.code,
+		message: diagnostic.message,
+		entityIds: [route.edgeId],
+		phase: "compound-routing",
+		geometry: "routes"
 	});
-	else layoutSiblings(null);
-	const absoluteRect = (id) => {
-		const node = nodeById.get(id);
-		if (!node) return {
-			x: 0,
-			y: 0,
-			width: 0,
-			height: 0
-		};
-		let x = node.x ?? 0;
-		let y = node.y ?? 0;
-		let parentId = node.parentId;
-		const seen = /* @__PURE__ */ new Set();
-		while (parentId != null && !seen.has(parentId)) {
-			seen.add(parentId);
-			const parent = nodeById.get(parentId);
-			if (!parent) break;
-			x += parent.x ?? 0;
-			y += parent.y ?? 0;
-			parentId = parent.parentId;
-		}
-		return {
-			x,
-			y,
-			width: node.width ?? 0,
-			height: node.height ?? 0
-		};
-	};
-	for (const edge of graph.edges) {
-		if (edgeById.get(edge.id)?.points !== void 0) continue;
-		const source = absoluteRect(edge.sourceId);
-		const target = absoluteRect(edge.targetId);
-		const start = {
-			x: source.x + source.width,
-			y: source.y + source.height / 2
-		};
-		const end = {
-			x: target.x,
-			y: target.y + target.height / 2
-		};
-		const track = (start.x + end.x) / 2;
-		const points = [
-			start,
-			{
-				x: track,
-				y: start.y
-			},
-			{
-				x: track,
-				y: end.y
-			},
-			end
-		];
-		edgeById.set(edge.id, {
-			...edge,
-			points,
-			x: track,
-			y: (start.y + end.y) / 2,
-			width: edge.width ?? 0,
-			height: edge.height ?? 0,
-			routing: "orthogonal"
-		});
-	}
-	return {
-		...graph,
-		nodes,
-		edges: graph.edges.map((edge) => edgeById.get(edge.id) ?? edge)
-	};
+	return result;
 }
 function runLayeredPipeline(graph, options, context) {
 	if (options.settings?.noLayout) return {
@@ -11361,16 +11316,16 @@ function runLayeredPipeline(graph, options, context) {
 			const targetDelta = postCompactionNodeCrossDeltas.get(edge.targetId) ?? 0;
 			const shiftEndpoint = (endpointIndex, adjacentIndex, delta) => {
 				if (delta === 0) return;
-				const endpoint$1 = points[endpointIndex];
+				const endpoint = points[endpointIndex];
 				const adjacent = points[adjacentIndex];
-				if (!endpoint$1) return;
-				const originalCross = horizontalAntiparallelFlow ? endpoint$1.y : endpoint$1.x;
+				if (!endpoint) return;
+				const originalCross = horizontalAntiparallelFlow ? endpoint.y : endpoint.x;
 				points[endpointIndex] = horizontalAntiparallelFlow ? {
-					...endpoint$1,
-					y: endpoint$1.y + delta
+					...endpoint,
+					y: endpoint.y + delta
 				} : {
-					...endpoint$1,
-					x: endpoint$1.x + delta
+					...endpoint,
+					x: endpoint.x + delta
 				};
 				if (adjacent && (horizontalAntiparallelFlow ? adjacent.y : adjacent.x) === originalCross) points[adjacentIndex] = horizontalAntiparallelFlow ? {
 					...adjacent,
@@ -11460,14 +11415,14 @@ function runLayeredPipeline(graph, options, context) {
 			for (const edge of [...incoming, ...outgoing]) {
 				const points = [...mutableRouteMap.get(edge.id) ?? []];
 				const endpointIndex = edge.sourceId === node.id ? 0 : points.length - 1;
-				const endpoint$1 = points[endpointIndex];
-				if (!endpoint$1) continue;
+				const endpoint = points[endpointIndex];
+				if (!endpoint) continue;
 				points[endpointIndex] = horizontal ? {
-					...endpoint$1,
-					x: endpoint$1.x + delta
+					...endpoint,
+					x: endpoint.x + delta
 				} : {
-					...endpoint$1,
-					y: endpoint$1.y + delta
+					...endpoint,
+					y: endpoint.y + delta
 				};
 				mutableRouteMap.set(edge.id, points);
 			}
@@ -11572,14 +11527,14 @@ function runLayeredPipeline(graph, options, context) {
 				if (points.length === 0) continue;
 				const index = edge.sourceId === nodeId ? 0 : edge.targetId === nodeId ? points.length - 1 : void 0;
 				if (index === void 0) continue;
-				const endpoint$1 = points[index];
-				const originalCross = horizontal ? endpoint$1.y : endpoint$1.x;
+				const endpoint = points[index];
+				const originalCross = horizontal ? endpoint.y : endpoint.x;
 				points[index] = horizontal ? {
-					...endpoint$1,
-					y: endpoint$1.y + delta
+					...endpoint,
+					y: endpoint.y + delta
 				} : {
-					...endpoint$1,
-					x: endpoint$1.x + delta
+					...endpoint,
+					x: endpoint.x + delta
 				};
 				const adjacentIndex = index === 0 ? 1 : points.length - 2;
 				const adjacent = points[adjacentIndex];
@@ -11777,7 +11732,12 @@ function runLayeredPipeline(graph, options, context) {
 * custom phase strategies, and all layered edge-routing styles.
 */
 function getLayeredLayout(graph, options = {}) {
-	return runLayeredPipeline(graph, options);
+	const result = runLayeredPipeline(graph, options);
+	return {
+		...result,
+		compoundGeometry: result.compoundGeometry ?? /* @__PURE__ */ new Map(),
+		compoundRoutes: result.compoundRoutes ?? /* @__PURE__ */ new Map()
+	};
 }
 const layeredAlgorithm = {
 	id: "layered",
@@ -11807,4 +11767,4 @@ const layeredAlgorithm = {
 };
 
 //#endregion
-export { minimizeCrossingsInteractively as A, JavaRandom as B, breakCyclesGreedily as C, breakCyclesWithModelOrderBreadthFirstSearch as D, breakCyclesWithDepthFirstSearch as E, placeNodesInteractively as F, UnsupportedLayoutError as H, placePorts as I, routeEdgesOrthogonally as L, minimizeCrossingsWithMedian as M, minimizeCrossingsWithModelOrder as N, breakCyclesWithModelOrderDepthFirstSearch as O, placeNodesInLayers as P, routeEdgesWithPolylines as R, breakCyclesByStronglyConnectedNodeType as S, breakCyclesInteractively as T, LayoutError as V, assignLayersByLongestPathToSink as _, elkLayeredEnumValues as a, breakCyclesByModelOrder as b, placeNodesWithLinearSegments as c, assignLayersWithMinWidth as d, assignLayersWithNetworkSimplex as f, assignLayersByLongestPath as g, assignLayersByDepthFirstModelOrder as h, toElkLayeredOptions as i, minimizeCrossingsWithBarycenter as j, getPolylineMidpoint as k, placeNodesWithBrandesKoepf as l, assignLayersByBreadthFirstModelOrder as m, layeredAlgorithm as n, elkLayeredOptionDefinitions as o, c as p, fromElkLayeredOptionId as r, placeNodesWithNetworkSimplex as s, getLayeredLayout as t, assignLayersWithStretchWidth as u, assignLayersInteractively as v, breakCyclesGreedilyByModelOrder as w, breakCyclesByStronglyConnectedConnectivity as x, assignLayersWithCoffmanGraham as y, routeEdgesWithSplines as z };
+export { minimizeCrossingsInteractively as A, JavaRandom as B, breakCyclesGreedily as C, breakCyclesWithModelOrderBreadthFirstSearch as D, breakCyclesWithDepthFirstSearch as E, placeNodesInteractively as F, placePorts as I, routeEdgesOrthogonally as L, minimizeCrossingsWithMedian as M, minimizeCrossingsWithModelOrder as N, breakCyclesWithModelOrderDepthFirstSearch as O, placeNodesInLayers as P, routeEdgesWithPolylines as R, breakCyclesByStronglyConnectedNodeType as S, breakCyclesInteractively as T, assignLayersByLongestPathToSink as _, elkLayeredEnumValues as a, breakCyclesByModelOrder as b, placeNodesWithLinearSegments as c, assignLayersWithMinWidth as d, assignLayersWithNetworkSimplex as f, assignLayersByLongestPath as g, assignLayersByDepthFirstModelOrder as h, toElkLayeredOptions as i, minimizeCrossingsWithBarycenter as j, getPolylineMidpoint as k, placeNodesWithBrandesKoepf as l, assignLayersByBreadthFirstModelOrder as m, layeredAlgorithm as n, elkLayeredOptionDefinitions as o, c as p, fromElkLayeredOptionId as r, placeNodesWithNetworkSimplex as s, getLayeredLayout as t, assignLayersWithStretchWidth as u, assignLayersInteractively as v, breakCyclesGreedilyByModelOrder as w, breakCyclesByStronglyConnectedConnectivity as x, assignLayersWithCoffmanGraham as y, routeEdgesWithSplines as z };