@kekonic/diagrams-layout 1.0.0-rc.4

package/dist/index.mjs

@@ -0,0 +1,4068 @@
+import { classifyBranch, findColumnIndex, getKindDefaults, kindHasCapability, kindSubtitle, mergeOptions, sequenceFragmentDisplayName } from "@kekonic/diagrams-core";
+import { attachPointOnPerimeter, geometrySizeForContent, normalizeShapeId, relativeContentBox, resolveShapeGeometry } from "@kekonic/diagrams-geometry";
+import { iconDisplaySize, resolveIcon } from "@kekonic/diagrams-icons";
+import * as opentypeNs from "opentype.js";
+import ELK from "elkjs/lib/elk.bundled.js";
+//#region src/measure/font-measurer.ts
+const opentypeModule = opentypeNs;
+const opentype = typeof opentypeModule.parse === "function" ? opentypeModule : opentypeModule["default"];
+let cachedFont;
+function loadDefaultFont() {
+	if (typeof document !== "undefined") return null;
+	if (cachedFont !== void 0) return cachedFont;
+	try {
+		const runtimeProcess = globalThis.process;
+		const moduleBuiltin = runtimeProcess?.getBuiltinModule?.("module");
+		const fsBuiltin = runtimeProcess?.getBuiltinModule?.("fs");
+		if (!moduleBuiltin || !fsBuiltin) return null;
+		const { createRequire } = moduleBuiltin;
+		const { readFileSync } = fsBuiltin;
+		const buffer = readFileSync(createRequire(import.meta.url).resolve("@fontsource/inter/files/inter-latin-500-normal.woff"));
+		cachedFont = opentype.parse(buffer);
+		return cachedFont;
+	} catch {
+		cachedFont = null;
+		return null;
+	}
+}
+function createFontFileMeasurer() {
+	const font = loadDefaultFont();
+	if (!font) return null;
+	return {
+		measureText(text, style) {
+			const scale = style.fontSize / font.unitsPerEm;
+			let width = 0;
+			for (const ch of text) {
+				const glyph = font.charToGlyph(ch);
+				width += (glyph.advanceWidth ?? 0) * scale;
+			}
+			const ascent = (font.ascender ?? font.unitsPerEm * .8) * scale;
+			const descent = Math.abs(font.descender ?? font.unitsPerEm * .2) * scale;
+			return {
+				width,
+				height: ascent + descent,
+				ascent,
+				descent
+			};
+		},
+		wrapText(text, options) {
+			const words = text.split(/\s+/);
+			const lines = [];
+			let current = "";
+			let maxW = 0;
+			for (const word of words) {
+				const test = current ? `${current} ${word}` : word;
+				if (this.measureText(test, options.style).width > options.maxWidth && current) {
+					lines.push(current);
+					maxW = Math.max(maxW, this.measureText(current, options.style).width);
+					current = word;
+				} else current = test;
+			}
+			if (current) {
+				lines.push(current);
+				maxW = Math.max(maxW, this.measureText(current, options.style).width);
+			}
+			const lineH = options.style.fontSize * LINE_HEIGHT;
+			return {
+				lines: lines.length ? lines : [text],
+				width: maxW,
+				height: (lines.length || 1) * lineH
+			};
+		}
+	};
+}
+//#endregion
+//#region src/measure/text-measurer.ts
+/** Shared font metrics — browser canvas and approximate server fallback. */
+const DEFAULT_FONT_FAMILY = "\"Inter\", \"Segoe UI\", system-ui, sans-serif";
+const LINE_HEIGHT = 1.2;
+const CHAR_WIDTH_RATIO = .55;
+let measurerUsesFallback = false;
+function measurerUsedApproximationFallback() {
+	return measurerUsesFallback;
+}
+function createDefaultMeasurer() {
+	if (typeof document !== "undefined") return createCanvasMeasurer();
+	const fontMeasurer = createFontFileMeasurer();
+	if (fontMeasurer) return fontMeasurer;
+	measurerUsesFallback = true;
+	return createApproximateMeasurer();
+}
+function createApproximateMeasurer() {
+	return {
+		measureText(text, style) {
+			return {
+				width: text.length * style.fontSize * CHAR_WIDTH_RATIO,
+				height: style.fontSize * LINE_HEIGHT,
+				ascent: style.fontSize * .8,
+				descent: style.fontSize * .2
+			};
+		},
+		wrapText(text, options) {
+			const words = text.split(/\s+/);
+			const lines = [];
+			let current = "";
+			let maxW = 0;
+			for (const word of words) {
+				const test = current ? `${current} ${word}` : word;
+				if (test.length * options.style.fontSize * CHAR_WIDTH_RATIO > options.maxWidth && current) {
+					lines.push(current);
+					maxW = Math.max(maxW, current.length * options.style.fontSize * CHAR_WIDTH_RATIO);
+					current = word;
+				} else current = test;
+			}
+			if (current) {
+				lines.push(current);
+				maxW = Math.max(maxW, current.length * options.style.fontSize * CHAR_WIDTH_RATIO);
+			}
+			const lineH = options.style.fontSize * LINE_HEIGHT;
+			return {
+				lines: lines.length ? lines : [text],
+				width: maxW,
+				height: (lines.length || 1) * lineH
+			};
+		}
+	};
+}
+function createCanvasMeasurer(canvas) {
+	const ctx = (canvas ?? (typeof document !== "undefined" ? document.createElement("canvas") : null))?.getContext("2d") ?? null;
+	return {
+		measureText(text, style) {
+			if (ctx) {
+				ctx.font = `${style.fontWeight ?? "500"} ${style.fontSize}px ${style.fontFamily}`;
+				const m = ctx.measureText(text);
+				const ascent = m.actualBoundingBoxAscent ?? style.fontSize * .8;
+				const descent = m.actualBoundingBoxDescent ?? style.fontSize * .2;
+				return {
+					width: m.width,
+					height: ascent + descent,
+					ascent,
+					descent
+				};
+			}
+			return {
+				width: text.length * style.fontSize * CHAR_WIDTH_RATIO,
+				height: style.fontSize * LINE_HEIGHT,
+				ascent: style.fontSize * .8,
+				descent: style.fontSize * .2
+			};
+		},
+		wrapText(text, options) {
+			const words = text.split(/\s+/);
+			const lines = [];
+			let current = "";
+			let maxW = 0;
+			for (const word of words) {
+				const test = current ? `${current} ${word}` : word;
+				if (this.measureText(test, options.style).width > options.maxWidth && current) {
+					lines.push(current);
+					maxW = Math.max(maxW, this.measureText(current, options.style).width);
+					current = word;
+				} else current = test;
+			}
+			if (current) {
+				lines.push(current);
+				maxW = Math.max(maxW, this.measureText(current, options.style).width);
+			}
+			const lineH = options.style.fontSize * LINE_HEIGHT;
+			return {
+				lines: lines.length ? lines : [text],
+				width: maxW,
+				height: (lines.length || 1) * lineH
+			};
+		}
+	};
+}
+let _defaultMeasurer;
+function resetDefaultMeasurer() {
+	_defaultMeasurer = void 0;
+	measurerUsesFallback = false;
+}
+function lazyDefaultMeasurer() {
+	if (!_defaultMeasurer) _defaultMeasurer = createDefaultMeasurer();
+	return _defaultMeasurer;
+}
+const defaultMeasurer = {
+	measureText(text, style) {
+		return lazyDefaultMeasurer().measureText(text, style);
+	},
+	wrapText(text, options) {
+		return lazyDefaultMeasurer().wrapText(text, options);
+	}
+};
+//#endregion
+//#region src/measure/table-measure.ts
+/** Dense ERD chrome — flatter and tighter than architecture cards. */
+const TABLE_PAD_X = 10;
+const TABLE_HEADER_H = 28;
+const TABLE_ROW_H = 20;
+/** Badge chip width — must match SVG render. */
+const TABLE_BADGE_W = 18;
+const TABLE_BADGE_GAP = 3;
+/**
+* Fixed key-badge gutter (fits PK+FK, or empty spacer).
+* Names always start at padX + KEY_COL regardless of how many key chips are present.
+*/
+const TABLE_KEY_COL = 43;
+const TABLE_RX = 4;
+/** Gap between type / NN / note in the right-side attrs cluster. */
+const TABLE_ATTR_GAP = 6;
+function isErdTableNode(node) {
+	return node.shape === "table" && Boolean(node.columns && node.columns.length > 0);
+}
+function columnAnchorY(tableTop, rowIndex, scale = 1) {
+	const headerH = 28 * scale;
+	const rowH = 20 * scale;
+	return tableTop + headerH + rowIndex * rowH + rowH / 2;
+}
+/** SQL-ish type only — muted mono on the right (flags/notes are separate). */
+function columnTypeLabel(col) {
+	return col.type?.trim() ?? "";
+}
+/** Enum / comment secondary text — never joined into the type with bullets. */
+function columnNoteLabel(col) {
+	return col.note?.trim() ?? "";
+}
+/**
+* Size an ERD table card from its title + columns using the shared text measurer.
+*/
+function measureTableNode(node, measurer, scale, effectiveMinW, _effectiveMaxW) {
+	const padX = 10 * scale;
+	const headerH = 28 * scale;
+	const rowH = 20 * scale;
+	const keyCol = 43 * scale;
+	const typeGap = 10 * scale;
+	const attrGap = 6 * scale;
+	const titleSize = 12 * scale;
+	const colNameSize = 11 * scale;
+	const colTypeSize = 10 * scale;
+	const colNoteSize = 9.5 * scale;
+	const titleMetrics = measurer.measureText(node.label, {
+		fontSize: titleSize,
+		fontFamily: DEFAULT_FONT_FAMILY,
+		fontWeight: "700"
+	});
+	let maxRowContent = 0;
+	const columns = node.columns ?? [];
+	for (const col of columns) {
+		const nameW = measurer.measureText(col.name, {
+			fontSize: colNameSize,
+			fontFamily: DEFAULT_FONT_FAMILY,
+			fontWeight: "600"
+		}).width;
+		const typeLabel = columnTypeLabel(col);
+		const noteLabel = columnNoteLabel(col);
+		const typeW = typeLabel ? measurer.measureText(typeLabel, {
+			fontSize: colTypeSize,
+			fontFamily: DEFAULT_FONT_FAMILY,
+			fontWeight: "500"
+		}).width : 0;
+		const noteW = noteLabel ? measurer.measureText(noteLabel, {
+			fontSize: colNoteSize,
+			fontFamily: DEFAULT_FONT_FAMILY,
+			fontWeight: "500"
+		}).width : 0;
+		const parts = [
+			typeW,
+			col.notNull ? measurer.measureText("NN", {
+				fontSize: colTypeSize,
+				fontFamily: DEFAULT_FONT_FAMILY,
+				fontWeight: "700"
+			}).width : 0,
+			noteW
+		].filter((w) => w > 0);
+		const attrsW = parts.reduce((sum, w) => sum + w, 0) + Math.max(0, parts.length - 1) * attrGap;
+		maxRowContent = Math.max(maxRowContent, keyCol + nameW + (attrsW ? typeGap + attrsW : 0));
+	}
+	const contentW = Math.max(titleMetrics.width + 8 * scale, maxRowContent) + padX * 2;
+	return {
+		width: Math.max(effectiveMinW, 180 * scale, contentW),
+		height: headerH + Math.max(1, columns.length) * rowH,
+		headerHeight: headerH,
+		rowHeight: rowH,
+		labelLines: [node.label]
+	};
+}
+/** Key chips only (PK/FK/UK) — fixed left gutter; NN is not a key. */
+function tableKeyBadges(col) {
+	const badges = [];
+	if (col.keys.includes("pk")) badges.push("PK");
+	if (col.keys.includes("fk")) badges.push("FK");
+	if (col.keys.includes("uk")) badges.push("UK");
+	return badges;
+}
+//#endregion
+//#region src/measure/measure.ts
+const PADDING_X = 22;
+const PADDING_Y = 20;
+const RICH_PADDING_Y = 26;
+const ICON_BLOCK = 28;
+const SUBTITLE_HEIGHT = 15;
+const TECHNOLOGY_HEIGHT = 14;
+const DESCRIPTION_LINE_HEIGHT = 14;
+const SECTION_GAP = 4;
+const NOTE_HEIGHT = 14;
+const MIN_ICON_COL = 32;
+const CARD_ICON_HEIGHT = 20;
+/** Matches SVG `CARD_PAD + ICON_TEXT_GAP` (18 + 12). */
+const CARD_ICON_PAD = 30;
+const ICON_ONLY_SIZE = 64;
+const ICON_ONLY_CAPTION = 16;
+const SHAPE_EXTRA = {
+	diamond: {
+		w: 36,
+		h: 36
+	},
+	cylinder: {
+		w: 10,
+		h: 22
+	},
+	hexagon: {
+		w: 18,
+		h: 10
+	},
+	person: {
+		w: 24,
+		h: 0
+	},
+	queue: {
+		w: 18,
+		h: 18
+	},
+	parallelogram: {
+		w: 24,
+		h: 8
+	},
+	trapezoid: {
+		w: 20,
+		h: 8
+	},
+	triangle: {
+		w: 16,
+		h: 20
+	},
+	document: {
+		w: 8,
+		h: 16
+	},
+	"folded-document": {
+		w: 8,
+		h: 12
+	},
+	cloud: {
+		w: 28,
+		h: 24
+	},
+	circle: {
+		w: 12,
+		h: 12
+	},
+	ellipse: {
+		w: 16,
+		h: 16
+	},
+	boundary: {
+		w: 8,
+		h: 8
+	}
+};
+/** Left icon column width for card nodes (matches SVG placement). */
+function cardIconColumnWidth(iconId, scale = 1) {
+	const height = CARD_ICON_HEIGHT * scale;
+	const { width } = iconDisplaySize(resolveIcon(iconId) ?? {
+		width: 1,
+		height: 1
+	}, height);
+	return Math.max(MIN_ICON_COL * scale, width);
+}
+function measureGraph(graph, measurer = defaultMeasurer, options = {}) {
+	const start = performance.now();
+	const nodes = [];
+	for (const node of graph.nodes) {
+		const shape = normalizeShapeId(node.shape ?? "rounded");
+		const geometry = resolveShapeGeometry(shape);
+		const cardShape = shape === "rounded" || shape === "rectangle" || shape === "pill";
+		const hasIcon = Boolean(node.icon && node.icon !== "none");
+		const { defaults: kindDefaults } = getKindDefaults(node.kind);
+		const iconOnly = kindHasCapability(node.kind, "icon-only") || kindDefaults.capabilities.includes("icon-only");
+		const scale = node.scale && node.scale > 0 ? node.scale : 1;
+		const fontSize = 15 * scale;
+		const padX = PADDING_X * scale;
+		const padY = (Boolean(node.technology && node.technology.trim() || node.description && node.description.trim()) ? RICH_PADDING_Y : PADDING_Y) * scale;
+		const minBoxH = 56 * scale;
+		const effectiveMinW = (node.minWidth ?? kindDefaults.defaultMinWidth) * (node.minWidth ? 1 : scale);
+		const effectiveMaxW = (node.maxWidth ?? kindDefaults.defaultMaxWidth) * (node.maxWidth ? 1 : scale);
+		if (iconOnly) {
+			const caption = node.labelAuthored ? measurer.wrapText(node.label, {
+				maxWidth: effectiveMaxW - padX,
+				style: {
+					fontSize: fontSize * .72,
+					fontFamily: DEFAULT_FONT_FAMILY,
+					fontWeight: "700"
+				}
+			}) : {
+				lines: [],
+				width: 0,
+				height: 0
+			};
+			const side = Math.max(effectiveMinW, Math.min(effectiveMaxW, ICON_ONLY_SIZE * scale + (caption.height > 0 ? ICON_ONLY_CAPTION * scale : 0)));
+			const height = Math.max(side, ICON_ONLY_SIZE * scale + caption.height);
+			nodes.push({
+				nodeId: node.id,
+				width: side,
+				height,
+				contentBox: relativeContentBox(geometry, side, height),
+				labelLines: caption.lines
+			});
+			continue;
+		}
+		if (shape === "table" && node.columns && node.columns.length > 0) {
+			const table = measureTableNode(node, measurer, scale, effectiveMinW, effectiveMaxW);
+			nodes.push({
+				nodeId: node.id,
+				width: table.width,
+				height: table.height,
+				contentBox: relativeContentBox(geometry, table.width, table.height),
+				labelLines: table.labelLines
+			});
+			continue;
+		}
+		if (shape === "diamond") {
+			const innerMaxW = (effectiveMaxW - padX * 2) * .58;
+			const wrapped = measurer.wrapText(node.label, {
+				maxWidth: innerMaxW,
+				style: {
+					fontSize,
+					fontFamily: DEFAULT_FONT_FAMILY,
+					fontWeight: "800"
+				}
+			});
+			const contentNeed = {
+				width: Math.max(...wrapped.lines.map((line) => measurer.measureText(line, {
+					fontSize,
+					fontFamily: DEFAULT_FONT_FAMILY,
+					fontWeight: "800"
+				}).width), wrapped.width) + padX * 2,
+				height: wrapped.height + padY * 2
+			};
+			const sized = geometrySizeForContent(geometry, contentNeed, {
+				width: Math.max(effectiveMinW, contentNeed.width * 1.7),
+				height: Math.max(80 * scale, contentNeed.height * 1.9)
+			});
+			const width = Math.max(effectiveMinW, sized.width);
+			const height = Math.max(80 * scale, sized.height);
+			nodes.push({
+				nodeId: node.id,
+				width,
+				height,
+				contentBox: relativeContentBox(geometry, width, height),
+				labelLines: wrapped.lines
+			});
+			continue;
+		}
+		const iconCol = cardShape && hasIcon && node.icon ? cardIconColumnWidth(node.icon, scale) : 0;
+		const wrapped = measurer.wrapText(node.label, {
+			maxWidth: effectiveMaxW - padX * 2 - iconCol,
+			style: {
+				fontSize,
+				fontFamily: DEFAULT_FONT_FAMILY,
+				fontWeight: "800"
+			}
+		});
+		const extra = SHAPE_EXTRA[shape] ?? {
+			w: 0,
+			h: 0
+		};
+		const iconW = cardShape && hasIcon ? iconCol + CARD_ICON_PAD * scale : hasIcon ? 8 * scale : 0;
+		const iconH = hasIcon && !cardShape ? ICON_BLOCK * scale : 0;
+		const authoredSubtitle = node.subtitle?.trim() ? node.subtitle.trim() : void 0;
+		const wantsSubtitle = Boolean(authoredSubtitle) || node.showSubtitle === true || options.reserveKindSubtitles;
+		const subtitleH = wantsSubtitle ? SUBTITLE_HEIGHT * scale : 0;
+		let subtitleW = 0;
+		if (wantsSubtitle) {
+			const subtitleSize = fontSize * (10.5 / 15);
+			const subtitleText = (authoredSubtitle ?? kindSubtitle(node.kind)).toUpperCase();
+			subtitleW = measurer.measureText(subtitleText, {
+				fontSize: subtitleSize,
+				fontFamily: DEFAULT_FONT_FAMILY,
+				fontWeight: "600"
+			}).width + Math.max(0, subtitleText.length - 1) * subtitleSize * .05;
+		}
+		const noteH = node.note ? NOTE_HEIGHT * scale : 0;
+		let noteW = 0;
+		if (node.note) noteW = measurer.measureText(node.note, {
+			fontSize: fontSize * (9 / 15),
+			fontFamily: DEFAULT_FONT_FAMILY,
+			fontWeight: "400"
+		}).width;
+		const technology = node.technology?.trim() ? node.technology.trim() : void 0;
+		const description = node.description?.trim() ? node.description.trim() : void 0;
+		const textMaxW = effectiveMaxW - padX * 2 - iconCol;
+		const sectionGap = SECTION_GAP * scale;
+		let technologyLines;
+		let technologyW = 0;
+		let technologyH = 0;
+		if (technology) {
+			const techSize = fontSize * (11 / 15);
+			const techWrap = measurer.wrapText(technology, {
+				maxWidth: textMaxW,
+				style: {
+					fontSize: techSize,
+					fontFamily: DEFAULT_FONT_FAMILY,
+					fontWeight: "500"
+				}
+			});
+			technologyLines = techWrap.lines;
+			technologyW = techWrap.width;
+			technologyH = technologyLines.length * TECHNOLOGY_HEIGHT * scale;
+		}
+		let descriptionLines;
+		let descriptionW = 0;
+		let descriptionH = 0;
+		if (description) {
+			const descSize = fontSize * (11 / 15);
+			const descWrap = measurer.wrapText(description, {
+				maxWidth: textMaxW,
+				style: {
+					fontSize: descSize,
+					fontFamily: DEFAULT_FONT_FAMILY,
+					fontWeight: "500"
+				}
+			});
+			descriptionLines = descWrap.lines;
+			descriptionW = descWrap.width;
+			descriptionH = descriptionLines.length * DESCRIPTION_LINE_HEIGHT * scale;
+		}
+		const afterSubtitleGap = technologyLines || descriptionLines ? sectionGap : 0;
+		const afterTechGap = technologyLines && descriptionLines ? sectionGap : 0;
+		const personIconH = shape === "person" && hasIcon ? ICON_BLOCK * scale : shape === "person" ? 0 : iconH;
+		const textStackH = wrapped.height + subtitleH + afterSubtitleGap + technologyH + afterTechGap + descriptionH + noteH;
+		const contentW = Math.max(wrapped.width, subtitleW, technologyW, descriptionW, noteW) + padX * 2 + extra.w * scale + iconW;
+		const contentH = textStackH + padY * 2 + extra.h * scale + personIconH;
+		let width = Math.max(effectiveMinW, contentW);
+		const stretch = contentW > 0 && width > contentW ? Math.min(width / contentW, 1.45) : 1;
+		let height = Math.max(minBoxH, contentH * stretch);
+		if (shape === "hexagon" || shape === "queue") height = Math.max(height, width * .44);
+		if (shape === "cylinder") height = Math.max(height, Math.min(width * .55, 96 * scale));
+		if (cardShape) {
+			const sized = geometrySizeForContent(geometry, {
+				width: Math.max(wrapped.width, subtitleW, technologyW, descriptionW, noteW) + iconW,
+				height: textStackH
+			}, {
+				width,
+				height
+			});
+			width = Math.max(width, sized.width);
+			height = Math.max(height, sized.height);
+		}
+		if (shape === "cloud") width = Math.max(width, height * 1.5);
+		if (shape === "person") {
+			const bodyW = Math.max(effectiveMinW, contentW);
+			const bodyH = Math.max(56 * scale, textStackH + padY * 2 + personIconH);
+			const bodyHalfW = Math.max(18, bodyW / 2 - 2);
+			const headR = Math.max(10, Math.min(22, bodyHalfW * .38));
+			const headStack = headR * 2 + Math.max(2, headR * .18) + 6;
+			width = bodyW;
+			height = headStack + bodyH;
+		}
+		if (shape === "circle") {
+			const side = Math.max(width, height);
+			width = side;
+			height = side;
+		}
+		nodes.push({
+			nodeId: node.id,
+			width,
+			height,
+			contentBox: relativeContentBox(geometry, width, height),
+			labelLines: wrapped.lines,
+			technologyLines,
+			descriptionLines
+		});
+	}
+	return {
+		nodes,
+		measureMs: performance.now() - start
+	};
+}
+//#endregion
+//#region src/layout/constants.ts
+const DENSITY_GAP = {
+	compact: 56,
+	normal: 88,
+	spacious: 116
+};
+const DEFAULT_GROUP_PADDING = {
+	top: 56,
+	right: 40,
+	bottom: 40,
+	left: 40
+};
+/** Chromeless layout planes — no label headroom. */
+const LAYOUT_ONLY_GROUP_PADDING = {
+	top: 20,
+	right: 20,
+	bottom: 20,
+	left: 20
+};
+const PADDING_HINTS = {
+	compact: {
+		top: 36,
+		right: 24,
+		bottom: 24,
+		left: 24
+	},
+	normal: {
+		top: 56,
+		right: 40,
+		bottom: 40,
+		left: 40
+	},
+	spacious: {
+		top: 88,
+		right: 60,
+		bottom: 60,
+		left: 60
+	},
+	/** Iso-pixel platforms need extra pad so chunky cards + pipes clear the rim. */
+	pixel: {
+		top: 100,
+		right: 80,
+		bottom: 80,
+		left: 80
+	}
+};
+//#endregion
+//#region src/layout/group-bounds.ts
+const GROUP_LABEL_FONT_SIZE = 11;
+const GROUP_LABEL_PADDING_X = 14;
+const GROUP_LABEL_PADDING_Y = 10;
+const GROUP_ICON_SIZE = 14;
+const GROUP_ICON_GAP = 6;
+function paddingForGroup(group) {
+	const chromeless = group.chrome === false;
+	if (group.paddingHint && PADDING_HINTS[group.paddingHint]) {
+		const p = PADDING_HINTS[group.paddingHint];
+		if (chromeless) return {
+			top: p.left,
+			right: p.right,
+			bottom: p.bottom,
+			left: p.left
+		};
+		return p;
+	}
+	if (group.paddingHint != null) {
+		const n = Number(group.paddingHint);
+		if (Number.isFinite(n) && n >= 0) {
+			const box = {
+				top: n,
+				right: n,
+				bottom: n,
+				left: n
+			};
+			if (chromeless) return {
+				top: n,
+				right: n,
+				bottom: n,
+				left: n
+			};
+			return box;
+		}
+	}
+	if (chromeless) return LAYOUT_ONLY_GROUP_PADDING;
+	return DEFAULT_GROUP_PADDING;
+}
+function groupBoundsFromNodes(graph, laidOut, padding) {
+	const nodeMap = new Map(laidOut.map((n) => [n.nodeId, n]));
+	const result = /* @__PURE__ */ new Map();
+	for (const group of graph.groups) {
+		const memberBounds = group.nodeIds.map((id) => nodeMap.get(id)?.bounds).filter((b) => !!b);
+		if (!memberBounds.length) continue;
+		let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+		for (const b of memberBounds) {
+			minX = Math.min(minX, b.x);
+			minY = Math.min(minY, b.y);
+			maxX = Math.max(maxX, b.x + b.width);
+			maxY = Math.max(maxY, b.y + b.height);
+		}
+		result.set(group.id, {
+			x: minX - padding.left,
+			y: minY - padding.top,
+			width: maxX - minX + padding.left + padding.right,
+			height: maxY - minY + padding.top + padding.bottom
+		});
+	}
+	return result;
+}
+function measureGroupLabelBox(label, bounds, hasIcon = false) {
+	const text = label.toUpperCase();
+	const charWidth = GROUP_LABEL_FONT_SIZE * .5740000000000001;
+	const iconExtra = hasIcon ? 20 : 0;
+	const width = Math.min(Math.max(text.length * charWidth + 8 + iconExtra, 48), Math.max(bounds.width - 8, 48));
+	return {
+		x: bounds.x + GROUP_LABEL_PADDING_X,
+		y: bounds.y + GROUP_LABEL_PADDING_Y,
+		width,
+		height: 19
+	};
+}
+function computeGroupBounds(graph, laidOut) {
+	const result = [];
+	for (const group of graph.groups) {
+		const padding = paddingForGroup(group);
+		const bounds = groupBoundsFromNodes(graph, laidOut, padding).get(group.id);
+		if (!bounds) continue;
+		const hasIcon = Boolean(group.icon && group.icon !== "none" && group.chrome !== false);
+		result.push({
+			groupId: group.id,
+			bounds,
+			labelBox: measureGroupLabelBox(group.label, bounds, hasIcon),
+			padding
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/direction/index.ts
+/** True for left↔right flow (`LR` / `RL`). */
+function isHorizontal(direction) {
+	return direction === "LR" || direction === "RL";
+}
+/** True for top↔bottom flow (`TD` / `BT`). */
+function isVertical(direction) {
+	return direction === "TD" || direction === "BT";
+}
+//#endregion
+//#region src/topology/analyze.ts
+function buildEdgeCounts(graph) {
+	const incoming = /* @__PURE__ */ new Map();
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		incoming.set(node.id, 0);
+		outgoing.set(node.id, 0);
+	}
+	for (const edge of graph.edges) {
+		outgoing.set(edge.from, (outgoing.get(edge.from) ?? 0) + 1);
+		incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+	}
+	return {
+		incoming,
+		outgoing
+	};
+}
+function analyzeDiagramTopology(graph, direction) {
+	const { incoming, outgoing } = buildEdgeCounts(graph);
+	const choiceNodes = [];
+	const choiceBranches = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if (node.kind === "choice" && (outgoing.get(node.id) ?? 0) >= 2) {
+		choiceNodes.push(node.id);
+		choiceBranches.add(node.id);
+	}
+	const mergeNodes = [];
+	const fanOutNodes = [];
+	for (const node of graph.nodes) {
+		if ((incoming.get(node.id) ?? 0) >= 2) mergeNodes.push(node.id);
+		if ((outgoing.get(node.id) ?? 0) >= 2) fanOutNodes.push(node.id);
+	}
+	return {
+		direction,
+		isWorkflowTD: isVertical(direction) && choiceNodes.length > 0,
+		choiceNodes,
+		mergeNodes,
+		fanOutNodes,
+		choiceBranches,
+		incoming,
+		outgoing
+	};
+}
+function incomingCount(topology, nodeId) {
+	return topology.incoming.get(nodeId) ?? 0;
+}
+function outgoingCount(topology, nodeId) {
+	return topology.outgoing.get(nodeId) ?? 0;
+}
+function isChoiceBranch(topology, nodeId) {
+	return topology.choiceBranches.has(nodeId);
+}
+//#endregion
+//#region src/layout/elk/edge-priority.ts
+function layoutBranchCue(edge) {
+	return edge.branch ?? classifyBranch(edge.label);
+}
+/**
+* Prefer a straight happy-path spine; keep exception edges short instead of scenic.
+* Explicit GraphEdge.priority amplifies or dampens the cue.
+*/
+function elkPriorityOptionsForEdge(edge) {
+	const cue = layoutBranchCue(edge);
+	let straightness = 3;
+	let shortness = 3;
+	if (edge.kind === "failure" || cue === "no") {
+		straightness = 1;
+		shortness = 9;
+	} else if (cue === "yes") {
+		straightness = 9;
+		shortness = 5;
+	} else if (!edge.label) {
+		straightness = 7;
+		shortness = 4;
+	}
+	if (edge.priority === "high") {
+		straightness += 3;
+		shortness += 2;
+	} else if (edge.priority === "low") {
+		straightness = Math.max(0, straightness - 4);
+		if (cue !== "no" && edge.kind !== "failure") shortness = Math.max(1, shortness - 1);
+	}
+	return {
+		"elk.layered.priority.straightness": String(straightness),
+		"elk.layered.priority.shortness": String(shortness)
+	};
+}
+//#endregion
+//#region src/layout/elk/elk-ports.ts
+function flowExitSide(direction) {
+	switch (direction) {
+		case "BT": return "NORTH";
+		case "LR": return "EAST";
+		case "RL": return "WEST";
+		default: return "SOUTH";
+	}
+}
+function flowEntrySide(direction) {
+	switch (direction) {
+		case "BT": return "SOUTH";
+		case "LR": return "WEST";
+		case "RL": return "EAST";
+		default: return "NORTH";
+	}
+}
+function elkSideToGeometry(side) {
+	switch (side) {
+		case "NORTH": return "north";
+		case "EAST": return "east";
+		case "WEST": return "west";
+		default: return "south";
+	}
+}
+function outPortId(nodeId, edgeId) {
+	return `${nodeId}:out:${edgeId}`;
+}
+function inPortId(nodeId, edgeId) {
+	return `${nodeId}:in:${edgeId}`;
+}
+/** Geometry-authored 1×1 FIXED_POS port centered on getPortPosition. */
+function makeGeometryPort(id, side, index, count, shapeId, width, height) {
+	const geometry = resolveShapeGeometry(normalizeShapeId(shapeId));
+	const local = {
+		x: 0,
+		y: 0,
+		width,
+		height
+	};
+	const pos = geometry.getPortPosition({
+		kind: "side",
+		side: elkSideToGeometry(side),
+		index,
+		count
+	}, local);
+	return {
+		id,
+		x: pos.x - .5,
+		y: pos.y - .5,
+		width: 1,
+		height: 1,
+		layoutOptions: {
+			"elk.port.side": side,
+			"elk.port.index": String(index)
+		}
+	};
+}
+function outRank(edge) {
+	const cue = layoutBranchCue(edge);
+	if (cue === "yes") return 0;
+	if (cue === "no") return 2;
+	return 1;
+}
+/**
+* Edges that participate in a 2-cycle (A→B and B→A).
+* These stay node→node so ELK free-attaches parallel corridor shafts.
+*/
+function mutualEdgeIds(graph) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) {
+		if (edge.from === edge.to) continue;
+		if (graph.edges.some((o) => o.id !== edge.id && o.from === edge.to && o.to === edge.from)) ids.add(edge.id);
+	}
+	return ids;
+}
+function materializeFacePorts(specs, shapeId, width, height) {
+	const bySide = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		const list = bySide.get(spec.side) ?? [];
+		list.push(spec);
+		bySide.set(spec.side, list);
+	}
+	const ports = [];
+	for (const [side, list] of bySide) {
+		list.sort((a, b) => a.rank - b.rank || a.edgeId.localeCompare(b.edgeId));
+		const count = list.length;
+		list.forEach((spec, index) => {
+			ports.push(makeGeometryPort(spec.id, side, index, count, shapeId, width, height));
+		});
+	}
+	return ports;
+}
+/**
+* Assign one out-port and one in-port per non-mutual edge.
+* Positions are distributed per face so N edges on a face ⇒ N distinct pins.
+*/
+function assignEdgePorts(graph, measured, direction) {
+	const measureMap = new Map(measured.map((m) => [m.nodeId, m]));
+	const shapeByNode = new Map(graph.nodes.map((n) => [n.id, n.shape]));
+	const exit = flowExitSide(direction);
+	const entry = flowEntrySide(direction);
+	const mutual = mutualEdgeIds(graph);
+	const outSpecsByNode = /* @__PURE__ */ new Map();
+	const inSpecsByNode = /* @__PURE__ */ new Map();
+	const edgeSourcePort = /* @__PURE__ */ new Map();
+	const edgeTargetPort = /* @__PURE__ */ new Map();
+	const push = (map, nodeId, spec) => {
+		const list = map.get(nodeId) ?? [];
+		list.push(spec);
+		map.set(nodeId, list);
+	};
+	for (const edge of graph.edges) {
+		if (mutual.has(edge.id)) continue;
+		const sourceId = outPortId(edge.from, edge.id);
+		const targetId = inPortId(edge.to, edge.id);
+		edgeSourcePort.set(edge.id, sourceId);
+		edgeTargetPort.set(edge.id, targetId);
+		push(outSpecsByNode, edge.from, {
+			id: sourceId,
+			edgeId: edge.id,
+			side: exit,
+			rank: outRank(edge)
+		});
+		push(inSpecsByNode, edge.to, {
+			id: targetId,
+			edgeId: edge.id,
+			side: entry,
+			rank: 1
+		});
+	}
+	const portsByNode = /* @__PURE__ */ new Map();
+	const portedNodes = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) {
+		const m = measureMap.get(node.id);
+		if (!m) continue;
+		const outs = outSpecsByNode.get(node.id) ?? [];
+		const inns = inSpecsByNode.get(node.id) ?? [];
+		if (!outs.length && !inns.length) continue;
+		portedNodes.add(node.id);
+		const shapeId = shapeByNode.get(node.id);
+		portsByNode.set(node.id, [...materializeFacePorts(outs, shapeId, m.width, m.height), ...materializeFacePorts(inns, shapeId, m.width, m.height)]);
+	}
+	return {
+		portsByNode,
+		edgeSourcePort,
+		edgeTargetPort,
+		portedNodes
+	};
+}
+//#endregion
+//#region src/layout/elk/polish-edges.ts
+const COLINEAR_EPS = .75;
+/** Drop redundant colinear waypoints from orthogonal ELK polylines.
+* Unlike route-orthogonal-avoid's search collapse, this may drop stubs once
+* attach points are frozen by snapEdgeEndpointsToGeometry.
+*/
+function collapseColinearPoints(points, eps = COLINEAR_EPS) {
+	if (points.length < 3) return points;
+	const out = [points[0]];
+	for (let i = 1; i < points.length - 1; i++) {
+		const a = out[out.length - 1];
+		const b = points[i];
+		const c = points[i + 1];
+		const vertical = Math.abs(a.x - b.x) < eps && Math.abs(b.x - c.x) < eps;
+		const horizontal = Math.abs(a.y - b.y) < eps && Math.abs(b.y - c.y) < eps;
+		if (vertical || horizontal) continue;
+		out.push(b);
+	}
+	out.push(points[points.length - 1]);
+	return out;
+}
+function rangesOverlap$1(a0, a1, b0, b1) {
+	return Math.min(a0, a1) <= Math.max(b0, b1) && Math.max(a0, a1) >= Math.min(b0, b1);
+}
+/** Move segment endpoints that are not path termini (attach points stay fixed). */
+function setSegmentCoord(out, segIndex, axis, value) {
+	const i = segIndex;
+	const last = out.length - 1;
+	if (i > 0) out[i][axis] = value;
+	if (i + 1 < last) out[i + 1][axis] = value;
+}
+/**
+* Shift orthogonal corridors that run inside the keep-out around node cards
+* so 90° corners aren't parked flush on a shape edge.
+* Path endpoints (port attaches) are never moved.
+*/
+function clearOrthogonalCorridors(points, nodes, pad) {
+	if (points.length < 3 || nodes.length === 0 || pad <= 0) return points;
+	const out = points.map((p) => ({
+		x: p.x,
+		y: p.y
+	}));
+	for (let pass = 0; pass < 3; pass++) {
+		let moved = false;
+		for (let i = 0; i < out.length - 1; i++) {
+			if (i === 0 || i === out.length - 2) continue;
+			const a = out[i];
+			const b = out[i + 1];
+			const vert = Math.abs(a.x - b.x) < COLINEAR_EPS;
+			const horz = Math.abs(a.y - b.y) < COLINEAR_EPS;
+			if (!vert && !horz) continue;
+			for (const box of nodes) {
+				const L = box.x;
+				const R = box.x + box.width;
+				const T = box.y;
+				const B = box.y + box.height;
+				if (vert) {
+					const x = (a.x + b.x) / 2;
+					if (!rangesOverlap$1(a.y, b.y, T - pad, B + pad)) continue;
+					if (x > L - pad && x < L) {
+						setSegmentCoord(out, i, "x", L - pad);
+						moved = true;
+					} else if (x > R && x < R + pad) {
+						setSegmentCoord(out, i, "x", R + pad);
+						moved = true;
+					}
+				} else {
+					const y = (a.y + b.y) / 2;
+					if (!rangesOverlap$1(a.x, b.x, L - pad, R + pad)) continue;
+					if (y > T - pad && y < T) {
+						setSegmentCoord(out, i, "y", T - pad);
+						moved = true;
+					} else if (y > B && y < B + pad) {
+						setSegmentCoord(out, i, "y", B + pad);
+						moved = true;
+					}
+				}
+			}
+		}
+		if (!moved) break;
+	}
+	return out;
+}
+/**
+* Repair any residual non-orthogonal stubs (e.g. ELK diagonal tips) by inserting
+* one corner so metro/rounded stroke rendering never draws a slash to the port.
+*/
+function ensureOrthogonalPoints(points, eps = COLINEAR_EPS) {
+	if (points.length < 2) return points;
+	const out = [{ ...points[0] }];
+	for (let i = 1; i < points.length; i++) {
+		const prev = out[out.length - 1];
+		const curr = points[i];
+		const dx = Math.abs(curr.x - prev.x);
+		const dy = Math.abs(curr.y - prev.y);
+		if (dx > eps && dy > eps) {
+			const before = out.length >= 2 ? out[out.length - 2] : null;
+			const preferVertical = before != null ? Math.abs(before.x - prev.x) < eps : dy >= dx;
+			out.push(preferVertical ? {
+				x: prev.x,
+				y: curr.y
+			} : {
+				x: curr.x,
+				y: prev.y
+			});
+		}
+		out.push({ ...curr });
+	}
+	return collapseColinearPoints(out, eps);
+}
+/** Light cleanup — preserve ELK topology; keep bends clear of node cards. */
+function polishEdgePaths(paths, nodes = [], edgeNodeClearance = 28) {
+	const pad = Math.max(28, edgeNodeClearance);
+	return paths.map((path) => ({
+		...path,
+		points: ensureOrthogonalPoints(collapseColinearPoints(clearOrthogonalCorridors(path.points, nodes, pad)))
+	}));
+}
+//#endregion
+//#region src/layout/elk/build-elk-graph.ts
+/** Defaults chosen for flowchart readability — override via LayoutOptions. */
+const DEFAULT_NODE_PLACEMENT = "balanced";
+const ELK_NODE_PLACEMENT = {
+	straight: "BRANDES_KOEPF",
+	balanced: "NETWORK_SIMPLEX",
+	basic: "SIMPLE"
+};
+const DEFAULT_THOROUGHNESS = 24;
+function elkDirection(direction) {
+	switch (direction) {
+		case "RL": return "LEFT";
+		case "TD": return "DOWN";
+		case "BT": return "UP";
+		default: return "RIGHT";
+	}
+}
+function spacing(options) {
+	const density = options.density ?? "normal";
+	const scale = options.spacingScale ?? 1;
+	const gap = DENSITY_GAP[density] ?? DENSITY_GAP.normal;
+	return Math.round(gap * scale);
+}
+function aspectRatioFor(direction) {
+	return direction === "TD" || direction === "BT" ? "0.72" : "1.55";
+}
+/** Resolve ELK edge endpoint ref (node id or `node:…:edge`) to owning node id. */
+function endpointNodeId(ref) {
+	const colon = ref.indexOf(":");
+	if (colon <= 0) return ref;
+	return ref.slice(0, colon);
+}
+/**
+* Build an ELK JSON graph from Kekonic Diagrams measure + membership.
+* Maps semantic GraphModel → ELK; no raw elk bags on Graph JSON.
+*
+* Every edge is wired port→port: source on the flow-exit face, target on the
+* flow-entry face, with per-edge FIXED_POS pins from ShapeGeometry so fan-in
+* and fan-out never share a single attach point.
+*/
+function buildElkGraph(graph, measured, options) {
+	const measureMap = new Map(measured.map((m) => [m.nodeId, m]));
+	const gap = spacing(options);
+	const groupGap = options.groupGap ?? 72;
+	const direction = options.direction ?? "LR";
+	const edgeNode = Math.max(28, options.edgeNodeSpacing ?? Math.round(gap * .6));
+	const edgeEdge = Math.max(12, options.edgeEdgeSpacing ?? Math.max(18, Math.round(gap * .36)));
+	const nodeNode = options.groupGap != null ? groupGap : gap;
+	const layerGap = options.groupGap != null ? Math.round(groupGap * .9) : gap;
+	const nodePlacement = ELK_NODE_PLACEMENT[options.nodePlacement ?? DEFAULT_NODE_PLACEMENT] ?? ELK_NODE_PLACEMENT.straight;
+	const topology = analyzeDiagramTopology(graph, direction);
+	const portAssignment = assignEdgePorts(graph, measured, direction);
+	const topSwimlanes = graph.groups.filter((g) => g.kind === "swimlane" && g.parentId == null);
+	const usePartitions = options.groupLayout === "swimlane" || topSwimlanes.length > 0;
+	const flatMembership = options.groupLayout === "flat" || usePartitions && options.groupLayout === "swimlane";
+	const hierarchy = flatMembership ? "SEPARATE_CHILDREN" : "INCLUDE_CHILDREN";
+	const swimlanePartition = /* @__PURE__ */ new Map();
+	topSwimlanes.forEach((g, i) => {
+		for (const nodeId of g.nodeIds) swimlanePartition.set(nodeId, i);
+		const stack = [...g.childGroupIds];
+		while (stack.length) {
+			const cid = stack.pop();
+			const child = graph.groups.find((x) => x.id === cid);
+			if (!child) continue;
+			for (const nodeId of child.nodeIds) swimlanePartition.set(nodeId, i);
+			stack.push(...child.childGroupIds);
+		}
+	});
+	const defaultPartition = topSwimlanes.length;
+	const incoming = topology.incoming;
+	const outgoing = topology.outgoing;
+	const rootLayoutOptions = {
+		"elk.algorithm": "layered",
+		"elk.direction": elkDirection(direction),
+		"elk.edgeRouting": "ORTHOGONAL",
+		"elk.hierarchyHandling": hierarchy,
+		"elk.aspectRatio": aspectRatioFor(direction),
+		"elk.layered.thoroughness": String(DEFAULT_THOROUGHNESS),
+		"elk.layered.crossingMinimization.strategy": "LAYER_SWEEP",
+		"elk.layered.nodePlacement.strategy": nodePlacement,
+		"elk.layered.nodePlacement.bk.edgeStraightening": "IMPROVE_STRAIGHTNESS",
+		"elk.layered.nodePlacement.favorStraightEdges": "true",
+		"elk.layered.compaction.postCompaction.strategy": "EDGE_LENGTH",
+		"elk.layered.unnecessaryBendpoints": "false",
+		"elk.layered.feedbackEdges": "false",
+		"elk.layered.considerModelOrder.strategy": options.considerModelOrder === false ? "NONE" : "NODES_AND_EDGES",
+		"elk.padding": `[top=64,left=64,bottom=64,right=64]`,
+		"elk.spacing.nodeNode": String(nodeNode),
+		"elk.layered.spacing.nodeNodeBetweenLayers": String(layerGap),
+		"elk.spacing.edgeNode": String(edgeNode),
+		"elk.layered.spacing.edgeNodeBetweenLayers": String(edgeNode),
+		"elk.spacing.edgeEdge": String(edgeEdge),
+		"elk.layered.spacing.edgeEdgeBetweenLayers": String(edgeEdge),
+		"elk.spacing.componentComponent": String(groupGap)
+	};
+	if (usePartitions) rootLayoutOptions["elk.partitioning.activate"] = "true";
+	if (graph.edges.some((e) => {
+		return graph.nodes.find((n) => n.id === e.from)?.groupId !== graph.nodes.find((n) => n.id === e.to)?.groupId;
+	}) && !flatMembership) rootLayoutOptions["elk.layered.mergeHierarchyEdges"] = "true";
+	const groupsByParent = /* @__PURE__ */ new Map();
+	for (const g of graph.groups) {
+		if (flatMembership) continue;
+		const key = g.parentId;
+		const list = groupsByParent.get(key) ?? [];
+		list.push(g);
+		groupsByParent.set(key, list);
+	}
+	const assignedNodes = /* @__PURE__ */ new Set();
+	const nodeLayoutOptions = (nodeId) => {
+		const opts = {};
+		const out = outgoing.get(nodeId) ?? 0;
+		const inn = incoming.get(nodeId) ?? 0;
+		if (out === 0 && inn > 0) opts["elk.layered.layering.layerConstraint"] = "LAST";
+		if (inn === 0 && out > 0) opts["elk.layered.layering.layerConstraint"] = "FIRST";
+		if (portAssignment.portedNodes.has(nodeId)) opts["elk.portConstraints"] = "FIXED_POS";
+		if (usePartitions) opts["elk.partitioning.partition"] = String(swimlanePartition.get(nodeId) ?? defaultPartition);
+		return opts;
+	};
+	const buildLeaf = (nodeId, m) => {
+		const layoutOptions = nodeLayoutOptions(nodeId);
+		const ports = portAssignment.portsByNode.get(nodeId);
+		return {
+			id: nodeId,
+			width: m.width,
+			height: m.height,
+			...Object.keys(layoutOptions).length ? { layoutOptions } : {},
+			...ports?.length ? { ports } : {}
+		};
+	};
+	const buildGroupNode = (groupId) => {
+		const group = graph.groups.find((g) => g.id === groupId);
+		const pad = paddingForGroup(group);
+		const children = [];
+		for (const nodeId of group.nodeIds) {
+			const m = measureMap.get(nodeId);
+			if (!m) continue;
+			assignedNodes.add(nodeId);
+			children.push(buildLeaf(nodeId, m));
+		}
+		for (const child of groupsByParent.get(groupId) ?? []) children.push(buildGroupNode(child.id));
+		return {
+			id: `group:${group.id}`,
+			children,
+			labels: group.label ? [{
+				id: `group:${group.id}:label`,
+				text: group.label,
+				width: 80,
+				height: 18
+			}] : void 0,
+			layoutOptions: {
+				"elk.padding": `[top=${pad.top},left=${pad.left},bottom=${pad.bottom},right=${pad.right}]`,
+				"elk.spacing.nodeNode": String(Math.round(gap * .8)),
+				"elk.layered.spacing.nodeNodeBetweenLayers": String(Math.round(gap * .8)),
+				"elk.layered.nodePlacement.strategy": nodePlacement,
+				"elk.layered.nodePlacement.favorStraightEdges": "true",
+				"elk.contentAlignment": "V_CENTER H_CENTER"
+			}
+		};
+	};
+	const children = [];
+	for (const top of groupsByParent.get(void 0) ?? []) children.push(buildGroupNode(top.id));
+	for (const node of graph.nodes) {
+		if (assignedNodes.has(node.id)) continue;
+		const m = measureMap.get(node.id);
+		if (!m) continue;
+		children.push(buildLeaf(node.id, m));
+	}
+	const sourceRef = (edge) => portAssignment.edgeSourcePort.get(edge.id) ?? edge.from;
+	const targetRef = (edge) => portAssignment.edgeTargetPort.get(edge.id) ?? edge.to;
+	return {
+		id: "root",
+		layoutOptions: rootLayoutOptions,
+		children,
+		edges: graph.edges.map((e) => ({
+			id: e.id,
+			sources: [sourceRef(e)],
+			targets: [targetRef(e)],
+			layoutOptions: elkPriorityOptionsForEdge(e)
+		}))
+	};
+}
+//#endregion
+//#region src/layout/elk/elk-engine.ts
+/** Shared elk engine — elkjs today (elk-rs drop-in when published). */
+const ElkCtor = ELK;
+let shared = null;
+function getElk() {
+	if (!shared) shared = new ElkCtor({ defaultLayoutOptions: {
+		"elk.algorithm": "layered",
+		"elk.edgeRouting": "ORTHOGONAL",
+		"elk.hierarchyHandling": "INCLUDE_CHILDREN"
+	} });
+	return shared;
+}
+const ELK_LAYOUT_ALGORITHM = "elk-layered-v1";
+const ELK_ROUTER_ALGORITHM = "elk-orthogonal-v1";
+//#endregion
+//#region src/layout/attach-endpoints.ts
+const EPS$1 = .75;
+function toward(from, to) {
+	return {
+		x: to.x - from.x,
+		y: to.y - from.y
+	};
+}
+function centerOf$1(bounds) {
+	return {
+		x: bounds.x + bounds.width / 2,
+		y: bounds.y + bounds.height / 2
+	};
+}
+/** Prefer the dominant axis so attach rays stay H/V even when ELK left a diagonal stub. */
+function orthoDirection(v) {
+	if (Math.abs(v.x) >= Math.abs(v.y)) return {
+		x: Math.sign(v.x) || 1,
+		y: 0
+	};
+	return {
+		x: 0,
+		y: Math.sign(v.y) || 1
+	};
+}
+function axisAligned(a, b) {
+	return Math.abs(a.x - b.x) < EPS$1 || Math.abs(a.y - b.y) < EPS$1;
+}
+function applyOrthoAttach(points, endIndex, hit, direction) {
+	const anchor = points[endIndex === 0 ? 1 : endIndex - 1];
+	if (axisAligned(anchor, hit)) {
+		points[endIndex] = hit;
+		return;
+	}
+	const corner = Math.abs(direction.y) >= Math.abs(direction.x) ? {
+		x: anchor.x,
+		y: hit.y
+	} : {
+		x: hit.x,
+		y: anchor.y
+	};
+	points[endIndex] = hit;
+	if (endIndex === 0) points.splice(1, 0, corner);
+	else points.splice(endIndex, 0, corner);
+}
+/** Aim at the nearest facing side of the bounds so we do not flip H/V on shallow diagonals. */
+function directionOntoBounds(origin, bounds) {
+	const L = bounds.x;
+	const R = bounds.x + bounds.width;
+	const T = bounds.y;
+	const B = bounds.y + bounds.height;
+	const inX = origin.x >= L - EPS$1 && origin.x <= R + EPS$1;
+	const inY = origin.y >= T - EPS$1 && origin.y <= B + EPS$1;
+	if (origin.y < T && inX) return {
+		x: 0,
+		y: 1
+	};
+	if (origin.y > B && inX) return {
+		x: 0,
+		y: -1
+	};
+	if (origin.x < L && inY) return {
+		x: 1,
+		y: 0
+	};
+	if (origin.x > R && inY) return {
+		x: -1,
+		y: 0
+	};
+	return orthoDirection(toward(origin, centerOf$1(bounds)));
+}
+/**
+* Replace path termini with shape-perimeter hits.
+* Attach rays are forced orthogonal; a corner is inserted when needed so the
+* final stub never becomes a diagonal shortcut.
+*/
+function snapEdgeEndpointsToGeometry(graph, nodes, edgePaths) {
+	const nodeMap = new Map(nodes.map((n) => [n.nodeId, n]));
+	const graphNodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	return edgePaths.map((path) => {
+		const edge = graph.edges.find((e) => e.id === path.edgeId);
+		if (!edge || path.points.length < 2) return path;
+		if (edge.fromColumn || edge.toColumn) return path;
+		const points = path.points.map((p) => ({
+			x: p.x,
+			y: p.y
+		}));
+		const fromLaid = nodeMap.get(edge.from);
+		const toLaid = nodeMap.get(edge.to);
+		const fromNode = graphNodes.get(edge.from);
+		const toNode = graphNodes.get(edge.to);
+		if (fromLaid && fromNode) {
+			const p1 = points[1];
+			const direction = directionOntoBounds(p1, fromLaid.bounds);
+			applyOrthoAttach(points, 0, attachPointOnPerimeter({
+				shapeId: fromNode.shape,
+				bounds: fromLaid.bounds,
+				origin: p1,
+				direction
+			}), direction);
+		}
+		if (toLaid && toNode) {
+			const prev = points[points.length - 2];
+			const direction = directionOntoBounds(prev, toLaid.bounds);
+			const hit = attachPointOnPerimeter({
+				shapeId: toNode.shape,
+				bounds: toLaid.bounds,
+				origin: prev,
+				direction
+			});
+			applyOrthoAttach(points, points.length - 1, hit, direction);
+		}
+		return {
+			...path,
+			points
+		};
+	});
+}
+//#endregion
+//#region src/layout/region-arrange.ts
+const GAP_PRESETS = {
+	compact: DENSITY_GAP.compact,
+	normal: DENSITY_GAP.normal,
+	spacious: DENSITY_GAP.spacious
+};
+function resolveArrangeGap(gap) {
+	if (typeof gap === "number" && Number.isFinite(gap)) return Math.max(0, gap);
+	if (typeof gap === "string" && GAP_PRESETS[gap] != null) return GAP_PRESETS[gap];
+	return 72;
+}
+function trackCount(spec, fallback) {
+	if (typeof spec === "number") return Math.max(1, Math.floor(spec));
+	if (Array.isArray(spec)) return Math.max(1, spec.length);
+	return Math.max(1, fallback);
+}
+function resolveTrackIndex(ref, spec, fallbackIndex, count) {
+	if (typeof ref === "number" && ref >= 1) return Math.min(count - 1, Math.max(0, Math.floor(ref) - 1));
+	if (typeof ref === "string" && Array.isArray(spec)) {
+		const idx = spec.indexOf(ref);
+		if (idx >= 0) return idx;
+	}
+	return Math.min(count - 1, Math.max(0, fallbackIndex));
+}
+function alignOffset(align, free) {
+	if (free <= 0) return 0;
+	switch (align) {
+		case "end": return free;
+		case "center": return free / 2;
+		default: return 0;
+	}
+}
+/**
+* Place sibling region cells into stack / row / grid tracks.
+* Pure geometry — no ELK. Stretch equalizes the cross-axis.
+*/
+function regionArrange(input) {
+	const align = input.align ?? "stretch";
+	const gap = resolveArrangeGap(input.gap);
+	const originX = input.origin?.x ?? 0;
+	const originY = input.origin?.y ?? 0;
+	const cells = input.cells;
+	if (cells.length === 0) return [];
+	if (input.arrange === "stack") return arrangeStack(cells, align, gap, originX, originY);
+	if (input.arrange === "row") return arrangeRow(cells, align, gap, originX, originY);
+	return arrangeGrid(input, align, gap, originX, originY);
+}
+function arrangeStack(cells, align, gap, originX, originY) {
+	const maxW = Math.max(...cells.map((c) => c.width), 0);
+	let y = originY;
+	const out = [];
+	for (const cell of cells) {
+		const width = align === "stretch" ? maxW : cell.width;
+		const x = originX + alignOffset(align, maxW - width);
+		out.push({
+			groupId: cell.groupId,
+			bounds: {
+				x,
+				y,
+				width,
+				height: cell.height
+			}
+		});
+		y += cell.height + gap;
+	}
+	return out;
+}
+function arrangeRow(cells, align, gap, originX, originY) {
+	const maxH = Math.max(...cells.map((c) => c.height), 0);
+	let x = originX;
+	const out = [];
+	for (const cell of cells) {
+		const height = align === "stretch" ? maxH : cell.height;
+		const y = originY + alignOffset(align, maxH - height);
+		out.push({
+			groupId: cell.groupId,
+			bounds: {
+				x,
+				y,
+				width: cell.width,
+				height
+			}
+		});
+		x += cell.width + gap;
+	}
+	return out;
+}
+function arrangeGrid(input, align, gap, originX, originY) {
+	const cells = input.cells;
+	let autoCol = 0;
+	let autoRow = 0;
+	const colCountHint = trackCount(input.columns, 1);
+	const placements = cells.map((cell) => {
+		const colSpan = Math.max(1, cell.colSpan ?? 1);
+		const rowSpan = Math.max(1, cell.rowSpan ?? 1);
+		let col = resolveTrackIndex(cell.column, input.columns, autoCol, colCountHint);
+		let row = resolveTrackIndex(cell.row, input.rows, autoRow, trackCount(input.rows, 1));
+		if (cell.column == null && cell.row == null) {
+			col = autoCol;
+			row = autoRow;
+			autoCol += colSpan;
+			if (autoCol >= colCountHint) {
+				autoCol = 0;
+				autoRow += 1;
+			}
+		}
+		return {
+			cell,
+			col,
+			row,
+			colSpan,
+			rowSpan
+		};
+	});
+	const maxCol = Math.max(colCountHint, ...placements.map((p) => p.col + p.colSpan));
+	const maxRow = Math.max(trackCount(input.rows, 1), ...placements.map((p) => p.row + p.rowSpan));
+	const colWidths = Array.from({ length: maxCol }, () => 0);
+	const rowHeights = Array.from({ length: maxRow }, () => 0);
+	for (const p of placements) {
+		const perCol = p.cell.width / p.colSpan;
+		const perRow = p.cell.height / p.rowSpan;
+		for (let c = p.col; c < p.col + p.colSpan; c++) colWidths[c] = Math.max(colWidths[c], perCol);
+		for (let r = p.row; r < p.row + p.rowSpan; r++) rowHeights[r] = Math.max(rowHeights[r], perRow);
+	}
+	const colX = [];
+	let x = originX;
+	for (let c = 0; c < maxCol; c++) {
+		colX.push(x);
+		x += colWidths[c] + (c < maxCol - 1 ? gap : 0);
+	}
+	const rowY = [];
+	let y = originY;
+	for (let r = 0; r < maxRow; r++) {
+		rowY.push(y);
+		y += rowHeights[r] + (r < maxRow - 1 ? gap : 0);
+	}
+	return placements.map((p) => {
+		let width = 0;
+		for (let c = p.col; c < p.col + p.colSpan; c++) {
+			width += colWidths[c];
+			if (c < p.col + p.colSpan - 1) width += gap;
+		}
+		let height = 0;
+		for (let r = p.row; r < p.row + p.rowSpan; r++) {
+			height += rowHeights[r];
+			if (r < p.row + p.rowSpan - 1) height += gap;
+		}
+		const cellW = align === "stretch" ? width : p.cell.width;
+		const cellH = align === "stretch" ? height : p.cell.height;
+		const ox = alignOffset(align, width - cellW);
+		const oy = alignOffset(align, height - cellH);
+		return {
+			groupId: p.cell.groupId,
+			bounds: {
+				x: colX[p.col] + ox,
+				y: rowY[p.row] + oy,
+				width: cellW,
+				height: cellH
+			}
+		};
+	});
+}
+/** True when a group or diagram options request region arrangement. */
+function groupHasRegionArrange(group) {
+	return group.arrange === "stack" || group.arrange === "row" || group.arrange === "grid";
+}
+//#endregion
+//#region src/layout/route-orthogonal-avoid.ts
+const EPS = .5;
+/** Keep corridors off node silhouettes so edges do not run along a face. */
+const SIDE_STANDOFF = 16;
+function inflate(b, pad) {
+	return {
+		x: b.x - pad,
+		y: b.y - pad,
+		width: b.width + pad * 2,
+		height: b.height + pad * 2
+	};
+}
+function centerOf(b) {
+	return {
+		x: b.x + b.width / 2,
+		y: b.y + b.height / 2
+	};
+}
+/** Orthogonal segment vs inflated axis-aligned rect (open interior). */
+function segmentHitsRect(a, b, box) {
+	const minX = Math.min(a.x, b.x);
+	const maxX = Math.max(a.x, b.x);
+	const minY = Math.min(a.y, b.y);
+	const maxY = Math.max(a.y, b.y);
+	const L = box.x;
+	const R = box.x + box.width;
+	const T = box.y;
+	const B = box.y + box.height;
+	if (Math.abs(a.x - b.x) < EPS) {
+		const x = a.x;
+		if (x <= L + EPS || x >= R - EPS) return false;
+		return maxY > T + EPS && minY < B - EPS;
+	}
+	if (Math.abs(a.y - b.y) < EPS) {
+		const y = a.y;
+		if (y <= T + EPS || y >= B - EPS) return false;
+		return maxX > L + EPS && minX < R - EPS;
+	}
+	return false;
+}
+function rangesOverlap(a0, a1, b0, b1) {
+	return Math.min(a0, a1) <= Math.max(b0, b1) && Math.max(a0, a1) >= Math.min(b0, b1);
+}
+/**
+* True when an orthogonal segment runs along a box face (parallel hug).
+* Short stubs into an attach face are allowed; long slides along a side are not.
+*/
+function segmentHugsRect(a, b, box, standoff = SIDE_STANDOFF, allowShortStub = false) {
+	const minX = Math.min(a.x, b.x);
+	const maxX = Math.max(a.x, b.x);
+	const minY = Math.min(a.y, b.y);
+	const maxY = Math.max(a.y, b.y);
+	const L = box.x;
+	const R = box.x + box.width;
+	const T = box.y;
+	const B = box.y + box.height;
+	const len = Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+	if (Math.abs(a.x - b.x) < EPS) {
+		const x = a.x;
+		const alongLeft = Math.abs(x - L) <= standoff;
+		const alongRight = Math.abs(x - R) <= standoff;
+		if (!(alongLeft || alongRight)) return false;
+		if (!rangesOverlap(minY, maxY, T, B)) return false;
+		if (allowShortStub && len <= standoff * 1.5) return false;
+		return Math.min(maxY, B) - Math.max(minY, T) > standoff * .5;
+	}
+	if (Math.abs(a.y - b.y) < EPS) {
+		const y = a.y;
+		const alongTop = Math.abs(y - T) <= standoff;
+		const alongBottom = Math.abs(y - B) <= standoff;
+		if (!(alongTop || alongBottom)) return false;
+		if (!rangesOverlap(minX, maxX, L, R)) return false;
+		if (allowShortStub && len <= standoff * 1.5) return false;
+		return Math.min(maxX, R) - Math.max(minX, L) > standoff * .5;
+	}
+	return false;
+}
+function pathLength(points) {
+	let len = 0;
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		len += Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+	}
+	return len;
+}
+function dedupe(points) {
+	const out = [];
+	for (const p of points) {
+		const prev = out[out.length - 1];
+		if (prev && Math.abs(prev.x - p.x) < EPS && Math.abs(prev.y - p.y) < EPS) continue;
+		out.push(p);
+	}
+	return out;
+}
+/**
+* Collapse colinear bends, but keep the egress/ingress stubs so a later
+* corridor on the same line cannot erase the outward nudge and cut through
+* the source/target box.
+*
+* Final layout polish uses `collapseColinearPoints` in polish-edges.ts (no stub
+* preservation) after endpoints are frozen — different stage, different rule.
+*/
+function collapseColinear(points) {
+	if (points.length < 3) return points;
+	const out = [points[0]];
+	for (let i = 1; i < points.length - 1; i++) {
+		if (i === 1 || i === points.length - 2) {
+			out.push(points[i]);
+			continue;
+		}
+		const a = out[out.length - 1];
+		const b = points[i];
+		const c = points[i + 1];
+		const vertical = Math.abs(a.x - b.x) < EPS && Math.abs(b.x - c.x) < EPS;
+		const horizontal = Math.abs(a.y - b.y) < EPS && Math.abs(b.y - c.y) < EPS;
+		if (vertical || horizontal) continue;
+		out.push(b);
+	}
+	out.push(points[points.length - 1]);
+	return dedupe(out);
+}
+function attach(b, side, t) {
+	const clamped = Math.min(.85, Math.max(.15, t));
+	switch (side) {
+		case "N": return {
+			x: b.x + b.width * clamped,
+			y: b.y
+		};
+		case "S": return {
+			x: b.x + b.width * clamped,
+			y: b.y + b.height
+		};
+		case "E": return {
+			x: b.x + b.width,
+			y: b.y + b.height * clamped
+		};
+		case "W": return {
+			x: b.x,
+			y: b.y + b.height * clamped
+		};
+	}
+}
+/** Which face a point sits on (within EPS), if any. */
+function sideOfPoint(p, b) {
+	if (Math.abs(p.y - b.y) < EPS && p.x >= b.x - EPS && p.x <= b.x + b.width + EPS) return "N";
+	if (Math.abs(p.y - (b.y + b.height)) < EPS && p.x >= b.x - EPS && p.x <= b.x + b.width + EPS) return "S";
+	if (Math.abs(p.x - (b.x + b.width)) < EPS && p.y >= b.y - EPS && p.y <= b.y + b.height + EPS) return "E";
+	if (Math.abs(p.x - b.x) < EPS && p.y >= b.y - EPS && p.y <= b.y + b.height + EPS) return "W";
+	return null;
+}
+/**
+* Prefer the geometrically primary faces; heavily punish U-turns that attach on
+* the far side after wrapping under/around the target (common arranged-mode fail).
+*/
+function facePreferencePenalty(from, to, points, preferred) {
+	const start = sideOfPoint(points[0], from);
+	const end = sideOfPoint(points[points.length - 1], to);
+	let penalty = 0;
+	if (start && start !== preferred[0]) penalty += 2400;
+	if (end && end !== preferred[1]) penalty += 9e3;
+	const [fs, ts] = preferred;
+	if (fs === "S" && ts === "N" && end === "S") penalty += 18e3;
+	if (fs === "S" && ts === "N" && (end === "E" || end === "W")) penalty += 12e3;
+	if (fs === "N" && ts === "S" && end === "N") penalty += 18e3;
+	if (fs === "E" && ts === "W" && end === "E") penalty += 18e3;
+	if (fs === "W" && ts === "E" && end === "W") penalty += 18e3;
+	return penalty;
+}
+/** Point outside the attach face — corridors route through here, not on the silhouette. */
+function egress(b, side, t, standoff) {
+	const p = attach(b, side, t);
+	switch (side) {
+		case "E": return {
+			x: p.x + standoff,
+			y: p.y
+		};
+		case "W": return {
+			x: p.x - standoff,
+			y: p.y
+		};
+		case "S": return {
+			x: p.x,
+			y: p.y + standoff
+		};
+		case "N": return {
+			x: p.x,
+			y: p.y - standoff
+		};
+	}
+}
+function sidePairs(from, to) {
+	const primary = preferredSidePair(from, to);
+	const eastWest = to.x - (from.x + from.width);
+	const westEast = from.x - (to.x + to.width);
+	const southNorth = to.y - (from.y + from.height);
+	const northSouth = from.y - (to.y + to.height);
+	return [
+		primary,
+		primary[0] === "E" || primary[0] === "W" ? southNorth >= northSouth ? ["S", "N"] : ["N", "S"] : eastWest >= westEast ? ["E", "W"] : ["W", "E"],
+		["E", "W"],
+		["W", "E"],
+		["S", "N"],
+		["N", "S"]
+	];
+}
+/** Primary attach faces — shared with arranged fan-slot grouping. */
+function preferredSidePair(from, to) {
+	const eastWest = to.x - (from.x + from.width);
+	const westEast = from.x - (to.x + to.width);
+	const southNorth = to.y - (from.y + from.height);
+	const northSouth = from.y - (to.y + to.height);
+	const hClear = Math.max(eastWest, westEast);
+	const vClear = Math.max(southNorth, northSouth);
+	const separatedH = hClear > 8;
+	const separatedV = vClear > 8;
+	if (separatedH && (!separatedV || hClear >= vClear * .35 || hClear > 48)) return eastWest >= westEast ? ["E", "W"] : ["W", "E"];
+	if (separatedV) return southNorth >= northSouth ? ["S", "N"] : ["N", "S"];
+	const fc = centerOf(from);
+	const tc = centerOf(to);
+	const dx = tc.x - fc.x;
+	const dy = tc.y - fc.y;
+	return Math.abs(dx) >= Math.abs(dy) ? dx >= 0 ? ["E", "W"] : ["W", "E"] : dy >= 0 ? ["S", "N"] : ["N", "S"];
+}
+/** Clearance between facing sides; null when the pair does not face. */
+function facingClearance(from, to, fs, ts) {
+	if (fs === "S" && ts === "N") return to.y - (from.y + from.height);
+	if (fs === "N" && ts === "S") return from.y - (to.y + to.height);
+	if (fs === "E" && ts === "W") return to.x - (from.x + from.width);
+	if (fs === "W" && ts === "E") return from.x - (to.x + to.width);
+	return null;
+}
+/** True when the boxes overlap on the axis orthogonal to the facing sides. */
+function facesOverlap(from, to, fs) {
+	if (fs === "S" || fs === "N") return rangesOverlap(from.x, from.x + from.width, to.x, to.x + to.width);
+	return rangesOverlap(from.y, from.y + from.height, to.y, to.y + to.height);
+}
+/**
+* Pack/stack cells leave ~16px gaps, but the default egress turn is ~36px.
+* When neighbors face across a tight clear gap, route in the interstitial
+* channel instead of overshooting into the target and escaping around the hull.
+*/
+function tryTightNeighborRoute(from, to, obstacles, pad, tFrom, tTo, turn) {
+	const [fs, ts] = sidePairs(from, to)[0];
+	const gap = facingClearance(from, to, fs, ts);
+	if (gap == null || gap <= 0 || gap >= turn * 2) return null;
+	if (!facesOverlap(from, to, fs)) return null;
+	const aAttach = attach(from, fs, tFrom);
+	const bAttach = attach(to, ts, tTo);
+	const half = gap / 2;
+	let mid;
+	if (fs === "S" || fs === "N") {
+		const y = fs === "S" ? from.y + from.height + half : from.y - half;
+		mid = [{
+			x: aAttach.x,
+			y
+		}, {
+			x: bAttach.x,
+			y
+		}];
+	} else {
+		const x = fs === "E" ? from.x + from.width + half : from.x - half;
+		mid = [{
+			x,
+			y: aAttach.y
+		}, {
+			x,
+			y: bAttach.y
+		}];
+	}
+	const points = collapseColinear(dedupe([
+		aAttach,
+		...mid,
+		bAttach
+	]));
+	const channelPad = Math.min(pad, Math.max(0, gap / 4 - 1));
+	if (countHits(points, obstacles.map((b) => inflate(b, channelPad)), [from, to]) > 0) return null;
+	return points;
+}
+function turnForPair(baseTurn, gap) {
+	if (gap == null || gap <= 0) return baseTurn;
+	return Math.min(baseTurn, Math.max(2, gap / 2 - 1));
+}
+function hvPath(a, b) {
+	if (Math.abs(a.y - b.y) < EPS || Math.abs(a.x - b.x) < EPS) return [a, b];
+	return [
+		a,
+		{
+			x: b.x,
+			y: a.y
+		},
+		b
+	];
+}
+function vhPath(a, b) {
+	if (Math.abs(a.y - b.y) < EPS || Math.abs(a.x - b.x) < EPS) return [a, b];
+	return [
+		a,
+		{
+			x: a.x,
+			y: b.y
+		},
+		b
+	];
+}
+function unionBounds(rects) {
+	if (rects.length === 0) return null;
+	let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+	for (const b of rects) {
+		minX = Math.min(minX, b.x);
+		minY = Math.min(minY, b.y);
+		maxX = Math.max(maxX, b.x + b.width);
+		maxY = Math.max(maxY, b.y + b.height);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/**
+* Rectilinear route between two node boxes that prefers corridors clear of
+* other node footprints. Candidate channels only (not a grid/A* router).
+*/
+function routeOrthogonalAvoiding(from, to, obstacles, pad, tFrom = .5, tTo = .5) {
+	const pads = [
+		pad,
+		Math.min(pad, 12),
+		6,
+		2
+	].filter((p, i, arr) => arr.indexOf(p) === i);
+	let fallback = null;
+	for (const tryPad of pads) {
+		const result = routeWithPad(from, to, obstacles, tryPad, tFrom, tTo);
+		if (result.clear) return result.points;
+		fallback ??= result.points;
+	}
+	return fallback ?? [centerOf(from), centerOf(to)];
+}
+function routeWithPad(from, to, obstacles, pad, tFrom, tTo) {
+	const turn = Math.max(Math.max(SIDE_STANDOFF, pad) * 2.25, pad + 14);
+	const tight = tryTightNeighborRoute(from, to, obstacles, pad, tFrom, tTo, turn);
+	if (tight) return {
+		points: tight,
+		clear: true
+	};
+	const hugReach = Math.max(SIDE_STANDOFF, turn * .75);
+	const inflated = obstacles.map((b) => inflate(b, pad));
+	const endpointBoxes = [from, to];
+	const candidates = [];
+	const pairs = sidePairs(from, to);
+	const preferred = pairs[0];
+	for (let rank = 0; rank < pairs.length; rank++) {
+		const [fs, ts] = pairs[rank];
+		const pairTurn = turnForPair(turn, facingClearance(from, to, fs, ts));
+		const aAttach = attach(from, fs, tFrom);
+		const bAttach = attach(to, ts, tTo);
+		const a = egress(from, fs, tFrom, pairTurn);
+		const b = egress(to, ts, tTo, pairTurn);
+		for (const mid of [hvPath(a, b), vhPath(a, b)]) candidates.push({
+			raw: [
+				aAttach,
+				...mid,
+				bAttach
+			],
+			rank
+		});
+		const midX = (a.x + b.x) / 2;
+		const midY = (a.y + b.y) / 2;
+		candidates.push({
+			raw: [
+				aAttach,
+				a,
+				{
+					x: midX,
+					y: a.y
+				},
+				{
+					x: midX,
+					y: b.y
+				},
+				b,
+				bAttach
+			],
+			rank
+		});
+		candidates.push({
+			raw: [
+				aAttach,
+				a,
+				{
+					x: a.x,
+					y: midY
+				},
+				{
+					x: b.x,
+					y: midY
+				},
+				b,
+				bAttach
+			],
+			rank
+		});
+	}
+	pushFacingChannelDetours(candidates, from, to, inflated, pad, tFrom, tTo, preferred);
+	const hull = unionBounds([
+		...localObstacles(from, to, inflated),
+		inflate(from, pad),
+		inflate(to, pad)
+	]);
+	if (hull) {
+		const clear = Math.max(pad, turn);
+		const left = hull.x - clear;
+		const right = hull.x + hull.width + clear;
+		const top = hull.y - clear;
+		const bottom = hull.y + hull.height + clear;
+		const entrySides = [preferred[1], ...[
+			"N",
+			"S",
+			"E",
+			"W"
+		].filter((s) => s !== preferred[1])];
+		for (const ts of entrySides) pushRailEscapes(candidates, from, tFrom, turn, pad, left, right, top, bottom, attach(to, ts, tTo), ts === preferred[1] ? 2 : 5);
+	}
+	let bestClear = null;
+	let bestClearScore = Infinity;
+	let bestAny = candidates[0]?.raw ?? [centerOf(from), centerOf(to)];
+	let bestAnyScore = Infinity;
+	for (const cand of candidates) {
+		const points = collapseColinear(dedupe(cand.raw));
+		if (points.length < 2) continue;
+		const len = pathLength(points);
+		const hits = countHits(points, inflated, endpointBoxes);
+		const hugs = countHugs(points, endpointBoxes, hugReach) + countHugs(points, obstacles, SIDE_STANDOFF);
+		const facePenalty = facePreferencePenalty(from, to, points, preferred);
+		const score = hits * 1e5 + hugs * 140 + cand.rank * 320 + facePenalty + len;
+		if (score < bestAnyScore) {
+			bestAnyScore = score;
+			bestAny = points;
+		}
+		if (hits === 0 && score < bestClearScore) {
+			bestClearScore = score;
+			bestClear = points;
+		}
+	}
+	return {
+		points: bestClear ?? bestAny,
+		clear: bestClear != null
+	};
+}
+/**
+* Short detours that skim above/below (or beside) blockers in the facing
+* channel — avoids full-hull perimeter tours when only a pack sibling blocks.
+*/
+function pushFacingChannelDetours(candidates, from, to, inflated, pad, tFrom, tTo, preferred) {
+	const [fs, ts] = preferred;
+	const clear = Math.max(pad, SIDE_STANDOFF);
+	const bAttach = attach(to, ts, tTo);
+	const b = egress(to, ts, tTo, clear);
+	if (fs === "E" && ts === "W" || fs === "W" && ts === "E") {
+		const x0 = fs === "E" ? from.x + from.width : to.x + to.width;
+		const x1 = fs === "E" ? to.x : from.x;
+		if (x1 <= x0 + 1) return;
+		const blockers = inflated.filter((box) => box.x + box.width > x0 - 1 && box.x < x1 - 1 && (rangesOverlap(box.y, box.y + box.height, from.y, from.y + from.height) || rangesOverlap(box.y, box.y + box.height, to.y, to.y + to.height)));
+		if (blockers.length === 0) return;
+		const topLane = Math.min(...blockers.map((box) => box.y)) - clear;
+		const bottomLane = Math.max(...blockers.map((box) => box.y + box.height)) + clear;
+		const aN = attach(from, "N", tFrom);
+		const aS = attach(from, "S", tFrom);
+		candidates.push({
+			raw: [
+				aN,
+				{
+					x: aN.x,
+					y: topLane
+				},
+				{
+					x: b.x,
+					y: topLane
+				},
+				b,
+				bAttach
+			],
+			rank: 1
+		});
+		candidates.push({
+			raw: [
+				aS,
+				{
+					x: aS.x,
+					y: bottomLane
+				},
+				{
+					x: b.x,
+					y: bottomLane
+				},
+				b,
+				bAttach
+			],
+			rank: 1
+		});
+		const aF = attach(from, fs, tFrom);
+		const jogX = fs === "E" ? Math.min(aF.x + clear, (x0 + x1) / 2) : Math.max(aF.x - clear, (x0 + x1) / 2);
+		candidates.push({
+			raw: [
+				aF,
+				{
+					x: jogX,
+					y: aF.y
+				},
+				{
+					x: jogX,
+					y: topLane
+				},
+				{
+					x: b.x,
+					y: topLane
+				},
+				b,
+				bAttach
+			],
+			rank: 0
+		});
+		candidates.push({
+			raw: [
+				aF,
+				{
+					x: jogX,
+					y: aF.y
+				},
+				{
+					x: jogX,
+					y: bottomLane
+				},
+				{
+					x: b.x,
+					y: bottomLane
+				},
+				b,
+				bAttach
+			],
+			rank: 0
+		});
+		return;
+	}
+	if (fs === "S" && ts === "N" || fs === "N" && ts === "S") {
+		const y0 = fs === "S" ? from.y + from.height : to.y + to.height;
+		const y1 = fs === "S" ? to.y : from.y;
+		if (y1 <= y0 + 1) return;
+		const blockers = inflated.filter((box) => box.y + box.height > y0 - 1 && box.y < y1 - 1 && (rangesOverlap(box.x, box.x + box.width, from.x, from.x + from.width) || rangesOverlap(box.x, box.x + box.width, to.x, to.x + to.width)));
+		if (blockers.length === 0) return;
+		const leftLane = Math.min(...blockers.map((box) => box.x)) - clear;
+		const rightLane = Math.max(...blockers.map((box) => box.x + box.width)) + clear;
+		const aW = attach(from, "W", tFrom);
+		const aE = attach(from, "E", tFrom);
+		candidates.push({
+			raw: [
+				aW,
+				{
+					x: leftLane,
+					y: aW.y
+				},
+				{
+					x: leftLane,
+					y: b.y
+				},
+				b,
+				bAttach
+			],
+			rank: 1
+		});
+		candidates.push({
+			raw: [
+				aE,
+				{
+					x: rightLane,
+					y: aE.y
+				},
+				{
+					x: rightLane,
+					y: b.y
+				},
+				b,
+				bAttach
+			],
+			rank: 1
+		});
+	}
+}
+/**
+* Obstacles near the endpoints — generous AABB so pack siblings beside the
+* straight span still shape the local hull (and its outside rails).
+*/
+function localObstacles(from, to, inflated, margin = 160) {
+	const x0 = Math.min(from.x, to.x) - margin;
+	const y0 = Math.min(from.y, to.y) - margin;
+	const x1 = Math.max(from.x + from.width, to.x + to.width) + margin;
+	const y1 = Math.max(from.y + from.height, to.y + to.height) + margin;
+	return inflated.filter((box) => !(box.x + box.width < x0 || box.x > x1 || box.y + box.height < y0 || box.y > y1));
+}
+/** Ortho routes that ride the outside of a local hull without mid-pack cuts. */
+function pushRailEscapes(candidates, from, tFrom, turn, pad, left, right, top, bottom, bAttach, rank = 3) {
+	const aN = attach(from, "N", tFrom);
+	const aS = attach(from, "S", tFrom);
+	const aE = attach(from, "E", tFrom);
+	const aW = attach(from, "W", tFrom);
+	const nTurn = Math.min(turn, Math.max(pad, aN.y - top));
+	const sTurn = Math.min(turn, Math.max(pad, bottom - aS.y));
+	const eTurn = Math.min(turn, Math.max(pad, right - aE.x));
+	const wTurn = Math.min(turn, Math.max(pad, aW.x - left));
+	const n = egress(from, "N", tFrom, nTurn);
+	const s = egress(from, "S", tFrom, sTurn);
+	const e = egress(from, "E", tFrom, eTurn);
+	const w = egress(from, "W", tFrom, wTurn);
+	candidates.push({
+		raw: [
+			aE,
+			e,
+			{
+				x: right,
+				y: e.y
+			},
+			{
+				x: right,
+				y: top
+			},
+			{
+				x: bAttach.x,
+				y: top
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aE,
+			e,
+			{
+				x: right,
+				y: e.y
+			},
+			{
+				x: right,
+				y: bottom
+			},
+			{
+				x: bAttach.x,
+				y: bottom
+			},
+			bAttach
+		],
+		rank: rank + 1
+	});
+	candidates.push({
+		raw: [
+			aW,
+			w,
+			{
+				x: left,
+				y: w.y
+			},
+			{
+				x: left,
+				y: top
+			},
+			{
+				x: bAttach.x,
+				y: top
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aW,
+			w,
+			{
+				x: left,
+				y: w.y
+			},
+			{
+				x: left,
+				y: bottom
+			},
+			{
+				x: bAttach.x,
+				y: bottom
+			},
+			bAttach
+		],
+		rank: rank + 1
+	});
+	candidates.push({
+		raw: [
+			aN,
+			n,
+			{
+				x: n.x,
+				y: top
+			},
+			{
+				x: left,
+				y: top
+			},
+			{
+				x: left,
+				y: bAttach.y
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aN,
+			n,
+			{
+				x: n.x,
+				y: top
+			},
+			{
+				x: right,
+				y: top
+			},
+			{
+				x: right,
+				y: bAttach.y
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aN,
+			n,
+			{
+				x: n.x,
+				y: top
+			},
+			{
+				x: bAttach.x,
+				y: top
+			},
+			bAttach
+		],
+		rank: rank + 1
+	});
+	candidates.push({
+		raw: [
+			aS,
+			s,
+			{
+				x: s.x,
+				y: bottom
+			},
+			{
+				x: left,
+				y: bottom
+			},
+			{
+				x: left,
+				y: bAttach.y
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aS,
+			s,
+			{
+				x: s.x,
+				y: bottom
+			},
+			{
+				x: right,
+				y: bottom
+			},
+			{
+				x: right,
+				y: bAttach.y
+			},
+			bAttach
+		],
+		rank
+	});
+	candidates.push({
+		raw: [
+			aS,
+			s,
+			{
+				x: s.x,
+				y: bottom
+			},
+			{
+				x: bAttach.x,
+				y: bottom
+			},
+			bAttach
+		],
+		rank: rank + 1
+	});
+}
+function countHits(points, obstacles, endpoints) {
+	let n = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const isStub = i === 0 || i === points.length - 2;
+		for (const box of obstacles) if (segmentHitsRect(points[i], points[i + 1], box)) n += 1;
+		if (!isStub) {
+			for (const box of endpoints) if (segmentHitsRect(points[i], points[i + 1], box)) n += 1;
+		}
+	}
+	return n;
+}
+function countHugs(points, boxes, reach) {
+	let n = 0;
+	for (let i = 0; i < points.length - 1; i++) {
+		const isStub = i === 0 || i === points.length - 2;
+		for (const box of boxes) if (segmentHugsRect(points[i], points[i + 1], box, reach, isStub)) n += 1;
+	}
+	return n;
+}
+//#endregion
+//#region src/layout/elk/layout-arranged.ts
+/** Inside a row of columns, pack top→bottom; inside stacked bands, pack left→right. */
+function cellFlowDirection(parentArrange) {
+	if (parentArrange === "row") return "TD";
+	if (parentArrange === "stack") return "LR";
+	return "TD";
+}
+const NODE_CELL_PREFIX = "__node__:";
+/** Fallback leaf gap when no authored `gap` — roomier than the old hard-coded 16px. */
+function defaultLeafGap(density) {
+	switch (density) {
+		case "compact": return 20;
+		case "spacious": return 40;
+		default: return 28;
+	}
+}
+function resolveLeafGap(gap, options) {
+	const scale = options.spacingScale ?? 1;
+	const base = gap != null ? resolveArrangeGap(gap) : defaultLeafGap(options.density);
+	return Math.max(0, Math.round(base * scale));
+}
+function resolveTrackGap(gap, options) {
+	const scale = options.spacingScale ?? 1;
+	return Math.max(0, Math.round(resolveArrangeGap(gap) * scale));
+}
+function nodeCellId(nodeId) {
+	return `${NODE_CELL_PREFIX}${nodeId}`;
+}
+function parseNodeCellId(cellId) {
+	return cellId.startsWith(NODE_CELL_PREFIX) ? cellId.slice(9) : null;
+}
+/** Pack wrap width — wider densities keep more siblings on one row. */
+function packMaxRowWidth(density) {
+	switch (density) {
+		case "compact": return 420;
+		case "spacious": return 720;
+		default: return 560;
+	}
+}
+function needsRegionArrange(graph, options) {
+	if (options.arrange === "stack" || options.arrange === "row" || options.arrange === "grid") return true;
+	return graph.groups.some((g) => groupHasRegionArrange(g));
+}
+function ranksFromFixed(nodes, direction) {
+	const dir = direction ?? "LR";
+	const horizontal = dir === "LR" || dir === "RL";
+	const sorted = [...nodes].sort((a, b) => {
+		const aPrimary = horizontal ? a.bounds.x : a.bounds.y;
+		const bPrimary = horizontal ? b.bounds.x : b.bounds.y;
+		if (aPrimary !== bPrimary) return aPrimary - bPrimary;
+		return (horizontal ? a.bounds.y : a.bounds.x) - (horizontal ? b.bounds.y : b.bounds.x);
+	});
+	const rankOf = /* @__PURE__ */ new Map();
+	let rank = 0;
+	let lastPrimary = Number.NEGATIVE_INFINITY;
+	for (const n of sorted) {
+		const primary = horizontal ? n.bounds.x : n.bounds.y;
+		if (primary - lastPrimary > 8) {
+			if (lastPrimary !== Number.NEGATIVE_INFINITY) rank += 1;
+			lastPrimary = primary;
+		}
+		rankOf.set(n.nodeId, rank);
+	}
+	const orderInRank = /* @__PURE__ */ new Map();
+	return sorted.map((n) => {
+		const r = rankOf.get(n.nodeId) ?? 0;
+		const order = orderInRank.get(r) ?? 0;
+		orderInRank.set(r, order + 1);
+		return {
+			...n,
+			rank: r,
+			order
+		};
+	});
+}
+function packNodes(nodeIds, measureMap, mode, density, gapPx = 28) {
+	const out = /* @__PURE__ */ new Map();
+	let x = 0;
+	let y = 0;
+	let rowH = 0;
+	const maxRowW = packMaxRowWidth(density);
+	const gap = Math.max(0, gapPx);
+	const rows = [];
+	let row = [];
+	for (const id of nodeIds) {
+		const m = measureMap.get(id);
+		if (!m) continue;
+		if (mode === "stack") {
+			out.set(id, {
+				x: 0,
+				y,
+				width: m.width,
+				height: m.height
+			});
+			y += m.height + gap;
+			continue;
+		}
+		if (x > 0 && x + m.width > maxRowW) {
+			rows.push(row);
+			row = [];
+			x = 0;
+			y += rowH + gap;
+			rowH = 0;
+		}
+		out.set(id, {
+			x,
+			y,
+			width: m.width,
+			height: m.height
+		});
+		row.push(id);
+		x += m.width + gap;
+		rowH = Math.max(rowH, m.height);
+	}
+	if (row.length) rows.push(row);
+	if (mode === "stack" && out.size > 1) {
+		const maxW = Math.max(...[...out.values()].map((b) => b.width));
+		for (const [id, b] of out) out.set(id, {
+			...b,
+			x: (maxW - b.width) / 2
+		});
+	} else if (mode === "pack" && rows.length > 0) {
+		const colCount = Math.max(...rows.map((r) => r.length), 0);
+		const colW = Array.from({ length: colCount }, () => 0);
+		const rowHeights = Array.from({ length: rows.length }, () => 0);
+		for (let r = 0; r < rows.length; r++) {
+			const ids = rows[r];
+			for (let c = 0; c < ids.length; c++) {
+				const b = out.get(ids[c]);
+				colW[c] = Math.max(colW[c], b.width);
+				rowHeights[r] = Math.max(rowHeights[r], b.height);
+			}
+		}
+		let gy = 0;
+		for (let r = 0; r < rows.length; r++) {
+			const ids = rows[r];
+			let gx = 0;
+			for (let c = 0; c < ids.length; c++) {
+				const id = ids[c];
+				const b = out.get(id);
+				out.set(id, {
+					x: gx,
+					y: gy,
+					width: b.width,
+					height: b.height
+				});
+				gx += colW[c] + gap;
+			}
+			gy += rowHeights[r] + gap;
+		}
+	}
+	return out;
+}
+function aabbOf(rects) {
+	let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+	let any = false;
+	for (const b of rects) {
+		any = true;
+		minX = Math.min(minX, b.x);
+		minY = Math.min(minY, b.y);
+		maxX = Math.max(maxX, b.x + b.width);
+		maxY = Math.max(maxY, b.y + b.height);
+	}
+	if (!any) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function offsetRects(rects, dx, dy) {
+	for (const [id, b] of rects) rects.set(id, {
+		...b,
+		x: b.x + dx,
+		y: b.y + dy
+	});
+}
+/**
+* Local ELK for nodes inside a group (and edges wholly inside it).
+* Returns node bounds relative to (0,0) content origin (no group padding).
+*/
+async function layoutCellFlow(graph, group, measured, options, flowDirection) {
+	const nodeIds = new Set(collectDescendantNodeIds(graph, group.id));
+	if (nodeIds.size === 0) return /* @__PURE__ */ new Map();
+	const subGraph = {
+		...graph,
+		nodes: graph.nodes.filter((n) => nodeIds.has(n.id)),
+		edges: graph.edges.filter((e) => nodeIds.has(e.from) && nodeIds.has(e.to)),
+		groups: []
+	};
+	const subMeasured = measured.filter((m) => nodeIds.has(m.nodeId));
+	if (subMeasured.length === 0) return /* @__PURE__ */ new Map();
+	if (subGraph.edges.length === 0) return packNodes(subMeasured.map((m) => m.nodeId), new Map(measured.map((m) => [m.nodeId, m])), flowDirection === "TD" || flowDirection === "BT" ? "stack" : "pack", options.density, resolveLeafGap(void 0, options));
+	const elkGraph = buildElkGraph(subGraph, subMeasured, {
+		...options,
+		direction: flowDirection,
+		groupLayout: "flat"
+	});
+	const laid = await getElk().layout(elkGraph);
+	const out = /* @__PURE__ */ new Map();
+	for (const child of laid.children ?? []) {
+		if (!nodeIds.has(child.id)) continue;
+		out.set(child.id, {
+			x: child.x ?? 0,
+			y: child.y ?? 0,
+			width: child.width ?? 0,
+			height: child.height ?? 0
+		});
+	}
+	const box = aabbOf(out.values());
+	if (box && (box.x !== 0 || box.y !== 0)) offsetRects(out, -box.x, -box.y);
+	return out;
+}
+/** Center (or start/end) content inside a stretched slot's padded inner box. */
+function contentOriginInSlot(slot, pad, contentBox, align) {
+	const innerW = Math.max(0, slot.width - pad.left - pad.right);
+	const innerH = Math.max(0, slot.height - pad.top - pad.bottom);
+	const freeX = Math.max(0, innerW - contentBox.width);
+	const freeY = Math.max(0, innerH - contentBox.height);
+	const ox = align === "end" ? freeX : align === "start" ? 0 : freeX / 2;
+	const oy = align === "end" ? freeY : align === "start" ? 0 : freeY / 2;
+	return {
+		x: slot.x + pad.left + ox,
+		y: slot.y + pad.top + oy
+	};
+}
+function collectDescendantNodeIds(graph, groupId) {
+	const group = graph.groups.find((g) => g.id === groupId);
+	if (!group) return [];
+	const ids = [...group.nodeIds];
+	const stack = [...group.childGroupIds];
+	while (stack.length) {
+		const cid = stack.pop();
+		const child = graph.groups.find((g) => g.id === cid);
+		if (!child) continue;
+		ids.push(...child.nodeIds);
+		stack.push(...child.childGroupIds);
+	}
+	return ids;
+}
+function childGroupsOf(graph, parentId) {
+	return graph.groups.filter((g) => g.parentId === parentId);
+}
+/** Reconstruct declaration order when `members` is missing (older compiled graphs). */
+function fallbackTrackMembers(graph, parent, children) {
+	const items = [];
+	for (const id of parent.nodeIds) {
+		const n = graph.nodes.find((node) => node.id === id);
+		items.push({
+			kind: "node",
+			id,
+			order: n?.sourceRange?.start.offset ?? Number.MAX_SAFE_INTEGER
+		});
+	}
+	for (const child of children) {
+		let order = Number.MAX_SAFE_INTEGER;
+		for (const nid of collectDescendantNodeIds(graph, child.id)) {
+			const o = graph.nodes.find((node) => node.id === nid)?.sourceRange?.start.offset;
+			if (o != null) order = Math.min(order, o);
+		}
+		items.push({
+			kind: "group",
+			id: child.id,
+			order
+		});
+	}
+	items.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+	return items.map(({ kind, id }) => kind === "node" ? {
+		kind: "node",
+		id
+	} : {
+		kind: "group",
+		id
+	});
+}
+/** Diagram-level declaration order across ungrouped nodes and top-level regions. */
+function topLevelTrackMembers(graph, children) {
+	const items = graph.nodes.filter((node) => node.groupId == null).map((node) => ({
+		kind: "node",
+		id: node.id,
+		order: node.sourceRange?.start.offset ?? Number.MAX_SAFE_INTEGER
+	}));
+	for (const child of children) {
+		let order = Number.MAX_SAFE_INTEGER;
+		for (const nodeId of collectDescendantNodeIds(graph, child.id)) {
+			const offset = graph.nodes.find((node) => node.id === nodeId)?.sourceRange?.start.offset;
+			if (offset != null) order = Math.min(order, offset);
+		}
+		items.push({
+			kind: "group",
+			id: child.id,
+			order
+		});
+	}
+	items.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+	return items.map(({ kind, id }) => ({
+		kind,
+		id
+	}));
+}
+/**
+* Layout one arranged parent: size children, pack tracks, write world node/group bounds.
+* Direct member nodes participate as track cells (declaration order via `members`).
+*/
+async function layoutArrangedParent(ctx, parent) {
+	const arrange = parent?.arrange ?? ctx.options.arrange;
+	if (!arrange) return;
+	const children = childGroupsOf(ctx.graph, parent?.id);
+	const trackMembers = parent?.members && parent.members.length > 0 ? parent.members : parent ? fallbackTrackMembers(ctx.graph, parent, children) : topLevelTrackMembers(ctx.graph, children);
+	if (trackMembers.length === 0) return;
+	const align = parent?.align ?? ctx.options.align ?? "stretch";
+	const flowDirection = cellFlowDirection(arrange);
+	const childById = new Map(children.map((g) => [g.id, g]));
+	for (const child of children) if (groupHasRegionArrange(child)) await layoutArrangedParent(ctx, child);
+	const cells = [];
+	const childContent = /* @__PURE__ */ new Map();
+	for (const member of trackMembers) {
+		if (member.kind === "node") {
+			const m = ctx.measureMap.get(member.id);
+			if (!m) continue;
+			cells.push({
+				groupId: nodeCellId(member.id),
+				width: m.width,
+				height: m.height
+			});
+			continue;
+		}
+		const child = childById.get(member.id);
+		if (!child) continue;
+		let content;
+		if (ctx.groupBounds.has(child.id) && groupHasRegionArrange(child)) {
+			const gb = ctx.groupBounds.get(child.id);
+			cells.push({
+				groupId: child.id,
+				width: gb.width,
+				height: gb.height,
+				column: child.column,
+				row: child.row,
+				colSpan: child.colSpan ?? child.span,
+				rowSpan: child.rowSpan
+			});
+			continue;
+		}
+		const mode = child.cellArrange ?? "flow";
+		const leafGap = resolveLeafGap(child.gap, ctx.options);
+		if (mode === "pack" || mode === "stack") content = packNodes(child.nodeIds, ctx.measureMap, mode, ctx.options.density, leafGap);
+		else content = await layoutCellFlow(ctx.graph, child, ctx.measured, ctx.options, flowDirection);
+		childContent.set(child.id, content);
+		const pad = paddingForGroup(child);
+		const contentBox = aabbOf(content.values()) ?? {
+			x: 0,
+			y: 0,
+			width: 80,
+			height: 40
+		};
+		const width = contentBox.width + pad.left + pad.right;
+		const height = contentBox.height + pad.top + pad.bottom;
+		cells.push({
+			groupId: child.id,
+			width,
+			height,
+			column: child.column,
+			row: child.row,
+			colSpan: child.colSpan ?? child.span,
+			rowSpan: child.rowSpan
+		});
+	}
+	const placed = regionArrange({
+		arrange,
+		align,
+		gap: resolveTrackGap(parent?.gap ?? ctx.options.gap, ctx.options),
+		columns: parent?.columns ?? ctx.options.columns,
+		rows: parent?.rows ?? ctx.options.rows,
+		cells,
+		origin: {
+			x: 64,
+			y: 64
+		}
+	});
+	for (const slot of placed) {
+		const directNodeId = parseNodeCellId(slot.groupId);
+		if (directNodeId) {
+			const m = ctx.measureMap.get(directNodeId);
+			if (m) {
+				const contentBox = {
+					x: 0,
+					y: 0,
+					width: m.width,
+					height: m.height
+				};
+				const origin = contentOriginInSlot(slot.bounds, {
+					top: 0,
+					right: 0,
+					bottom: 0,
+					left: 0
+				}, contentBox, align);
+				ctx.nodeBounds.set(directNodeId, {
+					x: origin.x,
+					y: origin.y,
+					width: m.width,
+					height: m.height
+				});
+			} else ctx.nodeBounds.set(directNodeId, { ...slot.bounds });
+			continue;
+		}
+		const child = childById.get(slot.groupId);
+		if (!child) continue;
+		const pad = paddingForGroup(child);
+		const content = childContent.get(child.id);
+		if (content) {
+			ctx.groupBounds.set(child.id, slot.bounds);
+			const contentBox = aabbOf(content.values()) ?? {
+				x: 0,
+				y: 0,
+				width: 0,
+				height: 0
+			};
+			const origin = contentOriginInSlot(slot.bounds, pad, contentBox, align);
+			for (const [nodeId, local] of content) ctx.nodeBounds.set(nodeId, {
+				x: origin.x + (local.x - contentBox.x),
+				y: origin.y + (local.y - contentBox.y),
+				width: local.width,
+				height: local.height
+			});
+		} else if (groupHasRegionArrange(child)) {
+			const prev = ctx.groupBounds.get(child.id);
+			if (prev) {
+				const dx = slot.bounds.x - prev.x;
+				const dy = slot.bounds.y - prev.y;
+				ctx.groupBounds.set(child.id, slot.bounds);
+				if (dx !== 0 || dy !== 0) {
+					for (const nid of collectDescendantNodeIds(ctx.graph, child.id)) {
+						const b = ctx.nodeBounds.get(nid);
+						if (b) ctx.nodeBounds.set(nid, {
+							...b,
+							x: b.x + dx,
+							y: b.y + dy
+						});
+					}
+					const stack = [...child.childGroupIds];
+					while (stack.length) {
+						const cid = stack.pop();
+						const gb = ctx.groupBounds.get(cid);
+						if (gb) ctx.groupBounds.set(cid, {
+							...gb,
+							x: gb.x + dx,
+							y: gb.y + dy
+						});
+						const g = ctx.graph.groups.find((x) => x.id === cid);
+						if (g) stack.push(...g.childGroupIds);
+					}
+				}
+			} else ctx.groupBounds.set(child.id, slot.bounds);
+		} else ctx.groupBounds.set(child.id, slot.bounds);
+	}
+	if (parent) {
+		const box = aabbOf(placed.map((p) => p.bounds));
+		if (box) {
+			const pad = paddingForGroup(parent);
+			ctx.groupBounds.set(parent.id, {
+				x: box.x - pad.left,
+				y: box.y - pad.top,
+				width: box.width + pad.left + pad.right,
+				height: box.height + pad.top + pad.bottom
+			});
+		}
+	}
+}
+function stubOrthogonalEdge(edgeId, fromId, toId, from, to, obstacles, pad, tFrom, tTo) {
+	const points = routeOrthogonalAvoiding(from, to, obstacles, pad, tFrom, tTo);
+	const start = points[0];
+	const end = points[points.length - 1];
+	const bendPoints = points.slice(1, -1);
+	return {
+		id: edgeId,
+		sources: [fromId],
+		targets: [toId],
+		sections: [{
+			id: `${edgeId}_s0`,
+			startPoint: {
+				x: start.x,
+				y: start.y
+			},
+			endPoint: {
+				x: end.x,
+				y: end.y
+			},
+			bendPoints
+		}]
+	};
+}
+function fanSlot(index, count) {
+	if (count <= 1) return .5;
+	return .28 + .44 * index / (count - 1);
+}
+function primaryExitSide(from, to) {
+	return preferredSidePair(from, to)[0];
+}
+function primaryEntrySide(from, to) {
+	return preferredSidePair(from, to)[1];
+}
+/** Sort key along a face — left→right for N/S, top→bottom for E/W. */
+function faceSortKey(node, other, side) {
+	const ox = other.x + other.width / 2;
+	const oy = other.y + other.height / 2;
+	if (side === "N" || side === "S") return ox - node.x;
+	return oy - node.y;
+}
+function rectsOverlap(a, b) {
+	return !(a.x + a.width < b.x || b.x + b.width < a.x || a.y + a.height < b.y || b.y + b.height < a.y);
+}
+/**
+* Channel between facing sides of two boxes (primary axis only).
+* Used to decide which group chrome actually sits *between* the endpoints.
+*/
+function facingStrip(from, to) {
+	const [fs] = preferredSidePair(from, to);
+	if (fs === "E" || fs === "W") {
+		const x0 = fs === "E" ? from.x + from.width : to.x + to.width;
+		const x1 = fs === "E" ? to.x : from.x;
+		if (x1 <= x0 + 1) return null;
+		const y0 = Math.min(from.y, to.y);
+		const y1 = Math.max(from.y + from.height, to.y + to.height);
+		return {
+			x: x0,
+			y: y0,
+			width: x1 - x0,
+			height: Math.max(1, y1 - y0)
+		};
+	}
+	const y0 = fs === "S" ? from.y + from.height : to.y + to.height;
+	const y1 = fs === "S" ? to.y : from.y;
+	if (y1 <= y0 + 1) return null;
+	const x0 = Math.min(from.x, to.x);
+	const x1 = Math.max(from.x + from.width, to.x + to.width);
+	return {
+		x: x0,
+		y: y0,
+		width: Math.max(1, x1 - x0),
+		height: y1 - y0
+	};
+}
+/**
+* Fan attach slots only among edges that share the same exit/entry face.
+* A lone edge on a face stays centered (t=0.5).
+*/
+function sideAwareFanSlots(routed, nodeBounds) {
+	const tFrom = /* @__PURE__ */ new Map();
+	const tTo = /* @__PURE__ */ new Map();
+	const outGroups = /* @__PURE__ */ new Map();
+	const inGroups = /* @__PURE__ */ new Map();
+	for (const e of routed) {
+		const from = nodeBounds.get(e.from);
+		const to = nodeBounds.get(e.to);
+		const outSide = primaryExitSide(from, to);
+		const inSide = primaryEntrySide(from, to);
+		const outKey = `${e.from}:${outSide}`;
+		const inKey = `${e.to}:${inSide}`;
+		if (!outGroups.has(outKey)) outGroups.set(outKey, []);
+		if (!inGroups.has(inKey)) inGroups.set(inKey, []);
+		outGroups.get(outKey).push({
+			edgeId: e.id,
+			key: faceSortKey(from, to, outSide)
+		});
+		inGroups.get(inKey).push({
+			edgeId: e.id,
+			key: faceSortKey(to, from, inSide)
+		});
+	}
+	for (const members of outGroups.values()) {
+		members.sort((a, b) => a.key - b.key);
+		members.forEach((m, i) => tFrom.set(m.edgeId, fanSlot(i, members.length)));
+	}
+	for (const members of inGroups.values()) {
+		members.sort((a, b) => a.key - b.key);
+		members.forEach((m, i) => tTo.set(m.edgeId, fanSlot(i, members.length)));
+	}
+	return {
+		tFrom,
+		tTo
+	};
+}
+function buildFixedElkGraph(graph, nodeBounds, groupBounds, options) {
+	const children = [];
+	for (const node of graph.nodes) {
+		const b = nodeBounds.get(node.id);
+		if (!b) continue;
+		children.push({
+			id: node.id,
+			x: b.x,
+			y: b.y,
+			width: b.width,
+			height: b.height
+		});
+	}
+	const clearance = Math.max(28, options.edgeNodeSpacing ?? 28);
+	const avoidPad = Math.min(12, clearance);
+	const routed = graph.edges.filter((e) => nodeBounds.has(e.from) && nodeBounds.has(e.to));
+	const { tFrom, tTo } = sideAwareFanSlots(routed, nodeBounds);
+	const memberCache = /* @__PURE__ */ new Map();
+	const membersOf = (groupId) => {
+		let set = memberCache.get(groupId);
+		if (!set) {
+			set = new Set(collectDescendantNodeIds(graph, groupId));
+			memberCache.set(groupId, set);
+		}
+		return set;
+	};
+	const descendantGroups = (groupId) => {
+		const out = /* @__PURE__ */ new Set([groupId]);
+		const stack = [groupId];
+		while (stack.length) {
+			const id = stack.pop();
+			const g = graph.groups.find((x) => x.id === id);
+			if (!g) continue;
+			for (const child of g.childGroupIds) {
+				if (out.has(child)) continue;
+				out.add(child);
+				stack.push(child);
+			}
+		}
+		return out;
+	};
+	/** Groups that contain `nodeId` but not `otherId`, plus their nested groups. */
+	const exclusiveSubtree = (nodeId, otherId) => {
+		const skip = /* @__PURE__ */ new Set();
+		for (const g of graph.groups) {
+			const members = membersOf(g.id);
+			if (!members.has(nodeId) || members.has(otherId)) continue;
+			for (const id of descendantGroups(g.id)) skip.add(id);
+		}
+		return skip;
+	};
+	const edges = routed.map((e) => {
+		const from = nodeBounds.get(e.from);
+		const to = nodeBounds.get(e.to);
+		const obstacles = [];
+		for (const [id, b] of nodeBounds) {
+			if (id === e.from || id === e.to) continue;
+			obstacles.push(b);
+		}
+		const strip = facingStrip(from, to);
+		if (strip) {
+			const skip = /* @__PURE__ */ new Set([...exclusiveSubtree(e.from, e.to), ...exclusiveSubtree(e.to, e.from)]);
+			for (const [gid, gb] of groupBounds) {
+				if (skip.has(gid)) continue;
+				const members = membersOf(gid);
+				if (members.has(e.from) || members.has(e.to)) continue;
+				if (!rectsOverlap(gb, strip)) continue;
+				obstacles.push(gb);
+			}
+		}
+		return stubOrthogonalEdge(e.id, e.from, e.to, from, to, obstacles, avoidPad, tFrom.get(e.id) ?? .5, tTo.get(e.id) ?? .5);
+	});
+	return {
+		id: "root",
+		layoutOptions: {
+			"elk.algorithm": "fixed",
+			"elk.edgeRouting": "ORTHOGONAL",
+			"elk.direction": options.direction === "TD" ? "DOWN" : options.direction === "BT" ? "UP" : options.direction === "RL" ? "LEFT" : "RIGHT",
+			"elk.spacing.nodeNode": "40",
+			"elk.spacing.edgeNode": String(clearance),
+			"elk.spacing.edgeEdge": String(options.edgeEdgeSpacing ?? 18),
+			"elk.padding": `[top=64,left=64,bottom=64,right=64]`
+		},
+		children,
+		edges
+	};
+}
+/**
+* Region-arrange path: local cell layouts → track packing → fixed-position ELK for edges.
+*/
+async function layoutAndRouteArranged(graph, measured, options) {
+	const t0 = performance.now();
+	const direction = options.direction ?? "LR";
+	const measureMap = new Map(measured.map((m) => [m.nodeId, m]));
+	const ctx = {
+		graph,
+		measured,
+		measureMap,
+		options,
+		nodeBounds: /* @__PURE__ */ new Map(),
+		groupBounds: /* @__PURE__ */ new Map()
+	};
+	if (options.arrange) await layoutArrangedParent(ctx, null);
+	else {
+		const roots = graph.groups.filter((g) => groupHasRegionArrange(g)).filter((g) => {
+			if (!g.parentId) return true;
+			const parent = graph.groups.find((p) => p.id === g.parentId);
+			return !parent || !groupHasRegionArrange(parent);
+		});
+		for (const root of roots) await layoutArrangedParent(ctx, root);
+	}
+	const placedIds = new Set(ctx.nodeBounds.keys());
+	const residualIds = graph.nodes.filter((n) => !placedIds.has(n.id)).map((n) => n.id);
+	if (residualIds.length) {
+		const residualSet = new Set(residualIds);
+		const sources = [];
+		const sinks = [];
+		const other = [];
+		for (const id of residualIds) {
+			const feedsIn = graph.edges.some((e) => e.from === id && !residualSet.has(e.to));
+			const fedFrom = graph.edges.some((e) => e.to === id && !residualSet.has(e.from));
+			if (feedsIn && !fedFrom) sources.push(id);
+			else if (fedFrom && !feedsIn) sinks.push(id);
+			else other.push(id);
+		}
+		const placePack = (ids, side) => {
+			if (ids.length === 0) return;
+			const packed = packNodes(ids, measureMap, direction === "TD" || direction === "BT" ? "pack" : "stack", options.density, resolveLeafGap(void 0, options));
+			const packedBox = aabbOf(packed.values()) ?? {
+				x: 0,
+				y: 0,
+				width: 80,
+				height: 40
+			};
+			const arrangedBox = aabbOf(ctx.nodeBounds.values());
+			let originX = 64;
+			let originY = 64;
+			if (arrangedBox) if (direction === "TD" || direction === "BT") {
+				originX = arrangedBox.x;
+				originY = side === "before" ? arrangedBox.y - packedBox.height - DEFAULT_RESIDUAL_GAP : arrangedBox.y + arrangedBox.height + DEFAULT_RESIDUAL_GAP;
+			} else {
+				originY = arrangedBox.y;
+				originX = side === "before" ? arrangedBox.x - packedBox.width - DEFAULT_RESIDUAL_GAP : arrangedBox.x + arrangedBox.width + DEFAULT_RESIDUAL_GAP;
+			}
+			for (const [id, b] of packed) ctx.nodeBounds.set(id, {
+				...b,
+				x: b.x - packedBox.x + originX,
+				y: b.y - packedBox.y + originY
+			});
+		};
+		placePack(sources, "before");
+		placePack([...sinks, ...other], "after");
+		const allBox = aabbOf(ctx.nodeBounds.values());
+		if (allBox && (allBox.x < 64 || allBox.y < 64)) {
+			const dx = Math.max(0, 64 - allBox.x);
+			const dy = Math.max(0, 64 - allBox.y);
+			if (dx || dy) {
+				for (const [id, b] of ctx.nodeBounds) ctx.nodeBounds.set(id, {
+					...b,
+					x: b.x + dx,
+					y: b.y + dy
+				});
+				for (const [id, b] of ctx.groupBounds) ctx.groupBounds.set(id, {
+					...b,
+					x: b.x + dx,
+					y: b.y + dy
+				});
+			}
+		}
+	}
+	const elkGraph = buildFixedElkGraph(graph, ctx.nodeBounds, ctx.groupBounds, {
+		...options,
+		direction
+	});
+	const laid = await getElk().layout(elkGraph);
+	const laidOutNodes = ranksFromFixed([...ctx.nodeBounds.entries()].map(([nodeId, bounds]) => ({
+		nodeId,
+		bounds,
+		rank: 0,
+		order: 0
+	})), direction);
+	const groups = [];
+	for (const g of graph.groups) {
+		const bounds = ctx.groupBounds.get(g.id);
+		if (!bounds) continue;
+		const padding = paddingForGroup(g);
+		groups.push({
+			groupId: g.id,
+			bounds,
+			labelBox: measureGroupLabelBox(g.label, bounds, Boolean(g.icon && g.icon !== "none" && g.chrome !== false)),
+			padding
+		});
+	}
+	const rawPaths = [];
+	for (const edge of laid.edges ?? []) {
+		const points = [];
+		for (const section of edge.sections ?? []) {
+			points.push({ ...section.startPoint });
+			for (const bend of section.bendPoints ?? []) points.push({ ...bend });
+			points.push({ ...section.endPoint });
+		}
+		if (points.length >= 2) rawPaths.push({
+			edgeId: edge.id,
+			points
+		});
+	}
+	const walkEdges = (node) => {
+		for (const edge of node.edges ?? []) {
+			if (rawPaths.some((p) => p.edgeId === edge.id)) continue;
+			const points = [];
+			for (const section of edge.sections ?? []) {
+				points.push({
+					x: (section.startPoint.x ?? 0) + (node.x ?? 0),
+					y: (section.startPoint.y ?? 0) + (node.y ?? 0)
+				});
+				for (const bend of section.bendPoints ?? []) points.push({
+					x: bend.x + (node.x ?? 0),
+					y: bend.y + (node.y ?? 0)
+				});
+				points.push({
+					x: (section.endPoint.x ?? 0) + (node.x ?? 0),
+					y: (section.endPoint.y ?? 0) + (node.y ?? 0)
+				});
+			}
+			if (points.length >= 2) rawPaths.push({
+				edgeId: edge.id,
+				points
+			});
+		}
+		for (const c of node.children ?? []) walkEdges(c);
+	};
+	walkEdges(laid);
+	const edgePaths = snapEdgeEndpointsToGeometry(graph, laidOutNodes, rawPaths).map((path) => ({
+		...path,
+		points: ensureOrthogonalPoints(collapseColinearPoints(path.points))
+	}));
+	const edgeLabels = [];
+	let maxX = 0;
+	let maxY = 0;
+	for (const n of laidOutNodes) {
+		maxX = Math.max(maxX, n.bounds.x + n.bounds.width);
+		maxY = Math.max(maxY, n.bounds.y + n.bounds.height);
+	}
+	for (const g of groups) {
+		maxX = Math.max(maxX, g.bounds.x + g.bounds.width);
+		maxY = Math.max(maxY, g.bounds.y + g.bounds.height);
+	}
+	for (const path of edgePaths) for (const p of path.points) {
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.y);
+	}
+	return {
+		layout: {
+			nodes: laidOutNodes,
+			groups,
+			edgePaths,
+			edgeLabels,
+			direction,
+			algorithmVersion: ELK_LAYOUT_ALGORITHM,
+			layoutMs: performance.now() - t0,
+			width: maxX + 8,
+			height: maxY + 8
+		},
+		edges: edgePaths,
+		routerAlgorithm: ELK_ROUTER_ALGORITHM
+	};
+}
+const DEFAULT_RESIDUAL_GAP = 48;
+//#endregion
+//#region src/layout/sequence/layout-sequence.ts
+const SEQUENCE_LAYOUT_ALGORITHM = "sequence-v1";
+const SEQUENCE_ROUTER_ALGORITHM = "sequence-direct-v1";
+const HEADER_GAP = 32;
+const PARTICIPANT_GAP = 48;
+/** Vertical pitch per message/note/divider order — room for label above the path. */
+const SLOT_H = 52;
+const LABEL_GAP = 14;
+const FRAGMENT_PAD_X = 14;
+const ACTIVATION_W = 10;
+const SELF_LOOP_W = 44;
+const SELF_LOOP_EXTRA = 22;
+const MARGIN = 24;
+const NOTE_PAD = 10;
+const NOTE_LINE = 15;
+const NOTE_BAND_GAP = 12;
+const DIVIDER_BAND = 36;
+function densityScale(density) {
+	if (density === "compact") return .88;
+	if (density === "spacious") return 1.22;
+	return 1;
+}
+/**
+* Build cumulative Y baselines for each order index.
+* Notes, dividers, self-messages, and fragment edges reserve extra vertical band
+* so labels/boxes don't collide with neighboring message paths.
+*/
+function buildOrderBaselines(seq, contentTop, slotH) {
+	const maxOrder = Math.max(0, ...seq.messages.map((m) => m.order), ...seq.notes.map((n) => n.order), ...seq.dividers.map((d) => d.order), ...seq.activations.map((a) => a.endOrder));
+	const noteAt = new Map(seq.notes.map((n) => [n.order, n]));
+	const dividerAt = new Map(seq.dividers.map((d) => [d.order, d]));
+	const selfAt = new Set(seq.messages.filter((m) => m.from && m.to && m.from === m.to).map((m) => m.order));
+	const fragStart = /* @__PURE__ */ new Set();
+	const fragEnd = /* @__PURE__ */ new Set();
+	const operandSepBefore = /* @__PURE__ */ new Set();
+	const walkFrags = (fragments) => {
+		for (const frag of fragments) {
+			fragStart.add(frag.startOrder);
+			fragEnd.add(frag.endOrder);
+			for (let i = 1; i < frag.operands.length; i++) operandSepBefore.add(frag.operands[i].startOrder);
+			for (const op of frag.operands) walkFrags(op.children);
+		}
+	};
+	walkFrags(seq.fragments);
+	const yBaselines = /* @__PURE__ */ new Map();
+	const tops = /* @__PURE__ */ new Map();
+	const bottoms = /* @__PURE__ */ new Map();
+	let cursor = contentTop;
+	for (let order = 0; order <= maxOrder; order++) {
+		let topPad = 0;
+		let band = slotH;
+		let bottomPad = 0;
+		if (fragStart.has(order)) topPad += 46;
+		if (operandSepBefore.has(order)) topPad += 18;
+		const note = noteAt.get(order);
+		if (note) band = Math.max(band, measureNoteHeight(note.text) + NOTE_BAND_GAP);
+		if (dividerAt.has(order)) band = Math.max(band, DIVIDER_BAND);
+		if (selfAt.has(order)) band = Math.max(band, slotH + SELF_LOOP_EXTRA);
+		if (fragEnd.has(order)) bottomPad += 24;
+		const top = cursor;
+		const center = cursor + topPad + band / 2;
+		const bottom = cursor + topPad + band + bottomPad;
+		tops.set(order, top);
+		yBaselines.set(order, center);
+		bottoms.set(order, bottom);
+		cursor = bottom;
+	}
+	const fallback = (order) => contentTop + order * slotH;
+	return {
+		yAt: (order) => yBaselines.get(order) ?? fallback(order) + slotH / 2,
+		bandTop: (order) => tops.get(order) ?? fallback(order),
+		bandBottom: (order) => bottoms.get(order) ?? fallback(order) + slotH,
+		bottomY: cursor + MARGIN
+	};
+}
+function measureNoteHeight(text) {
+	return Math.max(1, Math.ceil(text.length / 32)) * NOTE_LINE + NOTE_PAD * 2;
+}
+/**
+* Time-axis sequence layout: participants on X, messages ordered on Y.
+*/
+function layoutSequence(graph, measured, options = {}) {
+	const t0 = performance.now();
+	const seq = graph.sequence;
+	if (!seq) return emptySequenceResult(t0);
+	const scale = densityScale(options.density);
+	const slotH = SLOT_H * scale;
+	const participantGap = PARTICIPANT_GAP * scale;
+	const measuredById = new Map(measured.map((m) => [m.nodeId, m]));
+	const nodes = [];
+	const centers = /* @__PURE__ */ new Map();
+	let x = MARGIN;
+	let headerH = 40;
+	for (const [i, id] of seq.participantOrder.entries()) {
+		const m = measuredById.get(id);
+		const w = m?.width ?? 120;
+		const h = m?.height ?? 40;
+		headerH = Math.max(headerH, h);
+		const bounds = {
+			x,
+			y: MARGIN,
+			width: w,
+			height: h
+		};
+		nodes.push({
+			nodeId: id,
+			bounds,
+			rank: 0,
+			order: i
+		});
+		centers.set(id, x + w / 2);
+		x += w + participantGap;
+	}
+	const { yAt, bandTop, bandBottom, bottomY } = buildOrderBaselines(seq, MARGIN + headerH + HEADER_GAP * scale, slotH);
+	const messages = [];
+	const edgePaths = [];
+	const edgeLabels = [];
+	let msgNumber = 0;
+	for (const msg of seq.messages) {
+		if (seq.autonumber && msg.kind !== "destroy") msgNumber += 1;
+		const y = yAt(msg.order);
+		const fromX = msg.from && centers.has(msg.from) ? centers.get(msg.from) : msg.kind === "found" ? (centers.get(msg.to) ?? MARGIN) - 40 : MARGIN;
+		const toX = msg.to && centers.has(msg.to) ? centers.get(msg.to) : msg.kind === "lost" ? (centers.get(msg.from) ?? MARGIN) + 40 : fromX;
+		let points;
+		if (msg.kind === "destroy") {
+			const cx = centers.get(msg.from) ?? fromX;
+			points = [
+				{
+					x: cx - 8,
+					y: y - 8
+				},
+				{
+					x: cx + 8,
+					y: y + 8
+				},
+				{
+					x: cx + 8,
+					y: y - 8
+				},
+				{
+					x: cx - 8,
+					y: y + 8
+				}
+			];
+		} else if (msg.from && msg.to && msg.from === msg.to) {
+			const cx = centers.get(msg.from);
+			const loopDepth = Math.max(18, SELF_LOOP_EXTRA * scale);
+			points = [
+				{
+					x: cx,
+					y: y - loopDepth * .15
+				},
+				{
+					x: cx + SELF_LOOP_W,
+					y: y - loopDepth * .15
+				},
+				{
+					x: cx + SELF_LOOP_W,
+					y: y + loopDepth * .85
+				},
+				{
+					x: cx,
+					y: y + loopDepth * .85
+				}
+			];
+		} else points = [{
+			x: fromX,
+			y
+		}, {
+			x: toX,
+			y
+		}];
+		const labelCenter = points.length >= 2 ? {
+			x: (points[0].x + points[points.length - 1].x) / 2,
+			y: Math.min(points[0].y, points[points.length - 1].y) - LABEL_GAP
+		} : void 0;
+		messages.push({
+			messageId: msg.id,
+			kind: msg.kind,
+			points,
+			label: msg.label,
+			labelCenter,
+			number: seq.autonumber && msg.kind !== "destroy" ? msgNumber : void 0
+		});
+		if (msg.from && msg.to && msg.from !== "*" && msg.to !== "*") edgePaths.push({
+			edgeId: msg.id,
+			points
+		});
+	}
+	const lifelines = [];
+	for (const id of seq.participantOrder) {
+		const cx = centers.get(id);
+		const node = nodes.find((n) => n.nodeId === id);
+		lifelines.push({
+			participantId: id,
+			x: cx,
+			y0: node.bounds.y + node.bounds.height,
+			y1: bottomY
+		});
+	}
+	const activations = seq.activations.map((a) => {
+		const cx = centers.get(a.participantId) ?? MARGIN;
+		const y0 = yAt(a.startOrder) - 6;
+		const y1 = yAt(a.endOrder) + 6;
+		return {
+			id: a.id,
+			participantId: a.participantId,
+			startOrder: a.startOrder,
+			endOrder: a.endOrder,
+			bounds: {
+				x: cx - ACTIVATION_W / 2,
+				y: Math.min(y0, y1),
+				width: ACTIVATION_W,
+				height: Math.max(8, Math.abs(y1 - y0))
+			}
+		};
+	});
+	const fragments = [];
+	const layoutFrag = (frag, depth) => {
+		const xs = seq.participantOrder.map((id) => centers.get(id));
+		const minX = Math.min(...xs) - FRAGMENT_PAD_X - depth * 6;
+		const maxX = Math.max(...xs) + FRAGMENT_PAD_X + depth * 6;
+		const y0 = bandTop(frag.startOrder) + 2;
+		const y1 = bandBottom(frag.endOrder) - 2;
+		const separators = [];
+		const operandLabels = [];
+		const operandBands = [];
+		for (let i = 0; i < frag.operands.length; i++) {
+			const op = frag.operands[i];
+			const opTop = i === 0 ? y0 : bandTop(op.startOrder);
+			const opBottom = i === frag.operands.length - 1 ? y1 : bandTop(frag.operands[i + 1].startOrder);
+			operandBands.push({
+				startOrder: op.startOrder,
+				endOrder: op.endOrder,
+				styleRefs: op.styleRefs,
+				bounds: {
+					x: minX,
+					y: opTop,
+					width: maxX - minX,
+					height: Math.max(8, opBottom - opTop)
+				}
+			});
+			if (i > 0) {
+				separators.push(opTop);
+				if (op.label) operandLabels.push({
+					text: op.label,
+					x: minX + 8,
+					y: opTop + 4
+				});
+			}
+		}
+		if (frag.label) operandLabels.unshift({
+			text: `${sequenceFragmentDisplayName(frag.operator)} [${frag.label}]`,
+			x: minX + 8,
+			y: y0 + 6
+		});
+		else operandLabels.unshift({
+			text: sequenceFragmentDisplayName(frag.operator),
+			x: minX + 8,
+			y: y0 + 6
+		});
+		fragments.push({
+			id: frag.id,
+			operator: frag.operator,
+			label: frag.label,
+			styleRefs: frag.styleRefs,
+			unresolvedVars: frag.unresolvedVars,
+			bounds: {
+				x: minX,
+				y: y0,
+				width: maxX - minX,
+				height: Math.max(24, y1 - y0)
+			},
+			startOrder: frag.startOrder,
+			endOrder: frag.endOrder,
+			separators,
+			operandLabels,
+			operandBands
+		});
+		for (const op of frag.operands) for (const child of op.children) layoutFrag(child, depth + 1);
+	};
+	for (const frag of seq.fragments) layoutFrag(frag, 0);
+	const notes = seq.notes.map((n) => {
+		const y = yAt(n.order);
+		const h = measureNoteHeight(n.text);
+		const ids = n.participantIds.filter((id) => centers.has(id));
+		let x0;
+		let x1;
+		if (n.placement === "over" && ids.length) {
+			const xs = ids.map((id) => centers.get(id));
+			x0 = Math.min(...xs) - 24;
+			x1 = Math.max(...xs) + 24;
+		} else if (n.placement === "left" && ids[0]) {
+			const cx = centers.get(ids[0]);
+			x0 = cx - 150;
+			x1 = cx - 24;
+		} else if (ids[0]) {
+			const cx = centers.get(ids[0]);
+			x0 = cx + 24;
+			x1 = cx + 150;
+		} else {
+			x0 = MARGIN;
+			x1 = 144;
+		}
+		const w = Math.max(80, x1 - x0);
+		return {
+			id: n.id,
+			text: n.text,
+			bounds: {
+				x: x0,
+				y: y - h / 2,
+				width: w,
+				height: h
+			}
+		};
+	});
+	const firstX = Math.min(...centers.values(), MARGIN);
+	const lastX = Math.max(...centers.values(), MARGIN);
+	const sequence = {
+		lifelines,
+		activations,
+		fragments,
+		notes,
+		dividers: seq.dividers.map((d) => ({
+			id: d.id,
+			y: yAt(d.order) + 4,
+			x0: firstX - 20,
+			x1: lastX + 20,
+			label: d.label
+		})),
+		messages
+	};
+	let maxX = x;
+	let maxY = bottomY;
+	for (const f of fragments) {
+		maxX = Math.max(maxX, f.bounds.x + f.bounds.width);
+		maxY = Math.max(maxY, f.bounds.y + f.bounds.height);
+	}
+	for (const n of notes) {
+		maxX = Math.max(maxX, n.bounds.x + n.bounds.width);
+		maxY = Math.max(maxY, n.bounds.y + n.bounds.height);
+	}
+	for (const path of edgePaths) for (const p of path.points) {
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.y);
+	}
+	return {
+		layout: {
+			nodes,
+			groups: [],
+			edgePaths,
+			edgeLabels,
+			direction: "TD",
+			algorithmVersion: SEQUENCE_LAYOUT_ALGORITHM,
+			layoutMs: performance.now() - t0,
+			width: maxX + MARGIN,
+			height: maxY + MARGIN,
+			sequence
+		},
+		edges: edgePaths,
+		routerAlgorithm: SEQUENCE_ROUTER_ALGORITHM
+	};
+}
+function emptySequenceResult(t0) {
+	return {
+		layout: {
+			nodes: [],
+			groups: [],
+			edgePaths: [],
+			edgeLabels: [],
+			direction: "TD",
+			algorithmVersion: SEQUENCE_LAYOUT_ALGORITHM,
+			layoutMs: performance.now() - t0,
+			width: 0,
+			height: 0
+		},
+		edges: [],
+		routerAlgorithm: SEQUENCE_ROUTER_ALGORITHM
+	};
+}
+function isSequenceGraph(graph) {
+	return graph.diagramKind === "sequence" || graph.sequence != null;
+}
+//#endregion
+//#region src/layout/elk/layout-with-elk.ts
+function collectAbsoluteNodes(node, offsetX, offsetY, parentId, boundsOut, index) {
+	const x = offsetX + (node.x ?? 0);
+	const y = offsetY + (node.y ?? 0);
+	const bounds = {
+		x,
+		y,
+		width: node.width ?? 0,
+		height: node.height ?? 0
+	};
+	index.set(node.id, {
+		bounds,
+		parentId
+	});
+	if (node.id !== "root") boundsOut.set(node.id, bounds);
+	for (const child of node.children ?? []) collectAbsoluteNodes(child, x, y, node.id, boundsOut, index);
+}
+/**
+* With INCLUDE_CHILDREN, ELK may list edges on the root while section/label
+* coordinates stay relative to the LCA of the endpoints (often a compound group).
+* Offset by that LCA's absolute origin — not the edges-array owner.
+*/
+function edgeCoordinateOrigin(index, sourceId, targetId) {
+	if (!sourceId || !targetId) return {
+		x: 0,
+		y: 0
+	};
+	const sourceNode = endpointNodeId(sourceId);
+	const targetNode = endpointNodeId(targetId);
+	const ancestors = /* @__PURE__ */ new Set();
+	let cur = sourceNode;
+	while (cur) {
+		ancestors.add(cur);
+		cur = index.get(cur)?.parentId ?? null;
+	}
+	cur = targetNode;
+	while (cur) {
+		if (ancestors.has(cur)) {
+			const hit = index.get(cur);
+			return hit ? {
+				x: hit.bounds.x,
+				y: hit.bounds.y
+			} : {
+				x: 0,
+				y: 0
+			};
+		}
+		cur = index.get(cur)?.parentId ?? null;
+	}
+	return {
+		x: 0,
+		y: 0
+	};
+}
+function collectAbsoluteEdges(node, index, paths, labels, seen) {
+	for (const edge of node.edges ?? []) {
+		if (seen.has(edge.id)) continue;
+		seen.add(edge.id);
+		const origin = edgeCoordinateOrigin(index, edge.sources?.[0], edge.targets?.[0]);
+		const points = edgePoints(edge, origin.x, origin.y);
+		if (points.length >= 2) paths.push({
+			edgeId: edge.id,
+			points
+		});
+		for (const label of edge.labels ?? []) {
+			if (label.x == null || label.y == null || !label.width || !label.height) continue;
+			const bounds = {
+				x: origin.x + label.x,
+				y: origin.y + label.y,
+				width: label.width,
+				height: label.height
+			};
+			labels.push({
+				edgeId: edge.id,
+				text: label.text,
+				bounds,
+				anchor: {
+					x: bounds.x + bounds.width / 2,
+					y: bounds.y + bounds.height / 2
+				}
+			});
+		}
+	}
+	for (const child of node.children ?? []) collectAbsoluteEdges(child, index, paths, labels, seen);
+}
+function edgePoints(edge, offsetX, offsetY) {
+	const points = [];
+	for (const section of edge.sections ?? []) {
+		points.push({
+			x: section.startPoint.x + offsetX,
+			y: section.startPoint.y + offsetY
+		});
+		for (const bend of section.bendPoints ?? []) points.push({
+			x: bend.x + offsetX,
+			y: bend.y + offsetY
+		});
+		points.push({
+			x: section.endPoint.x + offsetX,
+			y: section.endPoint.y + offsetY
+		});
+	}
+	return dedupePoints(points);
+}
+function dedupePoints(points) {
+	const out = [];
+	for (const p of points) {
+		const prev = out[out.length - 1];
+		if (prev && Math.abs(prev.x - p.x) < .5 && Math.abs(prev.y - p.y) < .5) continue;
+		out.push(p);
+	}
+	return out;
+}
+function ranksFromBounds(nodes, direction) {
+	const dir = direction ?? "LR";
+	const horizontal = dir === "LR" || dir === "RL";
+	const sorted = [...nodes].sort((a, b) => {
+		const aPrimary = horizontal ? a.bounds.x : a.bounds.y;
+		const bPrimary = horizontal ? b.bounds.x : b.bounds.y;
+		if (aPrimary !== bPrimary) return aPrimary - bPrimary;
+		return (horizontal ? a.bounds.y : a.bounds.x) - (horizontal ? b.bounds.y : b.bounds.x);
+	});
+	const rankOf = /* @__PURE__ */ new Map();
+	let rank = 0;
+	let lastPrimary = Number.NEGATIVE_INFINITY;
+	for (const n of sorted) {
+		const primary = horizontal ? n.bounds.x : n.bounds.y;
+		if (primary - lastPrimary > 8) {
+			if (lastPrimary !== Number.NEGATIVE_INFINITY) rank += 1;
+			lastPrimary = primary;
+		}
+		rankOf.set(n.nodeId, rank);
+	}
+	const orderInRank = /* @__PURE__ */ new Map();
+	return sorted.map((n) => {
+		const r = rankOf.get(n.nodeId) ?? 0;
+		const order = orderInRank.get(r) ?? 0;
+		orderInRank.set(r, order + 1);
+		return {
+			nodeId: n.nodeId,
+			bounds: n.bounds,
+			rank: r,
+			order
+		};
+	});
+}
+function groupsFromElk(graph, absolute, laidOutNodes) {
+	const fallback = computeGroupBounds(graph, laidOutNodes);
+	const byId = new Map(fallback.map((g) => [g.groupId, g]));
+	for (const group of graph.groups) {
+		const elkBounds = absolute.get(`group:${group.id}`);
+		if (!elkBounds || elkBounds.width <= 0 || elkBounds.height <= 0) continue;
+		const padding = paddingForGroup(group);
+		byId.set(group.id, {
+			groupId: group.id,
+			bounds: elkBounds,
+			labelBox: measureGroupLabelBox(group.label, elkBounds, Boolean(group.icon && group.icon !== "none" && group.chrome !== false)),
+			padding
+		});
+	}
+	return [...byId.values()];
+}
+/**
+* Layout + orthogonal edge routes via ELK (elkjs API; elk-rs drop-in when published).
+*/
+async function layoutAndRouteWithElk(graph, measured, options = {}) {
+	if (isSequenceGraph(graph)) return layoutSequence(graph, measured, options);
+	if (needsRegionArrange(graph, options)) return layoutAndRouteArranged(graph, measured, options);
+	const t0 = performance.now();
+	const direction = options.direction ?? "LR";
+	const elkGraph = buildElkGraph(graph, measured, {
+		...options,
+		direction
+	});
+	const laid = await getElk().layout(elkGraph);
+	const absolute = /* @__PURE__ */ new Map();
+	const index = /* @__PURE__ */ new Map();
+	collectAbsoluteNodes(laid, 0, 0, null, absolute, index);
+	const laidOutNodes = ranksFromBounds(graph.nodes.map((n) => {
+		const b = absolute.get(n.id);
+		if (!b) return null;
+		return {
+			nodeId: n.id,
+			bounds: b
+		};
+	}).filter((n) => n != null), direction);
+	const groups = groupsFromElk(graph, absolute, laidOutNodes);
+	const rawPaths = [];
+	const rawLabels = [];
+	collectAbsoluteEdges(laid, index, rawPaths, rawLabels, /* @__PURE__ */ new Set());
+	const edgePaths = polishEdgePaths(snapEdgeEndpointsToGeometry(graph, laidOutNodes, rawPaths), laidOutNodes.map((n) => n.bounds), Math.max(28, options.edgeNodeSpacing ?? 28));
+	const edgeLabels = rawLabels;
+	let maxX = 0;
+	let maxY = 0;
+	for (const n of laidOutNodes) {
+		maxX = Math.max(maxX, n.bounds.x + n.bounds.width);
+		maxY = Math.max(maxY, n.bounds.y + n.bounds.height);
+	}
+	for (const g of groups) {
+		maxX = Math.max(maxX, g.bounds.x + g.bounds.width);
+		maxY = Math.max(maxY, g.bounds.y + g.bounds.height);
+	}
+	for (const path of edgePaths) for (const p of path.points) {
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.y);
+	}
+	for (const label of edgeLabels) {
+		maxX = Math.max(maxX, label.bounds.x + label.bounds.width);
+		maxY = Math.max(maxY, label.bounds.y + label.bounds.height);
+	}
+	return {
+		layout: {
+			nodes: laidOutNodes,
+			groups,
+			edgePaths,
+			edgeLabels,
+			direction,
+			algorithmVersion: ELK_LAYOUT_ALGORITHM,
+			layoutMs: performance.now() - t0,
+			width: Math.max(maxX, laid.width ?? 0) + 8,
+			height: Math.max(maxY, laid.height ?? 0) + 8
+		},
+		edges: edgePaths,
+		routerAlgorithm: ELK_ROUTER_ALGORITHM
+	};
+}
+//#endregion
+//#region src/layout-from-graph.ts
+const DEFAULT_LAYOUT = {
+	direction: "LR",
+	density: "normal",
+	spacingScale: 1.1,
+	algorithmVersion: "elk-layered-v1",
+	groupLayout: "compound",
+	nodePlacement: "balanced"
+};
+async function layoutFromGraph(graph, layoutOpts = {}) {
+	const opts = mergeOptions(DEFAULT_LAYOUT, layoutOpts);
+	return (await layoutAndRouteWithElk(graph, measureGraph(graph).nodes, opts)).layout;
+}
+//#endregion
+//#region src/measure/browser-font.ts
+/** Load bundled Inter via FontFace so canvas metrics match CLI opentype measurer. */
+let fontLoadPromise = null;
+let fontsReady = false;
+function browserFontsReady() {
+	return fontsReady;
+}
+function ensureBrowserFonts(fontUrl) {
+	if (typeof document === "undefined") return Promise.resolve();
+	if (fontsReady) return Promise.resolve();
+	if (fontLoadPromise) return fontLoadPromise;
+	fontLoadPromise = (async () => {
+		const face = new FontFace("Inter", `url(${fontUrl})`, {
+			weight: "500",
+			style: "normal"
+		});
+		await face.load();
+		document.fonts.add(face);
+		await document.fonts.load("500 14px \"Inter\"");
+		fontsReady = true;
+	})();
+	return fontLoadPromise;
+}
+//#endregion
+//#region src/layout/erd-snap.ts
+const OUTER_CLEARANCE = 18;
+/**
+* Snap ERD edge endpoints to column midlines while preserving orthogonal routes.
+* Runs after ELK; before crossing treatment / trim.
+*/
+function snapErdEdgeEndpoints(graph, layout, edgePaths) {
+	const nodeMap = new Map(layout.nodes.map((n) => [n.nodeId, n]));
+	const graphNodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	const obstacles = layout.nodes.map((n) => ({
+		nodeId: n.nodeId,
+		rect: n.bounds
+	}));
+	return edgePaths.map((path) => {
+		const edge = graph.edges.find((e) => e.id === path.edgeId);
+		if (!edge || !edge.fromColumn && !edge.toColumn) return path;
+		if (path.points.length < 2) return path;
+		const fromNode = graphNodes.get(edge.from);
+		const toNode = graphNodes.get(edge.to);
+		const fromLaid = nodeMap.get(edge.from);
+		const toLaid = nodeMap.get(edge.to);
+		if (!fromNode || !toNode || !fromLaid || !toLaid) return path;
+		let fromY;
+		let toY;
+		if (edge.fromColumn && isErdTableNode(fromNode)) {
+			const row = findColumnIndex(fromNode.columns, edge.fromColumn);
+			if (row >= 0) fromY = columnAnchorY(fromLaid.bounds.y, row, fromNode.scale ?? 1);
+		}
+		if (edge.toColumn && isErdTableNode(toNode)) {
+			const row = findColumnIndex(toNode.columns, edge.toColumn);
+			if (row >= 0) toY = columnAnchorY(toLaid.bounds.y, row, toNode.scale ?? 1);
+		}
+		if (fromY == null && toY == null) return path;
+		const sides = pickAttachmentSides(fromLaid.bounds, toLaid.bounds, path.points);
+		const start = pointOnSide(fromLaid.bounds, sides.fromSide, fromY ?? path.points[0].y);
+		const end = pointOnSide(toLaid.bounds, sides.toSide, toY ?? path.points[path.points.length - 1].y);
+		let points = rebuildOrthogonal(start, end, path.points, sides);
+		if (sides.fromSide === sides.toSide && pathCrossesObstacles(points, obstacles, edge.from, edge.to)) {
+			const flipped = sides.fromSide === "left" ? "right" : "left";
+			const altSides = {
+				fromSide: flipped,
+				toSide: flipped
+			};
+			const alt = rebuildOrthogonal(pointOnSide(fromLaid.bounds, flipped, start.y), pointOnSide(toLaid.bounds, flipped, end.y), path.points, altSides);
+			if (!pathCrossesObstacles(alt, obstacles, edge.from, edge.to)) points = alt;
+		}
+		return {
+			...path,
+			points
+		};
+	});
+}
+/** Choose left/right faces. Facing sides when horizontally separated; shared outer side when stacked. */
+function pickAttachmentSides(fromBounds, toBounds, original) {
+	const fromRight = fromBounds.x + fromBounds.width;
+	const toRight = toBounds.x + toBounds.width;
+	const gapToRight = toBounds.x - fromRight;
+	const gapToLeft = fromBounds.x - toRight;
+	if (gapToRight > 0) return {
+		fromSide: "right",
+		toSide: "left"
+	};
+	if (gapToLeft > 0) return {
+		fromSide: "left",
+		toSide: "right"
+	};
+	const fromMid = fromBounds.x + fromBounds.width / 2;
+	const hint = original[0];
+	const side = (hint ? hint.x <= fromMid : true) ? "left" : "right";
+	return {
+		fromSide: side,
+		toSide: side
+	};
+}
+function pointOnSide(bounds, side, y) {
+	return {
+		x: side === "left" ? bounds.x : bounds.x + bounds.width,
+		y
+	};
+}
+function rebuildOrthogonal(start, end, original, sides) {
+	if (Math.abs(start.y - end.y) < .5) return [start, end];
+	if (Math.abs(start.x - end.x) < .5) return [start, end];
+	if (sides.fromSide === sides.toSide) {
+		const midX = sides.fromSide === "left" ? Math.min(start.x, end.x) - OUTER_CLEARANCE : Math.max(start.x, end.x) + OUTER_CLEARANCE;
+		return [
+			start,
+			{
+				x: midX,
+				y: start.y
+			},
+			{
+				x: midX,
+				y: end.y
+			},
+			end
+		];
+	}
+	const lo = Math.min(start.x, end.x);
+	const hi = Math.max(start.x, end.x);
+	let midX = (start.x + end.x) / 2;
+	const interior = original.slice(1, -1);
+	if (interior.length) {
+		const xs = interior.map((p) => p.x).sort((a, b) => a - b);
+		const candidate = xs[Math.floor(xs.length / 2)];
+		if (candidate >= lo && candidate <= hi) midX = candidate;
+	}
+	return [
+		start,
+		{
+			x: midX,
+			y: start.y
+		},
+		{
+			x: midX,
+			y: end.y
+		},
+		end
+	];
+}
+function pathCrossesObstacles(points, obstacles, fromId, toId) {
+	const exclude = /* @__PURE__ */ new Set([fromId, toId]);
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		for (const { nodeId, rect } of obstacles) {
+			if (exclude.has(nodeId)) continue;
+			if (segmentHitsRectInterior(a, b, rect)) return true;
+		}
+	}
+	return false;
+}
+/** True when an orthogonal segment enters the open interior of a rect (not just grazing a face). */
+function segmentHitsRectInterior(from, to, rect) {
+	const left = rect.x;
+	const right = rect.x + rect.width;
+	const top = rect.y;
+	const bottom = rect.y + rect.height;
+	const eps = .75;
+	if (Math.abs(from.y - to.y) < eps) {
+		const y = from.y;
+		if (y <= top + eps || y >= bottom - eps) return false;
+		const x0 = Math.min(from.x, to.x);
+		const x1 = Math.max(from.x, to.x);
+		return x0 < right - eps && x1 > left + eps;
+	}
+	if (Math.abs(from.x - to.x) < eps) {
+		const x = from.x;
+		if (x <= left + eps || x >= right - eps) return false;
+		const y0 = Math.min(from.y, to.y);
+		const y1 = Math.max(from.y, to.y);
+		return y0 < bottom - eps && y1 > top + eps;
+	}
+	return false;
+}
+function erdRelationshipLabel(edge) {
+	if (edge.fromColumn && edge.toColumn) return `${edge.toColumn} → ${edge.fromColumn}`;
+	if (edge.toColumn) return edge.toColumn;
+	if (edge.fromColumn) return edge.fromColumn;
+	return edge.label;
+}
+//#endregion
+export { DEFAULT_FONT_FAMILY, ELK_LAYOUT_ALGORITHM, ELK_ROUTER_ALGORITHM, GROUP_ICON_GAP, GROUP_ICON_SIZE, SEQUENCE_LAYOUT_ALGORITHM, SEQUENCE_ROUTER_ALGORITHM, TABLE_ATTR_GAP, TABLE_BADGE_GAP, TABLE_BADGE_W, TABLE_HEADER_H, TABLE_KEY_COL, TABLE_PAD_X, TABLE_ROW_H, TABLE_RX, analyzeDiagramTopology, browserFontsReady, cardIconColumnWidth, columnAnchorY, columnNoteLabel, columnTypeLabel, computeGroupBounds, createCanvasMeasurer, defaultMeasurer, ensureBrowserFonts, erdRelationshipLabel, incomingCount, isChoiceBranch, isErdTableNode, isHorizontal, isSequenceGraph, isVertical, layoutAndRouteWithElk, layoutFromGraph, layoutSequence, measureGraph, measurerUsedApproximationFallback, outgoingCount, resetDefaultMeasurer, snapEdgeEndpointsToGeometry, snapErdEdgeEndpoints, tableKeyBadges };
+
+//# sourceMappingURL=index.mjs.map