@statelyai/layout 0.3.0 → 0.4.0

package/dist/{routing-ujEP7Qh6.cjs → routing-QIdGGFBe.cjs}

@@ -14,6 +14,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) {
@@ -26,7 +509,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));
@@ -484,173 +967,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
@@ -711,6 +1159,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;
@@ -768,21 +1221,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;
 			}
@@ -818,7 +1281,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;
 				}
@@ -852,7 +1315,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;
 		}
@@ -876,7 +1339,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;
@@ -897,6 +1360,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);
@@ -915,12 +1380,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
@@ -963,7 +1449,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 [[
@@ -977,13 +1463,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
@@ -997,151 +1483,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,
@@ -1158,7 +1507,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;
@@ -1427,6 +1786,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" ? {
@@ -1461,6 +1852,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 {
@@ -1482,8 +1897,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
@@ -1502,21 +1927,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
 			]);
@@ -1555,16 +2027,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;
@@ -1596,27 +2071,154 @@ 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;
 				}
-				if (found) points.push(...found.slice(i === 1 ? 0 : 1));
-				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 (found) points.push(...found.slice(i === 1 ? 0 : 1));
+				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 (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);
@@ -1645,6 +2247,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) {
@@ -1688,12 +2309,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 {
@@ -2120,250 +2748,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");
@@ -2568,6 +2952,12 @@ Object.defineProperty(exports, 'routeToGraphPatch', {
     return routeToGraphPatch;
   }
 });
+Object.defineProperty(exports, 'routeToPoints', {
+  enumerable: true,
+  get: function () {
+    return routeToPoints;
+  }
+});
 Object.defineProperty(exports, 'routeToPolylines', {
   enumerable: true,
   get: function () {