@statelyai/layout 0.2.0 → 0.3.0

package/dist/{layered-Cf9Rn8l7.cjs → layered-B2buJqMf.cjs}

@@ -1,21 +1,6 @@
+const require_routing = require('./routing-ujEP7Qh6.cjs');
 let _statelyai_graph_layout = require("@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 {
@@ -597,7 +582,7 @@ const assignLayersByLongestPath = (input, orientation) => {
 		if (sourceId === targetId) continue;
 		const sourceConstraint = input.constrainedLayerByNodeId.get(sourceId);
 		const targetConstraint = input.constrainedLayerByNodeId.get(targetId);
-		if (sourceConstraint !== void 0 && targetConstraint !== void 0 && targetConstraint <= sourceConstraint) throw new LayoutError(`Layer constraints conflict on edge ${edge.id}`, "UNSATISFIABLE_CONSTRAINTS");
+		if (sourceConstraint !== void 0 && targetConstraint !== void 0 && targetConstraint <= sourceConstraint) throw new require_routing.LayoutError(`Layer constraints conflict on edge ${edge.id}`, "UNSATISFIABLE_CONSTRAINTS");
 		successors.get(sourceId)?.push(targetId);
 		indegree.set(targetId, (indegree.get(targetId) ?? 0) + 1);
 	}
@@ -608,7 +593,7 @@ const assignLayersByLongestPath = (input, orientation) => {
 		const sourceLayer = layerByNodeId.get(sourceId) ?? 0;
 		for (const targetId of successors.get(sourceId) ?? []) {
 			const targetConstraint = input.constrainedLayerByNodeId.get(targetId);
-			if (targetConstraint !== void 0 && targetConstraint < sourceLayer + 1) throw new LayoutError(`Layer constraint conflicts at node ${targetId}`, "UNSATISFIABLE_CONSTRAINTS");
+			if (targetConstraint !== void 0 && targetConstraint < sourceLayer + 1) throw new require_routing.LayoutError(`Layer constraint conflicts at node ${targetId}`, "UNSATISFIABLE_CONSTRAINTS");
 			layerByNodeId.set(targetId, targetConstraint ?? Math.max(layerByNodeId.get(targetId) ?? 0, sourceLayer + 1));
 			const nextIndegree = (indegree.get(targetId) ?? 1) - 1;
 			indegree.set(targetId, nextIndegree);
@@ -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 = require_routing.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 = require_routing.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
 	};
+	require_routing.recordRouteGeometry(result, snapshot.routes);
+	return result;
 }
 
 //#endregion
@@ -5305,7 +5537,7 @@ const c = {
 	})
 };
 function constraintFailure(constraint, message) {
-	throw new LayoutError(`${constraint.id}: ${message}`, "UNSATISFIED_CONSTRAINT");
+	throw new require_routing.LayoutError(`${constraint.id}: ${message}`, "UNSATISFIED_CONSTRAINT");
 }
 /** Solve positions only. Fixed geometry is represented by constants, never edit variables. */
 function solveGeometryConstraints(graph, constraints, movableNodes, movableLabels, diagnostics) {
@@ -5317,7 +5549,7 @@ function solveGeometryConstraints(graph, constraints, movableNodes, movableLabel
 		const node = "nodeId" in ref;
 		const id = node ? ref.nodeId : ref.edgeId;
 		const rect = node ? nodes.get(id) : edges.get(id);
-		if (!rect) throw new LayoutError(`Unknown constraint entity: ${id}`, "INVALID_CONSTRAINT");
+		if (!rect) throw new require_routing.LayoutError(`Unknown constraint entity: ${id}`, "INVALID_CONSTRAINT");
 		const key = JSON.stringify([node ? "node" : "label", id]);
 		if ((node ? movableNodes : movableLabels).has(id) && !variables.has(key)) {
 			const pair = {
@@ -5343,13 +5575,13 @@ function solveGeometryConstraints(graph, constraints, movableNodes, movableLabel
 	const checks = [];
 	const ids = /* @__PURE__ */ new Set();
 	for (const constraint of constraints) {
-		if (ids.has(constraint.id)) throw new LayoutError(`Duplicate constraint ID: ${constraint.id}`, "INVALID_CONSTRAINT");
+		if (ids.has(constraint.id)) throw new require_routing.LayoutError(`Duplicate constraint ID: ${constraint.id}`, "INVALID_CONSTRAINT");
 		ids.add(constraint.id);
 		if (constraint.kind === "waypoint") continue;
 		const strength = Strength[constraint.strength ?? "required"];
 		const add = (lhs, operator = Operator.Eq, rhs = 0) => {
 			const difference = lhs.minus(rhs);
-			if (!Number.isFinite(difference.constant()) || !difference.terms().array.every((item) => Number.isFinite(item.second))) throw new LayoutError(`${constraint.id}: non-finite expression`, "INVALID_CONSTRAINT");
+			if (!Number.isFinite(difference.constant()) || !difference.terms().array.every((item) => Number.isFinite(item.second))) throw new require_routing.LayoutError(`${constraint.id}: non-finite expression`, "INVALID_CONSTRAINT");
 			try {
 				solver.addConstraint(new Constraint(difference, operator, 0, strength));
 			} catch {
@@ -5407,7 +5639,7 @@ function solveGeometryConstraints(graph, constraints, movableNodes, movableLabel
 	}
 	const coordinate = (variable) => {
 		const value = variable.value();
-		if (!Number.isFinite(value)) throw new LayoutError("Constraint solution contains non-finite geometry", "INVALID_CONSTRAINT");
+		if (!Number.isFinite(value)) throw new require_routing.LayoutError("Constraint solution contains non-finite geometry", "INVALID_CONSTRAINT");
 		return value === 0 ? 0 : value;
 	};
 	return {
@@ -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 = [
@@ -5642,14 +5707,14 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 	const constrainedLabels = labelReferences(constraints);
 	for (const [ids, entities] of [[selectedNodes, input.nodes], [selectedEdges, input.edges]]) {
 		const known = new Set(entities.map((e) => e.id));
-		for (const id of ids) if (!known.has(id)) throw new LayoutError(`Unknown selected entity: ${id}`, "INVALID_SELECTION");
+		for (const id of ids) if (!known.has(id)) throw new require_routing.LayoutError(`Unknown selected entity: ${id}`, "INVALID_SELECTION");
 	}
 	const containers = new Set(input.nodes.flatMap((n) => n.parentId == null ? [] : [n.parentId]));
-	if ([...selectedNodes].some((id) => containers.has(id))) throw new UnsupportedLayoutError("Authoring layout cannot move containers; select leaf nodes or use full layout without geometry constraints");
+	if ([...selectedNodes].some((id) => containers.has(id))) throw new require_routing.UnsupportedLayoutError("Authoring layout cannot move containers; select leaf nodes or use full layout without geometry constraints");
 	const previousNodes = new Map(scope.previous?.nodes.map((n) => [n.id, n]));
 	const previousEdges = new Map(scope.previous?.edges.map((e) => [e.id, e]));
 	const missing = (id) => {
-		throw new LayoutError(`Fixed entity ${id} requires finite geometry in graph or previous`, "MISSING_GEOMETRY");
+		throw new require_routing.LayoutError(`Fixed entity ${id} requires finite geometry in graph or previous`, "MISSING_GEOMETRY");
 	};
 	let nodes = input.nodes.map((node) => {
 		const previous = previousNodes.get(node.id);
@@ -5684,7 +5749,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 		nodes,
 		edges
 	};
-	const baseline = worldGeometry(authored);
+	const baseline = require_routing.worldGeometry(authored);
 	nodes = baseline.nodes;
 	edges = baseline.edges;
 	let graph = baseline;
@@ -5705,7 +5770,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 	for (const node of nodes) ancestors(node.id);
 	const direction = options.direction ?? input.direction ?? scope.previous?.direction ?? "down";
 	const gap = options.spacing?.node ?? 20;
-	if (!finite(gap) || gap < 0) throw new LayoutError("Spacing must be finite and non-negative", "INVALID_OPTIONS");
+	if (!finite(gap) || gap < 0) throw new require_routing.LayoutError("Spacing must be finite and non-negative", "INVALID_OPTIONS");
 	context.throwIfAborted();
 	if (selectedNodes.size && phase === "selection") {
 		const groups = /* @__PURE__ */ new Map();
@@ -5782,7 +5847,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 					};
 					const parent = n.parentId == null ? void 0 : placed.get(n.parentId);
 					if (parent && (translated.x < parent.x || translated.y < parent.y || translated.x + translated.width > parent.x + parent.width || translated.y + translated.height > parent.y + parent.height)) return false;
-					return fixedLabels.every((label) => budget() && !overlaps(translated, label, gap)) && obstacles.every((o) => budget() && (ancestors(n.id).has(o.id) || ancestors(o.id).has(n.id) || !overlaps(translated, o, gap)));
+					return fixedLabels.every((label) => budget() && !require_routing.overlaps(translated, label, gap)) && obstacles.every((o) => budget() && (ancestors(n.id).has(o.id) || ancestors(o.id).has(n.id) || !require_routing.overlaps(translated, o, gap)));
 				});
 			};
 			const offset = candidates.find((candidate) => comparisons <= 1e5 && fits(candidate));
@@ -5809,7 +5874,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 	const movedIds = new Set(moved.map((n) => n.id));
 	const resultNodes = new Map(graph.nodes.map((n) => [n.id, n]));
 	const automatic = /* @__PURE__ */ new Set();
-	const affected = (edge) => movedIds.has(edge.sourceId) || movedIds.has(edge.targetId) || moved.some((n) => !ancestors(edge.sourceId).has(n.id) && !ancestors(edge.targetId).has(n.id) && (routeCrosses(edge.points, n) || overlaps(edge, n) || edge.routing === "splines" && edge.points?.length && overlaps(n, {
+	const affected = (edge) => movedIds.has(edge.sourceId) || movedIds.has(edge.targetId) || moved.some((n) => !ancestors(edge.sourceId).has(n.id) && !ancestors(edge.targetId).has(n.id) && (require_routing.routeCrosses(edge.points, n) || require_routing.overlaps(edge, n) || edge.routing === "splines" && edge.points?.length && require_routing.overlaps(n, {
 		x: Math.min(...edge.points.map((p) => p.x)),
 		y: Math.min(...edge.points.map((p) => p.y)),
 		width: Math.max(...edge.points.map((p) => p.x)) - Math.min(...edge.points.map((p) => p.x)),
@@ -5817,7 +5882,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 	})));
 	const edgeById = new Map(graph.edges.map((e) => [e.id, e]));
 	for (const constraint of constraints) if (constraint.kind === "waypoint") {
-		if (!finite(constraint.point.x) || !finite(constraint.point.y) || !edgeById.has(constraint.edgeId)) throw new LayoutError(`${constraint.id}: invalid waypoint`, "INVALID_CONSTRAINT");
+		if (!finite(constraint.point.x) || !finite(constraint.point.y) || !edgeById.has(constraint.edgeId)) throw new require_routing.LayoutError(`${constraint.id}: invalid waypoint`, "INVALID_CONSTRAINT");
 	}
 	graph = {
 		...graph,
@@ -5840,7 +5905,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 				geometry: "routes"
 			});
 			if (routeAllowed) {
-				if (options.settings?.edgeRouting === "SPLINES" || options.strategies?.routeEdges) throw new UnsupportedLayoutError("Partial layout supports its built-in orthogonal router only");
+				if (options.settings?.edgeRouting === "SPLINES" || options.strategies?.routeEdges) throw new require_routing.UnsupportedLayoutError("Partial layout supports its built-in orthogonal router only");
 				const ancestorIds = new Set([...ancestors(source.id), ...ancestors(target.id)]);
 				const nodeObstacles = graph.nodes.filter((n) => !ancestorIds.has(n.id)).map((n) => n.id === source.id || n.id === target.id ? n : {
 					...n,
@@ -5852,7 +5917,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 				const labelObstacles = [...edgeById.values()].filter((e) => e.id !== edge.id && e.width > 0 && e.height > 0);
 				const required = waypoints.filter((c$1) => (c$1.strength ?? "required") === "required");
 				const accepted = new Set(required.map((c$1) => c$1.id));
-				const route = () => routeOrthogonal(edge, source, target, direction, [...nodeObstacles, ...labelObstacles], waypoints.filter((c$1) => c$1.kind === "waypoint" && accepted.has(c$1.id)).map((c$1) => c$1.kind === "waypoint" ? c$1.point : {
+				const route = () => require_routing.routeOrthogonal(edge, source, target, direction, [...nodeObstacles, ...labelObstacles], waypoints.filter((c$1) => c$1.kind === "waypoint" && accepted.has(c$1.id)).map((c$1) => c$1.kind === "waypoint" ? c$1.point : {
 					x: 0,
 					y: 0
 				}), () => context.throwIfAborted());
@@ -5940,7 +6005,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 						...next,
 						...p
 					};
-					return !graph.nodes.some((n) => !parentIds.has(n.id) && overlaps(rect, n)) && ![...edgeById.values()].some((e) => e.id !== edge.id && overlaps(rect, e));
+					return !graph.nodes.some((n) => !parentIds.has(n.id) && require_routing.overlaps(rect, n)) && ![...edgeById.values()].some((e) => e.id !== edge.id && require_routing.overlaps(rect, e));
 				});
 				if (chosen) next = {
 					...next,
@@ -5981,7 +6046,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 			entityIds: [node.id, parent.id],
 			geometry: "node"
 		});
-		if (graph.nodes.some((other) => other.id !== node.id && !ancestors(node.id).has(other.id) && !ancestors(other.id).has(node.id) && overlaps(node, other))) context.diagnostics.push({
+		if (graph.nodes.some((other) => other.id !== node.id && !ancestors(node.id).has(other.id) && !ancestors(other.id).has(node.id) && require_routing.overlaps(node, other))) context.diagnostics.push({
 			severity: "warning",
 			code: "NODE_OVERLAP",
 			message: `Node ${node.id} overlaps another node`,
@@ -5993,7 +6058,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 		const before = baseline.edges.find((e) => e.id === edge.id);
 		if (!samePosition(edge, before)) {
 			const containerIds = new Set([...ancestors(edge.sourceId), ...ancestors(edge.targetId)]);
-			const collisions = [...graph.nodes.filter((n) => !containerIds.has(n.id) && overlaps(edge, n)), ...graph.edges.filter((other) => other.id !== edge.id && overlaps(edge, other))];
+			const collisions = [...graph.nodes.filter((n) => !containerIds.has(n.id) && require_routing.overlaps(edge, n)), ...graph.edges.filter((other) => other.id !== edge.id && require_routing.overlaps(edge, other))];
 			if (collisions.length) context.diagnostics.push({
 				severity: "warning",
 				code: "LABEL_OVERLAP",
@@ -6001,7 +6066,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 				entityIds: [edge.id, ...collisions.map((e) => e.id)],
 				geometry: "labels"
 			});
-			for (const other of graph.edges) if (other.id !== edge.id && routeCrosses(other.points, edge) && !routeCrosses(other.points, before)) context.diagnostics.push({
+			for (const other of graph.edges) if (other.id !== edge.id && require_routing.routeCrosses(other.points, edge) && !require_routing.routeCrosses(other.points, before)) context.diagnostics.push({
 				severity: "warning",
 				code: "ROUTE_REPAIR_REQUIRED",
 				message: `Route ${other.id} crosses the moved label ${edge.id}`,
@@ -6009,7 +6074,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 				geometry: "routes"
 			});
 		}
-		if (geometry === "routes" && routeCrosses(before.points, before) && !routeCrosses(edge.points, edge)) context.diagnostics.push({
+		if (geometry === "routes" && require_routing.routeCrosses(before.points, before) && !require_routing.routeCrosses(edge.points, edge)) context.diagnostics.push({
 			severity: "warning",
 			code: "LABEL_REPAIR_REQUIRED",
 			message: `Label ${edge.id} is no longer attached to its route`,
@@ -6017,7 +6082,7 @@ function runPartialLayout(input, options, context, arrange, phase = "selection")
 			geometry: "labels"
 		});
 	}
-	return nativeGeometry(graph, authored);
+	return require_routing.nativeGeometry(graph, authored);
 }
 
 //#endregion
@@ -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 {
@@ -10988,7 +10943,7 @@ function runLayeredPipeline(graph, options, context) {
 		if (cycleBreakingStrategy === "BFS_NODE_ORDER") return breakCyclesWithModelOrderBreadthFirstSearch;
 		if (cycleBreakingStrategy === "SCC_CONNECTIVITY") return breakCyclesByStronglyConnectedConnectivity;
 		if (cycleBreakingStrategy === "SCC_NODE_TYPE") return breakCyclesByStronglyConnectedNodeType;
-		throw new UnsupportedLayoutError(`Cycle-breaking strategy ${cycleBreakingStrategy} is not implemented yet`);
+		throw new require_routing.UnsupportedLayoutError(`Cycle-breaking strategy ${cycleBreakingStrategy} is not implemented yet`);
 	})();
 	const orientation = measure("cycle-breaking", () => applyPartitionOrientation(input, applyLayerConstraintOrientation(input, cycleBreaker(input))));
 	const layeringStrategy = options.settings?.["layering.strategy"] ?? "NETWORK_SIMPLEX";
@@ -11003,7 +10958,7 @@ function runLayeredPipeline(graph, options, context) {
 		if (layeringStrategy === "NETWORK_SIMPLEX") return assignLayersWithNetworkSimplex;
 		if (layeringStrategy === "MIN_WIDTH") return assignLayersWithMinWidth;
 		if (layeringStrategy === "STRETCH_WIDTH") return assignLayersWithStretchWidth;
-		throw new UnsupportedLayoutError(`Layering strategy ${layeringStrategy} is not implemented yet`);
+		throw new require_routing.UnsupportedLayoutError(`Layering strategy ${layeringStrategy} is not implemented yet`);
 	})();
 	const assignment = measure("layer-assignment", () => applyHighDegreeNodeTreatment(input, orientation, applyNodePromotion(input, orientation, applyPartitions(input, applyLayerConstraints(input, layerAssigner(input, orientation))))));
 	let expanded = measure("long-edge-splitting", () => splitLongEdges(input, orientation, assignment));
@@ -11014,7 +10969,7 @@ function runLayeredPipeline(graph, options, context) {
 		if (crossingStrategy === "MEDIAN_LAYER_SWEEP") return minimizeCrossingsWithMedian(options.crossingSweeps);
 		if (crossingStrategy === "INTERACTIVE") return minimizeCrossingsInteractively;
 		if (crossingStrategy === "NONE") return minimizeCrossingsWithModelOrder;
-		throw new UnsupportedLayoutError(`Crossing-minimization strategy ${crossingStrategy} is not implemented`);
+		throw new require_routing.UnsupportedLayoutError(`Crossing-minimization strategy ${crossingStrategy} is not implemented`);
 	})();
 	let order = measure("crossing-minimization", () => applyLayerConstraintOrder(expanded.input, applyGreedySwitch(expanded.input, expanded.orientation, applySemiInteractiveOrder(expanded.input, applyForcedModelOrder(expanded.input, expanded.orientation, crossingMinimizer(expanded.input, expanded.orientation, expanded.assignment))))));
 	const unzippingFanIn = graph.edges.length === graph.nodes.length - 1 && graph.nodes.some((node) => graph.edges.filter((edge) => edge.targetId === node.id).length === graph.nodes.length - 1);
@@ -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",
@@ -11792,7 +11752,7 @@ const layeredAlgorithm = {
 	},
 	layout(graph, options, context) {
 		if (context.scope.mode === "partial" || context.scope.mode === "route-only") return context.measurePhase("partial-layout", () => runPartialLayout(graph, options ?? {}, context, getLayeredLayout));
-		if (context.constraints?.length && graph.nodes.some((node) => node.parentId != null)) throw new UnsupportedLayoutError("Full layout with geometry constraints does not support containers; use partial leaf constraints or full layout without geometry constraints");
+		if (context.constraints?.length && graph.nodes.some((node) => node.parentId != null)) throw new require_routing.UnsupportedLayoutError("Full layout with geometry constraints does not support containers; use partial leaf constraints or full layout without geometry constraints");
 		const result = runLayeredPipeline(graph, options ?? {}, context);
 		if (!context.constraints?.length) return result;
 		return context.measurePhase("constraints", () => runPartialLayout(result, options ?? {}, {
@@ -11813,18 +11773,6 @@ Object.defineProperty(exports, 'JavaRandom', {
     return JavaRandom;
   }
 });
-Object.defineProperty(exports, 'LayoutError', {
-  enumerable: true,
-  get: function () {
-    return LayoutError;
-  }
-});
-Object.defineProperty(exports, 'UnsupportedLayoutError', {
-  enumerable: true,
-  get: function () {
-    return UnsupportedLayoutError;
-  }
-});
 Object.defineProperty(exports, 'assignLayersByBreadthFirstModelOrder', {
   enumerable: true,
   get: function () {