@statelyai/layout 0.3.0 → 0.4.1

package/dist/{routing-A2hrK9MP.mjs → routing-CR8flv8b.mjs}

@@ -13,6 +13,489 @@ var UnsupportedLayoutError = class extends LayoutError {
 	}
 };
 
+//#endregion
+//#region src/authoring/coordinates.ts
+/** Legacy sibling edges are parent-relative; native compound output marks world-space edges. */
+function frames(graph) {
+	const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	const offsets = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	function offset(id) {
+		const cached = offsets.get(id);
+		if (cached) return cached;
+		if (visiting.has(id)) throw new LayoutError(`Cyclic parent hierarchy at ${id}`, "INVALID_GRAPH");
+		visiting.add(id);
+		const parentId = nodes.get(id)?.parentId;
+		if (parentId == null) {
+			const origin = {
+				x: 0,
+				y: 0
+			};
+			visiting.delete(id);
+			offsets.set(id, origin);
+			return origin;
+		}
+		const parent = nodes.get(parentId);
+		const ancestor = offset(parentId);
+		const result = {
+			x: ancestor.x + parent.x,
+			y: ancestor.y + parent.y
+		};
+		visiting.delete(id);
+		offsets.set(id, result);
+		return result;
+	}
+	for (const node$1 of graph.nodes) offsets.set(node$1.id, offset(node$1.id));
+	return {
+		nodes: offsets,
+		edges: new Map(graph.edges.map((edge) => {
+			const source = nodes.get(edge.sourceId);
+			const target = nodes.get(edge.targetId);
+			return [edge.id, graph.edgeCoordinateSpace !== "world" && (source.parentId ?? null) === (target.parentId ?? null) ? offset(source.id) : {
+				x: 0,
+				y: 0
+			}];
+		}))
+	};
+}
+function worldGeometry(graph) {
+	const offsets = frames(graph);
+	const base = { ...graph };
+	delete base.compoundRoutes;
+	delete base.compoundGeometry;
+	return {
+		...base,
+		nodes: graph.nodes.map((n) => {
+			const p = offsets.nodes.get(n.id);
+			return p.x === 0 && p.y === 0 ? n : {
+				...n,
+				x: n.x + p.x,
+				y: n.y + p.y
+			};
+		}),
+		edges: graph.edges.map((e) => {
+			const p = offsets.edges.get(e.id);
+			return p.x === 0 && p.y === 0 ? e : {
+				...e,
+				x: e.x + p.x,
+				y: e.y + p.y,
+				...e.points ? { points: e.points.map((v) => ({
+					x: v.x + p.x,
+					y: v.y + p.y
+				})) } : {}
+			};
+		})
+	};
+}
+/**
+* Convert solved world geometry back to parent-relative coordinates, using
+* each parent's solved position. Untouched coordinates stay exactly as authored.
+*/
+function nativeGeometry(graph, original) {
+	const offsets = frames(original);
+	const world = worldGeometry(original);
+	const originalNodes = new Map(original.nodes.map((n) => [n.id, n]));
+	const originalEdges = new Map(original.edges.map((e) => [e.id, e]));
+	const worldNodes = new Map(world.nodes.map((n) => [n.id, n]));
+	const worldEdges = new Map(world.edges.map((e) => [e.id, e]));
+	const solved = new Map(graph.nodes.map((n) => [n.id, n]));
+	const frame = (id) => {
+		const parentId = originalNodes.get(id)?.parentId;
+		const parent = parentId == null ? void 0 : solved.get(parentId);
+		return parent ? {
+			x: parent.x,
+			y: parent.y
+		} : {
+			x: 0,
+			y: 0
+		};
+	};
+	const same = (a, b) => a.x === b.x && a.y === b.y;
+	return {
+		...graph,
+		nodes: graph.nodes.map((n) => {
+			const p = frame(n.id), before = originalNodes.get(n.id), prior = worldNodes.get(n.id);
+			const kept = same(p, offsets.nodes.get(n.id));
+			return {
+				...n,
+				x: kept && n.x === prior.x ? before.x : n.x - p.x,
+				y: kept && n.y === prior.y ? before.y : n.y - p.y
+			};
+		}),
+		edges: graph.edges.map((e) => {
+			const old = offsets.edges.get(e.id), before = originalEdges.get(e.id), prior = worldEdges.get(e.id);
+			const source = originalNodes.get(e.sourceId), target = originalNodes.get(e.targetId);
+			const p = original.edgeCoordinateSpace !== "world" && (source.parentId ?? null) === (target.parentId ?? null) ? frame(source.id) : {
+				x: 0,
+				y: 0
+			};
+			const kept = same(p, old);
+			const points = kept && JSON.stringify(e.points) === JSON.stringify(prior.points) ? before.points : e.points?.map((v) => ({
+				x: v.x - p.x,
+				y: v.y - p.y
+			}));
+			return {
+				...e,
+				x: kept && e.x === prior.x ? before.x : e.x - p.x,
+				y: kept && e.y === prior.y ? before.y : e.y - p.y,
+				...points === void 0 ? {} : { points }
+			};
+		})
+	};
+}
+
+//#endregion
+//#region src/routing/layout-cache.ts
+const geometryByRoutes = /* @__PURE__ */ new WeakMap();
+/** Compare only geometry and topology; application data may contain cycles. */
+function geometryKey(graph) {
+	return JSON.stringify({
+		nodes: graph.nodes.map(({ id, parentId, x, y, width, height: height$1, ports }) => ({
+			id,
+			parentId,
+			x,
+			y,
+			width,
+			height: height$1,
+			ports: ports?.map(({ name, x: x$1, y: y$1, width: width$1, height: height$2 }) => ({
+				name,
+				x: x$1,
+				y: y$1,
+				width: width$1,
+				height: height$2
+			}))
+		})),
+		edges: graph.edges.map(({ id, sourceId, targetId, sourcePort, targetPort, x, y, width, height: height$1, points, routing }) => ({
+			id,
+			sourceId,
+			targetId,
+			sourcePort,
+			targetPort,
+			x,
+			y,
+			width,
+			height: height$1,
+			points,
+			routing
+		}))
+	});
+}
+/** Associate structured sections with the geometry that produced them. */
+function recordRouteGeometry(graph, routes) {
+	geometryByRoutes.set(routes, geometryKey(graph));
+}
+/** Graph edits invalidate cached sections, including edits made by external consumers. */
+function hasCurrentRouteGeometry(graph, routes) {
+	return geometryByRoutes.get(routes) === geometryKey(graph);
+}
+
+//#endregion
+//#region src/routing/persistent.ts
+const height = (n) => n?.height ?? 0;
+const size = (n) => n?.size ?? 0;
+function node(key, value, left, right) {
+	return {
+		key,
+		value,
+		left,
+		right,
+		height: 1 + Math.max(height(left), height(right)),
+		size: 1 + size(left) + size(right)
+	};
+}
+function balance(n) {
+	if (height(n.left) - height(n.right) > 1) {
+		let l = n.left;
+		if (height(l.right) > height(l.left)) {
+			const r = l.right;
+			l = node(r.key, r.value, node(l.key, l.value, l.left, r.left), r.right);
+		}
+		return node(l.key, l.value, l.left, node(n.key, n.value, l.right, n.right));
+	}
+	if (height(n.right) - height(n.left) > 1) {
+		let r = n.right;
+		if (height(r.left) > height(r.right)) {
+			const l = r.left;
+			r = node(l.key, l.value, l.left, node(r.key, r.value, l.right, r.right));
+		}
+		return node(r.key, r.value, node(n.key, n.value, n.left, r.left), r.right);
+	}
+	return n;
+}
+function put(n, key, value) {
+	if (!n) return node(key, value);
+	if (key === n.key) return Object.is(value, n.value) ? n : node(key, value, n.left, n.right);
+	return balance(key < n.key ? node(n.key, n.value, put(n.left, key, value), n.right) : node(n.key, n.value, n.left, put(n.right, key, value)));
+}
+function remove(n, key) {
+	if (!n) return n;
+	if (key < n.key) return balance(node(n.key, n.value, remove(n.left, key), n.right));
+	if (key > n.key) return balance(node(n.key, n.value, n.left, remove(n.right, key)));
+	if (!n.left) return n.right;
+	if (!n.right) return n.left;
+	let successor = n.right;
+	while (successor.left) successor = successor.left;
+	return balance(node(successor.key, successor.value, n.left, remove(n.right, successor.key)));
+}
+function* entries(n) {
+	if (!n) return;
+	yield* entries(n.left);
+	yield [n.key, n.value];
+	yield* entries(n.right);
+}
+var PersistentMap = class PersistentMap {
+	#root;
+	constructor(root) {
+		this.#root = root;
+		Object.freeze(this);
+	}
+	get size() {
+		return size(this.#root);
+	}
+	get [Symbol.toStringTag]() {
+		return "PersistentMap";
+	}
+	get(key) {
+		let n = this.#root;
+		while (n) {
+			if (key === n.key) return n.value;
+			n = key < n.key ? n.left : n.right;
+		}
+	}
+	has(key) {
+		let n = this.#root;
+		while (n) {
+			if (key === n.key) return true;
+			n = key < n.key ? n.left : n.right;
+		}
+		return false;
+	}
+	set(key, value) {
+		return new PersistentMap(put(this.#root, key, value));
+	}
+	delete(key) {
+		return this.has(key) ? new PersistentMap(remove(this.#root, key)) : this;
+	}
+	*entries() {
+		yield* entries(this.#root);
+	}
+	*keys() {
+		for (const [key] of this) yield key;
+	}
+	*values() {
+		for (const [, value] of this) yield value;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	forEach(callback, thisArg) {
+		for (const [key, value] of this) callback.call(thisArg, value, key, this);
+	}
+};
+
+//#endregion
+//#region src/routing/spatial.ts
+const intersects = (a, b) => a.x <= b.x + b.width && a.x + a.width >= b.x && a.y <= b.y + b.height && a.y + a.height >= b.y;
+const inflate = (r, amount) => ({
+	x: r.x - amount,
+	y: r.y - amount,
+	width: r.width + amount * 2,
+	height: r.height + amount * 2
+});
+function union(a, b) {
+	const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		width: Math.max(a.x + a.width, b.x + b.width) - x,
+		height: Math.max(a.y + a.height, b.y + b.height) - y
+	};
+}
+function cells(r) {
+	const x1 = Math.floor(r.x / 128), x2 = Math.floor((r.x + r.width) / 128), y1 = Math.floor(r.y / 128), y2 = Math.floor((r.y + r.height) / 128);
+	if ((x2 - x1 + 1) * (y2 - y1 + 1) > 4096) return void 0;
+	const result = [];
+	for (let x = 0; x <= x2 - x1; x++) for (let y = 0; y <= y2 - y1; y++) result.push(`${x1 + x}:${y1 + y}`);
+	return result;
+}
+/** Persistent uniform-grid broad phase; oversized rectangles live in an overflow index. */
+var SpatialIndex = class SpatialIndex {
+	constructor(bounds = new PersistentMap(), buckets = new PersistentMap(), overflow = new PersistentMap()) {
+		this.bounds = bounds;
+		this.buckets = buckets;
+		this.overflow = overflow;
+		Object.freeze(this);
+	}
+	set(id, rect$1) {
+		let { bounds, buckets, overflow } = this;
+		const previous = bounds.get(id);
+		if (previous) {
+			const keys = cells(previous);
+			if (!keys) overflow = overflow.delete(id);
+			else for (const key of keys) {
+				const bucket = buckets.get(key).delete(id);
+				buckets = bucket.size ? buckets.set(key, bucket) : buckets.delete(key);
+			}
+			bounds = bounds.delete(id);
+		}
+		if (rect$1) {
+			const keys = cells(rect$1);
+			if (!keys) overflow = overflow.set(id, true);
+			else for (const key of keys) buckets = buckets.set(key, (buckets.get(key) ?? new PersistentMap()).set(id, true));
+			bounds = bounds.set(id, rect$1);
+		}
+		return new SpatialIndex(bounds, buckets, overflow);
+	}
+	query(rect$1) {
+		const keys = cells(rect$1), found = /* @__PURE__ */ new Set();
+		if (!keys) {
+			for (const [id, bounds] of this.bounds) if (intersects(rect$1, bounds)) found.add(id);
+		} else {
+			for (const key of keys) for (const id of this.buckets.get(key)?.keys() ?? []) if (intersects(rect$1, this.bounds.get(id))) found.add(id);
+			for (const id of this.overflow.keys()) if (intersects(rect$1, this.bounds.get(id))) found.add(id);
+		}
+		return [...found].sort();
+	}
+};
+
+//#endregion
+//#region src/routing/model.ts
+function settings(input = {}) {
+	const result = {
+		coordinateSpace: input.coordinateSpace ?? "parent",
+		clearance: input.clearance ?? 8,
+		radius: input.radius ?? 10,
+		edgeSpacing: input.edgeSpacing ?? 12,
+		bendPenalty: input.bendPenalty ?? 10,
+		crossingPenalty: input.crossingPenalty ?? 80,
+		overlapPenalty: input.overlapPenalty ?? 8,
+		maxSearchNodes: input.maxSearchNodes ?? 4e3,
+		organicIterations: input.organicIterations ?? 12,
+		edges: structuredClone(input.edges ?? {})
+	};
+	for (const [key, value] of Object.entries(result)) if (typeof value === "number" && (!Number.isFinite(value) || value < 0)) throw new RangeError(`${key} must be finite and non-negative`);
+	if (!Number.isInteger(result.maxSearchNodes) || result.maxSearchNodes < 1 || !Number.isInteger(result.organicIterations)) throw new RangeError("Search and iteration budgets must be integers");
+	return freeze(result);
+}
+function freeze(value) {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const child of Object.values(value)) freeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function nodeGeometry(n) {
+	return freeze({
+		id: n.id,
+		parentId: n.parentId,
+		x: n.x,
+		y: n.y,
+		width: n.width,
+		height: n.height,
+		ports: n.ports?.map((p) => ({
+			name: p.name,
+			x: p.x,
+			y: p.y,
+			width: p.width,
+			height: p.height
+		}))
+	});
+}
+function edgeGeometry(e) {
+	return freeze({
+		id: e.id,
+		sourceId: e.sourceId ?? "",
+		targetId: e.targetId ?? "",
+		sourcePort: e.sourcePort,
+		targetPort: e.targetPort,
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height
+	});
+}
+function rect(value) {
+	const { x, y, width, height: height$1 } = value;
+	return [
+		x,
+		y,
+		width,
+		height$1
+	].every((n) => typeof n === "number" && Number.isFinite(n)) && width >= 0 && height$1 >= 0 ? {
+		x,
+		y,
+		width,
+		height: height$1
+	} : void 0;
+}
+function members(index, key, id, add) {
+	const current = index.get(key) ?? new PersistentMap(), next = add ? current.set(id, true) : current.delete(id);
+	return next.size ? index.set(key, next) : index.delete(key);
+}
+function ancestors(id, state) {
+	const result = [], seen = new Set([id]);
+	let parent = state.nodes.get(id)?.parentId;
+	while (parent != null) {
+		if (seen.has(parent)) throw new Error(`Cyclic routing hierarchy at ${parent}`);
+		result.push(parent);
+		seen.add(parent);
+		parent = state.nodes.get(parent)?.parentId;
+	}
+	return result;
+}
+function worldRect(node$1, state) {
+	const bounds = rect(node$1);
+	if (!bounds) return;
+	if (state.settings.coordinateSpace === "world") return bounds;
+	let x = bounds.x, y = bounds.y;
+	for (const id of ancestors(node$1.id, state)) {
+		const parent = state.nodes.get(id), p = parent && rect(parent);
+		if (!p) return;
+		x += p.x;
+		y += p.y;
+	}
+	return {
+		...bounds,
+		x,
+		y
+	};
+}
+function labelRect(edge, state) {
+	const bounds = rect(edge);
+	if (!bounds || bounds.width <= 0 || bounds.height <= 0) return;
+	const source = state.nodes.get(edge.sourceId), target = state.nodes.get(edge.targetId);
+	if (state.settings.coordinateSpace === "world" || !source || source.parentId == null || source.parentId !== target?.parentId) return bounds;
+	const parent = state.nodes.get(source.parentId), p = parent && worldRect(parent, state);
+	return p ? {
+		...bounds,
+		x: bounds.x + p.x,
+		y: bounds.y + p.y
+	} : void 0;
+}
+const center = (r) => ({
+	x: r.x + r.width / 2,
+	y: r.y + r.height / 2
+});
+function sideToward(a, b) {
+	return Math.abs(a.x - b.x) >= Math.abs(a.y - b.y) ? b.x >= a.x ? "right" : "left" : b.y >= a.y ? "bottom" : "top";
+}
+const vector = (side) => ({
+	x: side === "right" ? 1 : side === "left" ? -1 : 0,
+	y: side === "bottom" ? 1 : side === "top" ? -1 : 0
+});
+function anchor(bounds, side) {
+	const c = center(bounds), v = vector(side);
+	return {
+		x: c.x + v.x * bounds.width / 2,
+		y: c.y + v.y * bounds.height / 2
+	};
+}
+function groupKey(edge, style, config) {
+	const group = config.edges[edge.id]?.group;
+	if (style === "bus" || style === "bundle" || style === "fan") return group !== void 0 ? `group:${group}` : `source:${JSON.stringify([edge.sourceId, edge.sourcePort ?? null])}`;
+	return `pair:${JSON.stringify([edge.sourceId, edge.targetId].sort())}`;
+}
+
 //#endregion
 //#region src/authoring/routing.ts
 function overlaps(a, b, gap = 0) {
@@ -25,7 +508,7 @@ function crossesRect(a, b, rect$1) {
 		const delta = b[axis] - a[axis];
 		const min = rect$1[axis], max = min + (axis === "x" ? rect$1.width : rect$1.height);
 		if (Math.abs(delta) < 1e-10) {
-			if (a[axis] <= min || a[axis] >= max) return false;
+			if (a[axis] <= min + 1e-10 || a[axis] >= max - 1e-10) return false;
 		} else {
 			const t1 = (min - a[axis]) / delta, t2 = (max - a[axis]) / delta;
 			low = Math.max(low, Math.min(t1, t2));
@@ -483,173 +966,138 @@ function segmentCrossesRect(start, segment, rect$1) {
 }
 
 //#endregion
-//#region src/routing/persistent.ts
-const height = (n) => n?.height ?? 0;
-const size = (n) => n?.size ?? 0;
-function node(key, value, left, right) {
-	return {
-		key,
-		value,
-		left,
-		right,
-		height: 1 + Math.max(height(left), height(right)),
-		size: 1 + size(left) + size(right)
-	};
-}
-function balance(n) {
-	if (height(n.left) - height(n.right) > 1) {
-		let l = n.left;
-		if (height(l.right) > height(l.left)) {
-			const r = l.right;
-			l = node(r.key, r.value, node(l.key, l.value, l.left, r.left), r.right);
-		}
-		return node(l.key, l.value, l.left, node(n.key, n.value, l.right, n.right));
-	}
-	if (height(n.right) - height(n.left) > 1) {
-		let r = n.right;
-		if (height(r.left) > height(r.right)) {
-			const l = r.left;
-			r = node(l.key, l.value, l.left, node(r.key, r.value, l.right, r.right));
-		}
-		return node(r.key, r.value, node(n.key, n.value, n.left, r.left), r.right);
-	}
-	return n;
-}
-function put(n, key, value) {
-	if (!n) return node(key, value);
-	if (key === n.key) return Object.is(value, n.value) ? n : node(key, value, n.left, n.right);
-	return balance(key < n.key ? node(n.key, n.value, put(n.left, key, value), n.right) : node(n.key, n.value, n.left, put(n.right, key, value)));
-}
-function remove(n, key) {
-	if (!n) return n;
-	if (key < n.key) return balance(node(n.key, n.value, remove(n.left, key), n.right));
-	if (key > n.key) return balance(node(n.key, n.value, n.left, remove(n.right, key)));
-	if (!n.left) return n.right;
-	if (!n.right) return n.left;
-	let successor = n.right;
-	while (successor.left) successor = successor.left;
-	return balance(node(successor.key, successor.value, n.left, remove(n.right, successor.key)));
-}
-function* entries(n) {
-	if (!n) return;
-	yield* entries(n.left);
-	yield [n.key, n.value];
-	yield* entries(n.right);
-}
-var PersistentMap = class PersistentMap {
-	#root;
-	constructor(root) {
-		this.#root = root;
-		Object.freeze(this);
-	}
-	get size() {
-		return size(this.#root);
-	}
-	get [Symbol.toStringTag]() {
-		return "PersistentMap";
-	}
-	get(key) {
-		let n = this.#root;
-		while (n) {
-			if (key === n.key) return n.value;
-			n = key < n.key ? n.left : n.right;
-		}
-	}
-	has(key) {
-		let n = this.#root;
-		while (n) {
-			if (key === n.key) return true;
-			n = key < n.key ? n.left : n.right;
-		}
-		return false;
-	}
-	set(key, value) {
-		return new PersistentMap(put(this.#root, key, value));
-	}
-	delete(key) {
-		return this.has(key) ? new PersistentMap(remove(this.#root, key)) : this;
-	}
-	*entries() {
-		yield* entries(this.#root);
-	}
-	*keys() {
-		for (const [key] of this) yield key;
-	}
-	*values() {
-		for (const [, value] of this) yield value;
-	}
-	[Symbol.iterator]() {
-		return this.entries();
-	}
-	forEach(callback, thisArg) {
-		for (const [key, value] of this) callback.call(thisArg, value, key, this);
-	}
-};
-
-//#endregion
-//#region src/routing/spatial.ts
-const intersects = (a, b) => a.x <= b.x + b.width && a.x + a.width >= b.x && a.y <= b.y + b.height && a.y + a.height >= b.y;
-const inflate = (r, amount) => ({
-	x: r.x - amount,
-	y: r.y - amount,
-	width: r.width + amount * 2,
-	height: r.height + amount * 2
-});
-function union(a, b) {
-	const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+//#region src/routing/adapters.ts
+/** ELK/native spline output: start, then repeating control1/control2/end triples. */
+function pathFromSplinePoints(points) {
+	if (points.length < 4 || (points.length - 1) % 3 !== 0) throw new RangeError("Cubic spline points require a start and control1/control2/end triples");
+	const segments = [];
+	for (let i = 1; i < points.length; i += 3) segments.push({
+		kind: "cubic",
+		control1: { ...points[i] },
+		control2: { ...points[i + 1] },
+		to: { ...points[i + 2] }
+	});
 	return {
-		x,
-		y,
-		width: Math.max(a.x + a.width, b.x + b.width) - x,
-		height: Math.max(a.y + a.height, b.y + b.height) - y
+		start: { ...points[0] },
+		segments
 	};
 }
-function cells(r) {
-	const x1 = Math.floor(r.x / 128), x2 = Math.floor((r.x + r.width) / 128), y1 = Math.floor(r.y / 128), y2 = Math.floor((r.y + r.height) / 128);
-	if ((x2 - x1 + 1) * (y2 - y1 + 1) > 4096) return void 0;
-	const result = [];
-	for (let x = 0; x <= x2 - x1; x++) for (let y = 0; y <= y2 - y1; y++) result.push(`${x1 + x}:${y1 + y}`);
-	return result;
-}
-/** Persistent uniform-grid broad phase; oversized rectangles live in an overflow index. */
-var SpatialIndex = class SpatialIndex {
-	constructor(bounds = new PersistentMap(), buckets = new PersistentMap(), overflow = new PersistentMap()) {
-		this.bounds = bounds;
-		this.buckets = buckets;
-		this.overflow = overflow;
-		Object.freeze(this);
-	}
-	set(id, rect$1) {
-		let { bounds, buckets, overflow } = this;
-		const previous = bounds.get(id);
-		if (previous) {
-			const keys = cells(previous);
-			if (!keys) overflow = overflow.delete(id);
-			else for (const key of keys) {
-				const bucket = buckets.get(key).delete(id);
-				buckets = bucket.size ? buckets.set(key, bucket) : buckets.delete(key);
-			}
-			bounds = bounds.delete(id);
-		}
-		if (rect$1) {
-			const keys = cells(rect$1);
-			if (!keys) overflow = overflow.set(id, true);
-			else for (const key of keys) buckets = buckets.set(key, (buckets.get(key) ?? new PersistentMap()).set(id, true));
-			bounds = bounds.set(id, rect$1);
+/** Normalize routes from any native layout algorithm, without running layout again. */
+function getLayoutRoutes(graph) {
+	const compound = graph;
+	if (compound.compoundRoutes?.size && hasCurrentRouteGeometry(graph, compound.compoundRoutes)) return compound.compoundRoutes;
+	const world = worldGeometry(graph), nodes = new Map(world.nodes.map((n) => [n.id, n]));
+	let result = new PersistentMap();
+	for (const edge of world.edges) {
+		const points = edge.points;
+		let path;
+		if (points?.length && points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) if (edge.routing === "splines") {
+			if (points.length >= 4 && (points.length - 1) % 3 === 0) path = pathFromSplinePoints(points);
+		} else path = pathFromPoints(points);
+		const routed = path !== void 0;
+		if (!path) {
+			const a = nodes.get(edge.sourceId), b = nodes.get(edge.targetId);
+			path = pathFromPoints([{
+				x: a ? a.x + a.width : 0,
+				y: a ? a.y + a.height / 2 : 0
+			}, {
+				x: b?.x ?? 40,
+				y: b ? b.y + b.height / 2 : 40
+			}]);
 		}
-		return new SpatialIndex(bounds, buckets, overflow);
+		result = result.set(edge.id, freeze({
+			edgeId: edge.id,
+			status: routed ? "routed" : "fallback",
+			diagnostics: routed ? [] : [{
+				code: "MISSING_GEOMETRY",
+				edgeId: edge.id,
+				message: "Layout has no valid route; rendered a fallback connection"
+			}],
+			sections: [{
+				id: `${edge.id}:0`,
+				from: {
+					kind: "node",
+					nodeId: edge.sourceId,
+					...edge.sourcePort === void 0 ? {} : { port: edge.sourcePort }
+				},
+				to: {
+					kind: "node",
+					nodeId: edge.targetId,
+					...edge.targetPort === void 0 ? {} : { port: edge.targetPort }
+				},
+				path
+			}]
+		}));
 	}
-	query(rect$1) {
-		const keys = cells(rect$1), found = /* @__PURE__ */ new Set();
-		if (!keys) {
-			for (const [id, bounds] of this.bounds) if (intersects(rect$1, bounds)) found.add(id);
-		} else {
-			for (const key of keys) for (const id of this.buckets.get(key)?.keys() ?? []) if (intersects(rect$1, this.bounds.get(id))) found.add(id);
-			for (const id of this.overflow.keys()) if (intersects(rect$1, this.bounds.get(id))) found.add(id);
+	return result;
+}
+/** One polyline per section preserves label gaps and branching for simple renderers. */
+function routeToPolylines(route, options) {
+	return route.sections.map((s) => flattenPath(s.path, options));
+}
+/**
+* One point list for consumers of `GraphEdge.points`. Sections are joined
+* through their gaps (an edge label, for example); between orthogonal
+* sections the join is orthogonal too, so it never adds a diagonal.
+*/
+function routeToPoints(route, options) {
+	const points = [];
+	const axis = (a, b) => Math.abs(a.y - b.y) < 1e-9 ? "horizontal" : Math.abs(a.x - b.x) < 1e-9 ? "vertical" : void 0;
+	for (const polyline of routeToPolylines(route, options)) {
+		const a = points.at(-1), b = polyline[0];
+		if (a && b && axis(a, b) === void 0) {
+			const before = points.length > 1 ? axis(points.at(-2), a) : void 0;
+			const after = polyline.length > 1 ? axis(b, polyline[1]) : void 0;
+			if (before && after) if (before === "horizontal" && after === "horizontal") {
+				const x = (a.x + b.x) / 2;
+				points.push({
+					x,
+					y: a.y
+				}, {
+					x,
+					y: b.y
+				});
+			} else if (before === "vertical" && after === "vertical") {
+				const y = (a.y + b.y) / 2;
+				points.push({
+					x: a.x,
+					y
+				}, {
+					x: b.x,
+					y
+				});
+			} else points.push(before === "horizontal" ? {
+				x: b.x,
+				y: a.y
+			} : {
+				x: a.x,
+				y: b.y
+			});
 		}
-		return [...found].sort();
+		points.push(...polyline.map((point) => ({ ...point })));
 	}
-};
+	return points;
+}
+/** Compatibility for single-section native consumers. Refuses to erase gaps or topology. */
+function routeToGraphPatch(route, options = {}) {
+	if (route.sections.length !== 1 || route.sections[0].sharedId || route.sections[0].from.kind !== "node" || route.sections[0].to.kind !== "node") throw new Error("This route requires section-aware rendering; a single GraphEdge.points array would lose topology");
+	const offset = options.offset ?? {
+		x: 0,
+		y: 0
+	};
+	const points = flattenPath(route.sections[0].path, options).map((p) => ({
+		x: p.x - offset.x,
+		y: p.y - offset.y
+	}));
+	return {
+		op: "updateEdge",
+		id: route.edgeId,
+		data: {
+			points,
+			routing: "polyline"
+		}
+	};
+}
 
 //#endregion
 //#region src/routing/search.ts
@@ -710,6 +1158,11 @@ var Queue = class {
 };
 /** Visibility graph + A*, with incoming direction in the state for bend costs. */
 function findPath(start, end, style, context, terminals = {}) {
+	const maxGridNodes = context.maxGridNodes ?? context.maxSearchNodes;
+	const remainingDistance = (point) => {
+		const dx = Math.abs(point.x - end.x), dy = Math.abs(point.y - end.y);
+		return style === "orthogonal" ? dx + dy : style === "octilinear" ? Math.max(dx, dy) + (Math.SQRT2 - 1) * Math.min(dx, dy) : distance(point, end);
+	};
 	const turnCost = (a, b) => {
 		if (!a || !b || !Math.hypot(a.x, a.y) || !Math.hypot(b.x, b.y)) return 0;
 		const dot = a.x * b.x + a.y * b.y, cross = a.x * b.y - a.y * b.x;
@@ -767,21 +1220,31 @@ function findPath(start, end, style, context, terminals = {}) {
 			];
 			neighbors = () => points.map((_, i) => i);
 		} else {
-			const xs = [...new Set([
+			const coordinates = (values) => {
+				const endpoints = values.slice(0, 2);
+				const sorted = [...values].sort((a, b) => a - b);
+				const unique = [];
+				for (const value of sorted) {
+					if (unique.length && Math.abs(value - unique.at(-1)) < 1e-8) continue;
+					unique.push(value);
+				}
+				return unique.map((value) => endpoints.find((p) => Math.abs(p - value) < 1e-8) ?? value);
+			};
+			const xs = coordinates([
 				start.x,
 				end.x,
 				area.x,
 				area.x + area.width,
 				...corners.map((p) => p.x)
-			])].sort((a, b) => a - b);
-			const ys = [...new Set([
+			]);
+			const ys = coordinates([
 				start.y,
 				end.y,
 				area.y,
 				area.y + area.height,
 				...corners.map((p) => p.y)
-			])].sort((a, b) => a - b);
-			if (xs.length * ys.length > context.maxSearchNodes) {
+			]);
+			if (xs.length * ys.length > maxGridNodes) {
 				context.budgetExceeded = true;
 				return;
 			}
@@ -817,7 +1280,7 @@ function findPath(start, end, style, context, terminals = {}) {
 				const unique = new Map(points.map((p) => [`${p.x}:${p.y}`, p]));
 				for (const p of extra) unique.set(`${p.x}:${p.y}`, p);
 				points = [...unique.values()];
-				if (points.length > context.maxSearchNodes) {
+				if (points.length > maxGridNodes) {
 					context.budgetExceeded = true;
 					return;
 				}
@@ -851,7 +1314,7 @@ function findPath(start, end, style, context, terminals = {}) {
 				i + width < points.length ? i + width : -1
 			].filter((v) => v >= 0);
 		}
-		if (points.length > context.maxSearchNodes) {
+		if (points.length > maxGridNodes) {
 			context.budgetExceeded = true;
 			return;
 		}
@@ -875,7 +1338,7 @@ function findPath(start, end, style, context, terminals = {}) {
 			previous: -1,
 			key: first,
 			cost: 0
-		}, distance(start, end));
+		}, remainingDistance(start));
 		while (queue.items.length && context.visited < context.maxSearchNodes) {
 			const current = queue.pop();
 			if (costs.get(current.key) !== current.cost) continue;
@@ -896,6 +1359,8 @@ function findPath(start, end, style, context, terminals = {}) {
 				if (!visible(current.index, next)) continue;
 				const before = current.previous < 0 ? terminals.incoming : delta(points[current.previous], a);
 				const step = delta(a, b);
+				const reverses = (incoming, outgoing) => incoming && outgoing && Math.abs(incoming.x * outgoing.y - incoming.y * outgoing.x) < 1e-8 && incoming.x * outgoing.x + incoming.y * outgoing.y < -1e-8;
+				if (reverses(before, step) || next === to && reverses(step, terminals.outgoing)) continue;
 				const bend = turnCost(before, step) + (next === to ? turnCost(step, terminals.outgoing) : 0);
 				const pair = Math.min(current.index, next) * points.length + Math.max(current.index, next);
 				let edgeCost = edgeCosts.get(pair);
@@ -914,12 +1379,33 @@ function findPath(start, end, style, context, terminals = {}) {
 					previous: current.index,
 					key,
 					cost
-				}, cost + distance(b, end));
+				}, cost + remainingDistance(b));
 			}
 		}
 	}
 	if (context.visited >= context.maxSearchNodes) context.budgetExceeded = true;
 }
+const findPathBetweenLeads = (start, end, style, ctx, leads, directions = {}) => {
+	const protectedContext = {
+		...ctx,
+		edgeCost: (p, q) => {
+			for (const [from, to] of leads) {
+				const dx = q.x - p.x, dy = q.y - p.y;
+				const length = Math.hypot(dx, dy);
+				if (length < 1e-8) continue;
+				if (Math.abs(dx * (to.y - from.y) - dy * (to.x - from.x)) > 1e-8 * length || Math.abs(dx * (from.y - p.y) - dy * (from.x - p.x)) > 1e-8 * length) continue;
+				const lo = ((from.x - p.x) * dx + (from.y - p.y) * dy) / length;
+				const hi = ((to.x - p.x) * dx + (to.y - p.y) * dy) / length;
+				if (Math.min(length, Math.max(lo, hi)) - Math.max(0, Math.min(lo, hi)) > 1e-8) return Infinity;
+			}
+			return ctx.edgeCost?.(p, q) ?? 0;
+		}
+	};
+	const result = findPath(start, end, style, protectedContext, directions);
+	ctx.visited = protectedContext.visited;
+	ctx.budgetExceeded = protectedContext.budgetExceeded;
+	return result;
+};
 
 //#endregion
 //#region src/routing/coordination.ts
@@ -962,7 +1448,7 @@ function conflictCost(a, b, other, config) {
 	return config.overlapPenalty * overlap * (1 - separation / spacing);
 }
 /** Remove only the common terminal's attachment region from soft reservations. */
-function outsideTerminal(segment, rect$1) {
+function outsideTerminal(segment, rect$1, closed = true) {
 	let lo = 0, hi = 1;
 	const dx = segment.b.x - segment.a.x, dy = segment.b.y - segment.a.y;
 	for (const [start, delta, min, max] of [[
@@ -976,13 +1462,13 @@ function outsideTerminal(segment, rect$1) {
 		rect$1.y,
 		rect$1.y + rect$1.height
 	]]) if (Math.abs(delta) < 1e-8) {
-		if (start < min || start > max) return [segment];
+		if (closed ? start < min || start > max : start <= min + 1e-8 || start >= max - 1e-8) return [segment];
 	} else {
 		const a = (min - start) / delta, b = (max - start) / delta;
 		lo = Math.max(lo, Math.min(a, b));
 		hi = Math.min(hi, Math.max(a, b));
 	}
-	if (lo > hi) return [segment];
+	if (closed ? lo > hi : lo >= hi) return [segment];
 	const at = (t) => ({
 		x: segment.a.x + dx * t,
 		y: segment.a.y + dy * t
@@ -996,151 +1482,14 @@ function outsideTerminal(segment, rect$1) {
 	}] : []];
 }
 
-//#endregion
-//#region src/routing/model.ts
-function settings(input = {}) {
-	const result = {
-		coordinateSpace: input.coordinateSpace ?? "parent",
-		clearance: input.clearance ?? 8,
-		radius: input.radius ?? 10,
-		edgeSpacing: input.edgeSpacing ?? 12,
-		bendPenalty: input.bendPenalty ?? 10,
-		crossingPenalty: input.crossingPenalty ?? 80,
-		overlapPenalty: input.overlapPenalty ?? 8,
-		maxSearchNodes: input.maxSearchNodes ?? 4e3,
-		organicIterations: input.organicIterations ?? 12,
-		edges: structuredClone(input.edges ?? {})
-	};
-	for (const [key, value] of Object.entries(result)) if (typeof value === "number" && (!Number.isFinite(value) || value < 0)) throw new RangeError(`${key} must be finite and non-negative`);
-	if (!Number.isInteger(result.maxSearchNodes) || result.maxSearchNodes < 1 || !Number.isInteger(result.organicIterations)) throw new RangeError("Search and iteration budgets must be integers");
-	return freeze(result);
-}
-function freeze(value) {
-	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-		for (const child of Object.values(value)) freeze(child);
-		Object.freeze(value);
-	}
-	return value;
-}
-function nodeGeometry(n) {
-	return freeze({
-		id: n.id,
-		parentId: n.parentId,
-		x: n.x,
-		y: n.y,
-		width: n.width,
-		height: n.height,
-		ports: n.ports?.map((p) => ({
-			name: p.name,
-			x: p.x,
-			y: p.y,
-			width: p.width,
-			height: p.height
-		}))
-	});
-}
-function edgeGeometry(e) {
-	return freeze({
-		id: e.id,
-		sourceId: e.sourceId ?? "",
-		targetId: e.targetId ?? "",
-		sourcePort: e.sourcePort,
-		targetPort: e.targetPort,
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
-	});
-}
-function rect(value) {
-	const { x, y, width, height: height$1 } = value;
-	return [
-		x,
-		y,
-		width,
-		height$1
-	].every((n) => typeof n === "number" && Number.isFinite(n)) && width >= 0 && height$1 >= 0 ? {
-		x,
-		y,
-		width,
-		height: height$1
-	} : void 0;
-}
-function members(index, key, id, add) {
-	const current = index.get(key) ?? new PersistentMap(), next = add ? current.set(id, true) : current.delete(id);
-	return next.size ? index.set(key, next) : index.delete(key);
-}
-function ancestors(id, state) {
-	const result = [], seen = new Set([id]);
-	let parent = state.nodes.get(id)?.parentId;
-	while (parent != null) {
-		if (seen.has(parent)) throw new Error(`Cyclic routing hierarchy at ${parent}`);
-		result.push(parent);
-		seen.add(parent);
-		parent = state.nodes.get(parent)?.parentId;
-	}
-	return result;
-}
-function worldRect(node$1, state) {
-	const bounds = rect(node$1);
-	if (!bounds) return;
-	if (state.settings.coordinateSpace === "world") return bounds;
-	let x = bounds.x, y = bounds.y;
-	for (const id of ancestors(node$1.id, state)) {
-		const parent = state.nodes.get(id), p = parent && rect(parent);
-		if (!p) return;
-		x += p.x;
-		y += p.y;
-	}
-	return {
-		...bounds,
-		x,
-		y
-	};
-}
-function labelRect(edge, state) {
-	const bounds = rect(edge);
-	if (!bounds || bounds.width <= 0 || bounds.height <= 0) return;
-	const source = state.nodes.get(edge.sourceId), target = state.nodes.get(edge.targetId);
-	if (state.settings.coordinateSpace === "world" || !source || source.parentId == null || source.parentId !== target?.parentId) return bounds;
-	const parent = state.nodes.get(source.parentId), p = parent && worldRect(parent, state);
-	return p ? {
-		...bounds,
-		x: bounds.x + p.x,
-		y: bounds.y + p.y
-	} : void 0;
-}
-const center = (r) => ({
-	x: r.x + r.width / 2,
-	y: r.y + r.height / 2
-});
-function sideToward(a, b) {
-	return Math.abs(a.x - b.x) >= Math.abs(a.y - b.y) ? b.x >= a.x ? "right" : "left" : b.y >= a.y ? "bottom" : "top";
-}
-const vector = (side) => ({
-	x: side === "right" ? 1 : side === "left" ? -1 : 0,
-	y: side === "bottom" ? 1 : side === "top" ? -1 : 0
-});
-function anchor(bounds, side) {
-	const c = center(bounds), v = vector(side);
-	return {
-		x: c.x + v.x * bounds.width / 2,
-		y: c.y + v.y * bounds.height / 2
-	};
-}
-function groupKey(edge, style, config) {
-	const group = config.edges[edge.id]?.group;
-	if (style === "bus" || style === "bundle" || style === "fan") return group !== void 0 ? `group:${group}` : `source:${JSON.stringify([edge.sourceId, edge.sourcePort ?? null])}`;
-	return `pair:${JSON.stringify([edge.sourceId, edge.targetId].sort())}`;
-}
-
 //#endregion
 //#region src/routing/algorithms.ts
 function contextFor(state, excluded, endpoints, metrics$1, batch, padding = 0) {
 	return {
 		edgeCost: (a, b) => batch.edgeCost?.(a, b) ?? 0,
 		guides: (bounds) => batch.guides?.(bounds) ?? [],
-		maxSearchNodes: state.settings.maxSearchNodes,
+		maxSearchNodes: Math.max(1, Math.floor(state.settings.maxSearchNodes / 2)),
+		maxGridNodes: state.settings.maxSearchNodes,
 		bendPenalty: state.settings.bendPenalty,
 		visited: 0,
 		budgetExceeded: false,
@@ -1157,7 +1506,17 @@ function pathLength(path) {
 	return pathReservations(path).reduce((sum, segment) => sum + distance(segment.a, segment.b), 0);
 }
 function pathCost(path, context) {
-	return pathReservations(path).reduce((sum, segment) => sum + distance(segment.a, segment.b) + (context.edgeCost?.(segment.a, segment.b) ?? 0), 0);
+	const segments = pathReservations(path);
+	const lengthAndConflicts = segments.reduce((sum, segment) => sum + distance(segment.a, segment.b) + (context.edgeCost?.(segment.a, segment.b) ?? 0), 0);
+	if (path.segments.some((segment) => segment.kind !== "line")) return lengthAndConflicts;
+	let turns = 0;
+	for (let i = 1; i < segments.length; i++) {
+		const a = segments[i - 1], b = segments[i];
+		const ax = a.b.x - a.a.x, ay = a.b.y - a.a.y;
+		const bx = b.b.x - b.a.x, by = b.b.y - b.a.y;
+		turns += ax * bx + ay * by < -1e-8 ? 4 : Math.abs(ax * by - ay * bx) > 1e-8 ? 1 : 0;
+	}
+	return lengthAndConflicts + context.bendPenalty * turns;
 }
 function safe(path, context) {
 	let start = path.start;
@@ -1426,6 +1785,38 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 				if (!(source$1 ? perEdge.sourceSide : perEdge.targetSide)) side = sideToward(center(outer), point);
 			} else report("MISSING_PORT", `Port ${name} has no positioned geometry; used the node boundary`);
 		}
+		if (attachment && name === void 0 && !(source$1 ? perEdge.sourceSide : perEdge.targetSide)) {
+			const excludedParents = new Set([...ancestors(edge.sourceId, state), ...ancestors(edge.targetId, state)].filter((id) => id !== edge.sourceId && id !== edge.targetId));
+			const blocked = (p, s) => {
+				const sign = attachment.facing === "inward" ? -1 : 1, v = vector(s);
+				const lead = {
+					x: p.x + v.x * sign,
+					y: p.y + v.y * sign
+				};
+				return state.obstacles.query(segmentBounds(p, lead)).some((id) => {
+					if (id === `n:${source$1 ? edge.sourceId : edge.targetId}` || id.startsWith("n:") && excludedParents.has(id.slice(2))) return false;
+					return crossesRect(p, lead, state.obstacles.bounds.get(id));
+				});
+			};
+			if (blocked(point, side)) {
+				const toward = center(labelRect(edge, state) ?? other);
+				for (const alternative of [
+					"left",
+					"right",
+					"top",
+					"bottom"
+				]) {
+					const p = { ...anchor(bounds, alternative) };
+					if (alternative === "left" || alternative === "right") p.y = Math.max(bounds.y, Math.min(bounds.y + bounds.height, toward.y));
+					else p.x = Math.max(bounds.x, Math.min(bounds.x + bounds.width, toward.x));
+					if (!blocked(p, alternative)) {
+						side = alternative;
+						point = p;
+						break;
+					}
+				}
+			}
+		}
 		return {
 			point,
 			side: attachment?.facing === "inward" ? {
@@ -1460,6 +1851,30 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 		`n:${edge.targetId}`,
 		`e:${edge.id}`
 	]), metrics$1, batch, config.radius * 2 + lane * config.edgeSpacing) : context;
+	let futureTargetCorridor;
+	const protectFutureTarget = (ctx) => {
+		const obstacles = ctx.obstacles;
+		ctx.obstacles = (bounds) => {
+			const result = obstacles(bounds);
+			return futureTargetCorridor && intersects(bounds, futureTargetCorridor) ? [...result, futureTargetCorridor] : result;
+		};
+		return ctx;
+	};
+	for (const ctx of new Set([context, searchContext])) protectFutureTarget(ctx);
+	const drawn = [];
+	const selfCost = (a, b) => drawn.reduce((cost, segment) => {
+		return cost + (conflictCost(a, b, segment, {
+			...config,
+			edgeSpacing: 0,
+			crossingPenalty: 0,
+			overlapPenalty: 1
+		}) > 1e-8 ? Infinity : conflictCost(a, b, segment, config));
+	}, 0);
+	for (const ctx of new Set([context, searchContext])) {
+		const cost = ctx.edgeCost, guides = ctx.guides;
+		ctx.edgeCost = (a, b) => (cost?.(a, b) ?? 0) + selfCost(a, b);
+		ctx.guides = (bounds) => [...guides?.(bounds) ?? [], ...drawn.map((s) => reservationBounds(s, config.edgeSpacing))];
+	}
 	const labelAnchor = (toward) => {
 		const side = sideToward(center(label), toward), point = anchor(label, side);
 		if ((side === "left" || side === "right") && toward.y > label.y && toward.y < label.y + label.height) return {
@@ -1481,8 +1896,18 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 		}
 	} : target;
 	const lastSource = label ? {
-		point: labelAnchor(target.point),
-		side: sideToward(center(label), target.point),
+		point: firstTarget.side === sideToward(center(label), target.point) ? anchor(label, {
+			left: "right",
+			right: "left",
+			top: "bottom",
+			bottom: "top"
+		}[firstTarget.side]) : labelAnchor(target.point),
+		side: firstTarget.side === sideToward(center(label), target.point) ? {
+			left: "right",
+			right: "left",
+			top: "bottom",
+			bottom: "top"
+		}[firstTarget.side] : sideToward(center(label), target.point),
 		ref: {
 			kind: "label",
 			edgeId: edge.id
@@ -1501,21 +1926,68 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 	function connection(a, b, via$1 = []) {
 		let path, preferred;
 		if (distance(a.point, b.point) < 1e-8 && !via$1.length) {
-			report("CONSTRAINT_VIOLATION", "Coincident terminals; rendered a visible loop fallback");
+			const v = vector(a.side), tangent = {
+				x: -v.y,
+				y: v.x
+			};
 			const gap = config.clearance + config.edgeSpacing + 10;
+			const candidates = [];
+			for (const extent of [
+				config.clearance + 1,
+				(config.clearance + 1) * 2,
+				gap,
+				gap * 2,
+				gap * 3
+			]) for (const sign of [1, -1]) {
+				const lead = Math.min(config.clearance + 1, extent / 3);
+				const at = (normal, lateral) => ({
+					x: a.point.x + v.x * normal + tangent.x * lateral,
+					y: a.point.y + v.y * normal + tangent.y * lateral
+				});
+				const candidate = pathFromPoints([
+					a.point,
+					at(lead, 0),
+					at(lead, sign * extent),
+					at(extent, sign * extent),
+					at(extent, 0),
+					b.point
+				]);
+				if (safe(candidate, context)) candidates.push(candidate);
+			}
+			if (!candidates.length) {
+				const hard = contextFor(state, excluded, new Set([
+					`n:${edge.sourceId}`,
+					`n:${edge.targetId}`,
+					`e:${edge.id}`
+				]), metrics$1, batch, -config.clearance);
+				for (const extent of [
+					config.clearance + 1,
+					gap,
+					gap * 2
+				]) for (const sign of [1, -1]) {
+					const at = (normal, lateral) => ({
+						x: a.point.x + v.x * normal + tangent.x * lateral,
+						y: a.point.y + v.y * normal + tangent.y * lateral
+					});
+					const candidate = pathFromPoints([
+						a.point,
+						at(1, 0),
+						at(1, sign * extent),
+						at(extent, sign * extent),
+						at(extent, 0),
+						b.point
+					]);
+					if (safe(candidate, hard)) candidates.push(candidate);
+				}
+			}
+			candidates.sort((x, y) => pathCost(x, context) - pathCost(y, context));
+			if (candidates.length) return candidates[0];
+			report("CONSTRAINT_VIOLATION", "Coincident terminals; no clear outward loop corridor");
 			return pathFromPoints([
 				a.point,
 				{
-					x: a.point.x + gap,
-					y: a.point.y
-				},
-				{
-					x: a.point.x + gap,
-					y: a.point.y - gap
-				},
-				{
-					x: a.point.x,
-					y: a.point.y - gap
+					x: a.point.x + v.x * gap,
+					y: a.point.y + v.y * gap
 				},
 				b.point
 			]);
@@ -1554,16 +2026,19 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 			}
 		}
 		if (!path) {
-			const start = stub(a), end = stub(b), waypoints = [...via$1];
-			if (loop && !waypoints.length) {
-				const r = inflate(sourceBounds, config.clearance + config.edgeSpacing + 1);
-				waypoints.push({
-					x: r.x + r.width,
-					y: r.y
-				});
-			}
+			const alignedFacing = (a.point.x === b.point.x || a.point.y === b.point.y) && (b.point.x - a.point.x) * vector(a.side).x + (b.point.y - a.point.y) * vector(a.side).y > 0 && (a.point.x - b.point.x) * vector(b.side).x + (a.point.y - b.point.y) * vector(b.side).y > 0;
+			const boundedStub = (t) => {
+				const p = stub(t), gap = distance(a.point, b.point) / 3;
+				if (!alignedFacing || distance(t.point, p) <= gap) return p;
+				const v = vector(t.side);
+				return {
+					x: t.point.x + v.x * gap,
+					y: t.point.y + v.y * gap
+				};
+			};
+			const start = boundedStub(a), end = boundedStub(b), waypoints = [...via$1];
 			if (style === "parallel" && peers.length > 1) {
-				const base = findPath(start, end, "polyline", context);
+				const base = findPathBetweenLeads(start, end, "polyline", context, [[a.point, start], [end, b.point]]);
 				const mid = base && base.length > 2 ? base[Math.floor(base.length / 2)] : center(segmentBounds(start, end));
 				const d = Math.max(1, distance(start, end)), rank = peers.indexOf(edge.id) + 1;
 				const orientation = edge.sourceId < edge.targetId ? 1 : -1;
@@ -1595,13 +2070,13 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 						y: -vector(b.side).y
 					} : void 0
 				};
-				let found = findPath(anchors[i - 1], anchors[i], searchStyle, searchContext, directions);
+				let found = findPathBetweenLeads(anchors[i - 1], anchors[i], searchStyle, searchContext, [[a.point, start], [end, b.point]], directions);
 				if (!found && searchContext !== context && !searchContext.budgetExceeded) {
 					const narrow = {
 						...searchContext,
 						obstacles: context.obstacles
 					};
-					found = findPath(anchors[i - 1], anchors[i], searchStyle, narrow, directions);
+					found = findPathBetweenLeads(anchors[i - 1], anchors[i], searchStyle, narrow, [[a.point, start], [end, b.point]], directions);
 					searchContext.visited = narrow.visited;
 					searchContext.budgetExceeded = narrow.budgetExceeded;
 				}
@@ -1609,13 +2084,140 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 				else ok = false;
 			}
 			points.push(b.point);
-			if (ok) {
-				const simple = simplify(points);
-				path = style === "curved" || style === "bundle" || style === "bezier" ? curve(simple, state, context) : style === "organic" ? organic(simple, state, context) : pathFromPoints(simple);
+			if (ok) {
+				const simple = simplify(points);
+				path = style === "curved" || style === "bundle" || style === "bezier" ? curve(simple, state, context) : style === "organic" ? organic(simple, state, context) : pathFromPoints(simple);
+			}
+		}
+		if (preferred && Number.isFinite(pathCost(preferred, context)) && (!path || !safe(path, context) || pathCost(preferred, context) <= pathCost(path, context))) return preferred;
+		if (path && safe(path, context) && Number.isFinite(pathCost(path, context))) return path;
+		if (![
+			"straight",
+			"bezier",
+			"polyline",
+			"organic",
+			"parallel"
+		].includes(style)) {
+			const hard = {
+				...contextFor(state, excluded, new Set([
+					`n:${edge.sourceId}`,
+					`n:${edge.targetId}`,
+					`e:${edge.id}`
+				]), metrics$1, batch, -config.clearance),
+				maxSearchNodes: Math.max(0, config.maxSearchNodes - searchContext.visited - (searchContext === context ? 0 : context.visited))
+			};
+			protectFutureTarget(hard);
+			hard.guides = void 0;
+			hard.edgeCost = selfCost;
+			const lead = (t) => {
+				const v = vector(t.side);
+				for (let length = 1; length >= 1e-6; length /= 2) {
+					const point = {
+						x: t.point.x + v.x * length,
+						y: t.point.y + v.y * length
+					};
+					if (clear(t.point, point, hard)) return point;
+				}
+				return t.point;
+			};
+			const start = lead(a), end = lead(b), anchors = [
+				start,
+				...via$1,
+				end
+			];
+			const points = [a.point];
+			let ok = clear(a.point, start, hard) && clear(end, b.point, hard);
+			for (let i = 1; ok && i < anchors.length; i++) {
+				const found = findPathBetweenLeads(anchors[i - 1], anchors[i], style === "octilinear" ? "octilinear" : "orthogonal", hard, [[a.point, start], [end, b.point]], {
+					incoming: i === 1 ? vector(a.side) : void 0,
+					outgoing: i === anchors.length - 1 ? {
+						x: -vector(b.side).x,
+						y: -vector(b.side).y
+					} : void 0
+				});
+				if (found) points.push(...found.slice(i === 1 ? 0 : 1));
+				else ok = false;
+			}
+			points.push(b.point);
+			const retry = pathFromPoints(simplify(points));
+			searchContext.visited += hard.visited;
+			if (ok && safe(retry, hard) && Number.isFinite(pathCost(retry, hard))) {
+				let separated = retry;
+				for (let pass = 0; pass < 6; pass++) {
+					const track = [separated.start, ...separated.segments.map((s) => s.to)];
+					let best = separated, bestCost = pathCost(separated, context);
+					for (let i = 1; i < track.length - 2; i++) {
+						const p = track[i], q = track[i + 1];
+						if ((context.edgeCost?.(p, q) ?? 0) === 0) continue;
+						const horizontal = p.y === q.y;
+						if (!horizontal && p.x !== q.x) continue;
+						for (const offset of [
+							-config.edgeSpacing,
+							config.edgeSpacing,
+							-config.edgeSpacing * 2,
+							config.edgeSpacing * 2,
+							-config.edgeSpacing / 2,
+							config.edgeSpacing / 2,
+							-config.edgeSpacing / 3,
+							config.edgeSpacing / 3,
+							-config.edgeSpacing * 4,
+							config.edgeSpacing * 4
+						]) {
+							const candidatePoints = track.map((r, j) => j === i || j === i + 1 ? horizontal ? {
+								x: r.x,
+								y: r.y + offset
+							} : {
+								x: r.x + offset,
+								y: r.y
+							} : r);
+							if (candidatePoints.slice(1).some((r, j) => r.x !== candidatePoints[j].x && r.y !== candidatePoints[j].y)) continue;
+							const candidate = pathFromPoints(simplify(candidatePoints));
+							const segments = pathReservations(candidate);
+							if (segments.some((s, j) => segments.slice(j + 1).some((t) => {
+								if (s.a.x === s.b.x && t.a.x === t.b.x && s.a.x === t.a.x) return Math.min(Math.max(s.a.y, s.b.y), Math.max(t.a.y, t.b.y)) - Math.max(Math.min(s.a.y, s.b.y), Math.min(t.a.y, t.b.y)) > 1e-8;
+								if (s.a.y === s.b.y && t.a.y === t.b.y && s.a.y === t.a.y) return Math.min(Math.max(s.a.x, s.b.x), Math.max(t.a.x, t.b.x)) - Math.max(Math.min(s.a.x, s.b.x), Math.min(t.a.x, t.b.x)) > 1e-8;
+								return false;
+							})) || !safe(candidate, hard)) continue;
+							const cost = pathCost(candidate, context);
+							if (cost < bestCost) {
+								best = candidate;
+								bestCost = cost;
+							}
+						}
+					}
+					if (best === separated) break;
+					separated = best;
+				}
+				if (!via$1.length && pathCost(retry, context) > pathLength(retry)) {
+					const remaining = Math.max(0, config.maxSearchNodes - searchContext.visited - (searchContext === context ? 0 : context.visited));
+					const optimized = {
+						...hard,
+						visited: 0,
+						budgetExceeded: false,
+						maxSearchNodes: Math.min(2e3, remaining),
+						edgeCost: (a$1, b$1) => (batch.edgeCost?.(a$1, b$1) ?? 0) + selfCost(a$1, b$1),
+						guides: (bounds) => (batch.guides?.(bounds) ?? []).slice(0, 8)
+					};
+					const found = findPathBetweenLeads(start, end, style === "octilinear" ? "octilinear" : "orthogonal", optimized, [[a.point, start], [end, b.point]], {
+						incoming: vector(a.side),
+						outgoing: {
+							x: -vector(b.side).x,
+							y: -vector(b.side).y
+						}
+					});
+					searchContext.visited += optimized.visited;
+					if (found) {
+						const candidate = pathFromPoints(simplify([
+							a.point,
+							...found,
+							b.point
+						]));
+						if (safe(candidate, hard) && pathCost(candidate, context) < pathCost(separated, context)) return candidate;
+					}
+				}
+				return separated;
 			}
 		}
-		if (preferred && (!path || !safe(path, context) || pathCost(preferred, context) <= pathCost(path, context))) return preferred;
-		if (path && safe(path, context)) return path;
 		report(searchContext.budgetExceeded ? "SEARCH_BUDGET" : "ROUTE_BLOCKED", "Preferred route unavailable; fallback may cross obstacles or violate routing constraints");
 		if (loop && !via$1.length) {
 			const r = inflate(sourceBounds, config.clearance + config.edgeSpacing + 1);
@@ -1644,6 +2246,25 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 	}
 	const via = perEdge.waypoints ?? [];
 	if (via.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))) throw new RangeError(`Non-finite waypoint on ${edge.id}`);
+	if (lastSource && !loop) {
+		const hard = contextFor(state, excluded, new Set([
+			`n:${edge.sourceId}`,
+			`n:${edge.targetId}`,
+			`e:${edge.id}`
+		]), metrics$1, batch, -config.clearance);
+		const v = vector(target.side);
+		for (let length = config.clearance + 1; length >= 1e-6; length /= 2) {
+			const lead = {
+				x: target.point.x + v.x * length,
+				y: target.point.y + v.y * length
+			};
+			const corridor = inflate(segmentBounds(target.point, lead), Math.min(.5, length / 4));
+			if (clear(target.point, lead, hard) && !intersects(segmentBounds(source.point, source.point), corridor) && !intersects(segmentBounds(firstTarget.point, firstTarget.point), corridor)) {
+				futureTargetCorridor = corridor;
+				break;
+			}
+		}
+	}
 	const plan = grouped ? groupPlan(group, state, metrics$1, batch, style) : void 0;
 	if (grouped && !plan) report("ROUTE_BLOCKED", "Shared trunk unavailable; used individual fallback routing");
 	if (plan) {
@@ -1687,12 +2308,19 @@ function routeEdge(edge, state, style, metrics$1, batch) {
 		to: firstTarget.ref,
 		path: connection(source, firstTarget, via)
 	});
-	if (lastSource) sections.push({
-		id: `${edge.id}:label-target`,
-		from: lastSource.ref,
-		to: target.ref,
-		path: connection(lastSource, target)
-	});
+	if (lastSource) {
+		futureTargetCorridor = void 0;
+		let segments = sections.flatMap((s) => pathReservations(s.path));
+		segments = segments.flatMap((s) => outsideTerminal(s, label, false));
+		if (loop) segments = segments.flatMap((s) => outsideTerminal(s, inflate(sourceBounds, config.clearance + 1)));
+		drawn.push(...segments);
+		sections.push({
+			id: `${edge.id}:label-target`,
+			from: lastSource.ref,
+			to: target.ref,
+			path: connection(lastSource, target)
+		});
+	}
 	if (sections.some((section) => pathReservations(section.path).some((segment) => batch.conflicts?.(segment.a, segment.b)))) report("ROUTE_CONFLICT", "Route crosses or overlaps another edge; retained a compact visible path");
 	metrics$1.searchNodes += searchContext.visited + (searchContext === context ? 0 : context.visited);
 	return {
@@ -2119,250 +2747,6 @@ function applyRoutePatches(routes, patches) {
 	return result;
 }
 
-//#endregion
-//#region src/routing/layout-cache.ts
-const geometryByRoutes = /* @__PURE__ */ new WeakMap();
-/** Compare only geometry and topology; application data may contain cycles. */
-function geometryKey(graph) {
-	return JSON.stringify({
-		nodes: graph.nodes.map(({ id, parentId, x, y, width, height: height$1, ports }) => ({
-			id,
-			parentId,
-			x,
-			y,
-			width,
-			height: height$1,
-			ports: ports?.map(({ name, x: x$1, y: y$1, width: width$1, height: height$2 }) => ({
-				name,
-				x: x$1,
-				y: y$1,
-				width: width$1,
-				height: height$2
-			}))
-		})),
-		edges: graph.edges.map(({ id, sourceId, targetId, sourcePort, targetPort, x, y, width, height: height$1, points, routing }) => ({
-			id,
-			sourceId,
-			targetId,
-			sourcePort,
-			targetPort,
-			x,
-			y,
-			width,
-			height: height$1,
-			points,
-			routing
-		}))
-	});
-}
-/** Associate structured sections with the geometry that produced them. */
-function recordRouteGeometry(graph, routes) {
-	geometryByRoutes.set(routes, geometryKey(graph));
-}
-/** Graph edits invalidate cached sections, including edits made by external consumers. */
-function hasCurrentRouteGeometry(graph, routes) {
-	return geometryByRoutes.get(routes) === geometryKey(graph);
-}
-
-//#endregion
-//#region src/authoring/coordinates.ts
-/** Legacy sibling edges are parent-relative; native compound output marks world-space edges. */
-function frames(graph) {
-	const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
-	const offsets = /* @__PURE__ */ new Map();
-	const visiting = /* @__PURE__ */ new Set();
-	function offset(id) {
-		const cached = offsets.get(id);
-		if (cached) return cached;
-		if (visiting.has(id)) throw new LayoutError(`Cyclic parent hierarchy at ${id}`, "INVALID_GRAPH");
-		visiting.add(id);
-		const parentId = nodes.get(id)?.parentId;
-		if (parentId == null) {
-			const origin = {
-				x: 0,
-				y: 0
-			};
-			visiting.delete(id);
-			offsets.set(id, origin);
-			return origin;
-		}
-		const parent = nodes.get(parentId);
-		const ancestor = offset(parentId);
-		const result = {
-			x: ancestor.x + parent.x,
-			y: ancestor.y + parent.y
-		};
-		visiting.delete(id);
-		offsets.set(id, result);
-		return result;
-	}
-	for (const node$1 of graph.nodes) offsets.set(node$1.id, offset(node$1.id));
-	return {
-		nodes: offsets,
-		edges: new Map(graph.edges.map((edge) => {
-			const source = nodes.get(edge.sourceId);
-			const target = nodes.get(edge.targetId);
-			return [edge.id, graph.edgeCoordinateSpace !== "world" && (source.parentId ?? null) === (target.parentId ?? null) ? offset(source.id) : {
-				x: 0,
-				y: 0
-			}];
-		}))
-	};
-}
-function worldGeometry(graph) {
-	const offsets = frames(graph);
-	const base = { ...graph };
-	delete base.compoundRoutes;
-	delete base.compoundGeometry;
-	return {
-		...base,
-		nodes: graph.nodes.map((n) => {
-			const p = offsets.nodes.get(n.id);
-			return p.x === 0 && p.y === 0 ? n : {
-				...n,
-				x: n.x + p.x,
-				y: n.y + p.y
-			};
-		}),
-		edges: graph.edges.map((e) => {
-			const p = offsets.edges.get(e.id);
-			return p.x === 0 && p.y === 0 ? e : {
-				...e,
-				x: e.x + p.x,
-				y: e.y + p.y,
-				...e.points ? { points: e.points.map((v) => ({
-					x: v.x + p.x,
-					y: v.y + p.y
-				})) } : {}
-			};
-		})
-	};
-}
-/** Ancestor frames stay fixed during authoring. Preserve untouched coordinates exactly. */
-function nativeGeometry(graph, original) {
-	const offsets = frames(original);
-	const world = worldGeometry(original);
-	const originalNodes = new Map(original.nodes.map((n) => [n.id, n]));
-	const originalEdges = new Map(original.edges.map((e) => [e.id, e]));
-	const worldNodes = new Map(world.nodes.map((n) => [n.id, n]));
-	const worldEdges = new Map(world.edges.map((e) => [e.id, e]));
-	return {
-		...graph,
-		nodes: graph.nodes.map((n) => {
-			const p = offsets.nodes.get(n.id), before = originalNodes.get(n.id), prior = worldNodes.get(n.id);
-			return {
-				...n,
-				x: n.x === prior.x ? before.x : n.x - p.x,
-				y: n.y === prior.y ? before.y : n.y - p.y
-			};
-		}),
-		edges: graph.edges.map((e) => {
-			const p = offsets.edges.get(e.id), before = originalEdges.get(e.id), prior = worldEdges.get(e.id);
-			const points = JSON.stringify(e.points) === JSON.stringify(prior.points) ? before.points : e.points?.map((v) => ({
-				x: v.x - p.x,
-				y: v.y - p.y
-			}));
-			return {
-				...e,
-				x: e.x === prior.x ? before.x : e.x - p.x,
-				y: e.y === prior.y ? before.y : e.y - p.y,
-				...points === void 0 ? {} : { points }
-			};
-		})
-	};
-}
-
-//#endregion
-//#region src/routing/adapters.ts
-/** ELK/native spline output: start, then repeating control1/control2/end triples. */
-function pathFromSplinePoints(points) {
-	if (points.length < 4 || (points.length - 1) % 3 !== 0) throw new RangeError("Cubic spline points require a start and control1/control2/end triples");
-	const segments = [];
-	for (let i = 1; i < points.length; i += 3) segments.push({
-		kind: "cubic",
-		control1: { ...points[i] },
-		control2: { ...points[i + 1] },
-		to: { ...points[i + 2] }
-	});
-	return {
-		start: { ...points[0] },
-		segments
-	};
-}
-/** Normalize routes from any native layout algorithm, without running layout again. */
-function getLayoutRoutes(graph) {
-	const compound = graph;
-	if (compound.compoundRoutes?.size && hasCurrentRouteGeometry(graph, compound.compoundRoutes)) return compound.compoundRoutes;
-	const world = worldGeometry(graph), nodes = new Map(world.nodes.map((n) => [n.id, n]));
-	let result = new PersistentMap();
-	for (const edge of world.edges) {
-		const points = edge.points;
-		let path;
-		if (points?.length && points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) if (edge.routing === "splines") {
-			if (points.length >= 4 && (points.length - 1) % 3 === 0) path = pathFromSplinePoints(points);
-		} else path = pathFromPoints(points);
-		const routed = path !== void 0;
-		if (!path) {
-			const a = nodes.get(edge.sourceId), b = nodes.get(edge.targetId);
-			path = pathFromPoints([{
-				x: a ? a.x + a.width : 0,
-				y: a ? a.y + a.height / 2 : 0
-			}, {
-				x: b?.x ?? 40,
-				y: b ? b.y + b.height / 2 : 40
-			}]);
-		}
-		result = result.set(edge.id, freeze({
-			edgeId: edge.id,
-			status: routed ? "routed" : "fallback",
-			diagnostics: routed ? [] : [{
-				code: "MISSING_GEOMETRY",
-				edgeId: edge.id,
-				message: "Layout has no valid route; rendered a fallback connection"
-			}],
-			sections: [{
-				id: `${edge.id}:0`,
-				from: {
-					kind: "node",
-					nodeId: edge.sourceId,
-					...edge.sourcePort === void 0 ? {} : { port: edge.sourcePort }
-				},
-				to: {
-					kind: "node",
-					nodeId: edge.targetId,
-					...edge.targetPort === void 0 ? {} : { port: edge.targetPort }
-				},
-				path
-			}]
-		}));
-	}
-	return result;
-}
-/** One polyline per section preserves label gaps and branching for simple renderers. */
-function routeToPolylines(route, options) {
-	return route.sections.map((s) => flattenPath(s.path, options));
-}
-/** Compatibility for single-section native consumers. Refuses to erase gaps or topology. */
-function routeToGraphPatch(route, options = {}) {
-	if (route.sections.length !== 1 || route.sections[0].sharedId || route.sections[0].from.kind !== "node" || route.sections[0].to.kind !== "node") throw new Error("This route requires section-aware rendering; a single GraphEdge.points array would lose topology");
-	const offset = options.offset ?? {
-		x: 0,
-		y: 0
-	};
-	const points = flattenPath(route.sections[0].path, options).map((p) => ({
-		x: p.x - offset.x,
-		y: p.y - offset.y
-	}));
-	return {
-		op: "updateEdge",
-		id: route.edgeId,
-		data: {
-			points,
-			routing: "polyline"
-		}
-	};
-}
-
 //#endregion
 //#region src/routing/index.ts
 const straightRouting = createRoutingStrategy("straight");
@@ -2393,4 +2777,4 @@ const routingStrategies = Object.freeze({
 });
 
 //#endregion
-export { toSvgPath as A, flattenPath as C, getTangentAtLength as D, getPointAtLength as E, UnsupportedLayoutError as F, routeCrosses as M, routeOrthogonal as N, pathFromPoints as O, LayoutError as P, freeze as S, getPathLength as T, routeToPolylines as _, fanRouting as a, recordRouteGeometry as b, orthogonalRouting as c, routingStrategies as d, selfLoopRouting as f, routeToGraphPatch as g, pathFromSplinePoints as h, curvedRouting as i, overlaps as j, roundCorners as k, parallelRouting as l, getLayoutRoutes as m, bundleRouting as n, octilinearRouting as o, straightRouting as p, busRouting as r, organicRouting as s, bezierRouting as t, polylineRouting as u, nativeGeometry as v, getPathBounds as w, applyRoutePatches as x, worldGeometry as y };
+export { routeOrthogonal as A, getPointAtLength as C, toSvgPath as D, roundCorners as E, LayoutError as F, UnsupportedLayoutError as I, recordRouteGeometry as M, nativeGeometry as N, overlaps as O, worldGeometry as P, getPathLength as S, pathFromPoints as T, routeToGraphPatch as _, fanRouting as a, flattenPath as b, orthogonalRouting as c, routingStrategies as d, selfLoopRouting as f, pathFromSplinePoints as g, getLayoutRoutes as h, curvedRouting as i, freeze as j, routeCrosses as k, parallelRouting as l, applyRoutePatches as m, bundleRouting as n, octilinearRouting as o, straightRouting as p, busRouting as r, organicRouting as s, bezierRouting as t, polylineRouting as u, routeToPoints as v, getTangentAtLength as w, getPathBounds as x, routeToPolylines as y };