@statelyai/layout 0.4.3 → 0.5.1

package/dist/routing-CR8flv8b.mjs

@@ -1,2780 +0,0 @@
-//#region src/errors.ts
-var LayoutError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "LayoutError";
-	}
-};
-var UnsupportedLayoutError = class extends LayoutError {
-	constructor(message) {
-		super(message, "UNSUPPORTED_LAYOUT");
-		this.name = "UnsupportedLayoutError";
-	}
-};
-
-//#endregion
-//#region src/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) {
-	return a.width > 0 && a.height > 0 && b.width > 0 && b.height > 0 && a.x < b.x + b.width + gap && a.x + a.width + gap > b.x && a.y < b.y + b.height + gap && a.y + a.height + gap > b.y;
-}
-/** Open-interior intersection: travelling along a rectangle boundary is allowed. */
-function crossesRect(a, b, rect$1) {
-	let low = 0, high = 1;
-	for (const axis of ["x", "y"]) {
-		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 + 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));
-			high = Math.min(high, Math.max(t1, t2));
-		}
-	}
-	return low < high - 1e-10;
-}
-function routeCrosses(points, rect$1) {
-	return points?.some((point, i) => i > 0 && crossesRect(points[i - 1], point, rect$1)) ?? false;
-}
-function endpoint(node$1, portName, direction, source) {
-	if (portName !== void 0) {
-		const port = node$1.ports?.find((p) => p.name === portName);
-		if (port?.x !== void 0 && port.y !== void 0) return {
-			x: node$1.x + port.x + (port.width ?? 0) / 2,
-			y: node$1.y + port.y + (port.height ?? 0) / 2
-		};
-		throw new LayoutError(`Port ${portName} on ${node$1.id} requires positioned geometry`, "MISSING_GEOMETRY");
-	}
-	const horizontal = direction === "left" || direction === "right";
-	const far = source === (direction === "right" || direction === "down");
-	return horizontal ? {
-		x: node$1.x + (far ? node$1.width : 0),
-		y: node$1.y + node$1.height / 2
-	} : {
-		x: node$1.x + node$1.width / 2,
-		y: node$1.y + (far ? node$1.height : 0)
-	};
-}
-/** Deterministic orthogonal visibility-grid search around fixed rectangles. */
-function connect(start, end, obstacles, check) {
-	if (start.x === end.x && start.y === end.y) return [start];
-	for (let attempt = 0; attempt < 8; attempt++) {
-		check();
-		const margin = 64 * 2 ** attempt;
-		const left = Math.min(start.x, end.x) - margin;
-		const right = Math.max(start.x, end.x) + margin;
-		const top = Math.min(start.y, end.y) - margin;
-		const bottom = Math.max(start.y, end.y) + margin;
-		const local = obstacles.filter((r) => r.x <= right && r.x + r.width >= left && r.y <= bottom && r.y + r.height >= top);
-		const result = search(start, end, local, obstacles, check);
-		if (result || local.length === obstacles.length) return result;
-	}
-}
-function search(start, end, gridObstacles, obstacles, check) {
-	const xs = [...new Set([
-		start.x,
-		end.x,
-		...gridObstacles.flatMap((r) => [r.x, r.x + r.width])
-	])].sort((a, b) => a - b);
-	const ys = [...new Set([
-		start.y,
-		end.y,
-		...gridObstacles.flatMap((r) => [r.y, r.y + r.height])
-	])].sort((a, b) => a - b);
-	if (xs.length * ys.length > 4e4) return void 0;
-	const width = xs.length;
-	const point = (id) => ({
-		x: xs[id % width],
-		y: ys[Math.floor(id / width)]
-	});
-	const from = ys.indexOf(start.y) * width + xs.indexOf(start.x);
-	const to = ys.indexOf(end.y) * width + xs.indexOf(end.x);
-	const distances = new Map([[from, 0]]);
-	const previous = /* @__PURE__ */ new Map();
-	const queue = [];
-	function push(item) {
-		queue.push(item);
-		let i = queue.length - 1;
-		while (i > 0) {
-			const parent = i - 1 >> 1;
-			if (queue[parent].cost <= item.cost) break;
-			queue[i] = queue[parent];
-			i = parent;
-		}
-		queue[i] = item;
-	}
-	function pop() {
-		const first = queue[0];
-		const last = queue.pop();
-		if (queue.length) {
-			let i = 0;
-			while (i * 2 + 1 < queue.length) {
-				let child = i * 2 + 1;
-				if (child + 1 < queue.length && queue[child + 1].cost < queue[child].cost) child++;
-				if (last.cost <= queue[child].cost) break;
-				queue[i] = queue[child];
-				i = child;
-			}
-			queue[i] = last;
-		}
-		return first;
-	}
-	push({
-		id: from,
-		cost: 0
-	});
-	let visits = 0;
-	while (queue.length) {
-		if (++visits % 128 === 0) check();
-		const current = pop();
-		if (current.cost !== distances.get(current.id)) continue;
-		if (current.id === to) {
-			const result = [end];
-			let id = to;
-			while (id !== from) {
-				id = previous.get(id);
-				result.push(point(id));
-			}
-			return result.reverse();
-		}
-		const x = current.id % width, y = Math.floor(current.id / width);
-		const neighbors = [
-			x > 0 ? current.id - 1 : -1,
-			x + 1 < width ? current.id + 1 : -1,
-			y > 0 ? current.id - width : -1,
-			y + 1 < ys.length ? current.id + width : -1
-		];
-		const a = point(current.id);
-		for (const next of neighbors) {
-			if (next < 0) continue;
-			const b = point(next);
-			if (obstacles.some((rect$1) => crossesRect(a, b, rect$1))) continue;
-			const cost = current.cost + Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-			if (cost >= (distances.get(next) ?? Infinity)) continue;
-			distances.set(next, cost);
-			previous.set(next, current.id);
-			push({
-				id: next,
-				cost
-			});
-		}
-	}
-}
-function routeOrthogonal(edge, source, target, direction, obstacles, waypoints, check) {
-	const anchors = [
-		endpoint(source, edge.sourcePort, direction, true),
-		...waypoints,
-		endpoint(target, edge.targetPort, direction, false)
-	];
-	const points = [];
-	for (let i = 1; i < anchors.length; i++) {
-		const segment = connect(anchors[i - 1], anchors[i], obstacles, check);
-		if (!segment) return void 0;
-		points.push(...points.length ? segment.slice(1) : segment);
-	}
-	return points.filter((p, i) => {
-		if (i === 0 || i === points.length - 1) return true;
-		const before = points[i - 1], after = points[i + 1];
-		return !(before.x === p.x && p.x === after.x && (p.y - before.y) * (after.y - p.y) >= 0 || before.y === p.y && p.y === after.y && (p.x - before.x) * (after.x - p.x) >= 0);
-	});
-}
-
-//#endregion
-//#region src/routing/path.ts
-const distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
-const lerp = (a, b, t) => ({
-	x: a.x + (b.x - a.x) * t,
-	y: a.y + (b.y - a.y) * t
-});
-function pathFromPoints(points) {
-	if (!points.length) throw new RangeError("A path needs at least one point");
-	return {
-		start: { ...points[0] },
-		segments: points.slice(1).map((to) => ({
-			kind: "line",
-			to: { ...to }
-		}))
-	};
-}
-function pointLineDistance(p, a, b) {
-	const squared = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
-	return distance(p, lerp(a, b, squared ? Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / squared)) : 0));
-}
-/** SVG endpoint-to-center conversion, including SVG's radius correction. */
-function arcCenter(start, arc) {
-	let rx = Math.abs(arc.rx), ry = Math.abs(arc.ry);
-	if (!rx || !ry || distance(start, arc.to) === 0) return void 0;
-	const phi = arc.rotation * Math.PI / 180, c = Math.cos(phi), s = Math.sin(phi);
-	const dx = (start.x - arc.to.x) / 2, dy = (start.y - arc.to.y) / 2;
-	const x = c * dx + s * dy, y = -s * dx + c * dy;
-	const scale = Math.sqrt(Math.max(1, x * x / (rx * rx) + y * y / (ry * ry)));
-	rx *= scale;
-	ry *= scale;
-	const factor = (arc.largeArc === arc.sweep ? -1 : 1) * Math.sqrt(Math.max(0, (rx * rx * ry * ry - rx * rx * y * y - ry * ry * x * x) / (rx * rx * y * y + ry * ry * x * x)));
-	const cx = factor * rx * y / ry, cy = -factor * ry * x / rx;
-	const center$1 = {
-		x: c * cx - s * cy + (start.x + arc.to.x) / 2,
-		y: s * cx + c * cy + (start.y + arc.to.y) / 2
-	};
-	const theta = Math.atan2((y - cy) / ry, (x - cx) / rx);
-	let delta = Math.atan2((-y - cy) / ry, (-x - cx) / rx) - theta;
-	if (arc.sweep && delta < 0) delta += 2 * Math.PI;
-	if (!arc.sweep && delta > 0) delta -= 2 * Math.PI;
-	return {
-		rx,
-		ry,
-		c,
-		s,
-		center: center$1,
-		theta,
-		delta
-	};
-}
-/** Adaptive, bounded-error polyline approximation. Throws rather than silently exceeding tolerance. */
-function flattenPath(path, options = {}) {
-	const tolerance = options.tolerance ?? .5, max = options.maxSegments ?? 65536;
-	if (!(tolerance > 0 && Number.isFinite(tolerance)) || !Number.isInteger(max) || max < 1) throw new RangeError("Invalid flattening tolerance or segment budget");
-	const points = [{ ...path.start }];
-	const add = (point) => {
-		if (points.length > max) throw new RangeError("Path flattening exceeded maxSegments");
-		points.push({ ...point });
-	};
-	function bezier(controls, depth = 0) {
-		const first = controls[0], last = controls.at(-1);
-		if (controls.slice(1, -1).every((p) => pointLineDistance(p, first, last) <= tolerance)) {
-			add(last);
-			return;
-		}
-		if (depth >= 32) throw new RangeError("Cannot flatten path at requested tolerance");
-		const left = [first], right = [last];
-		let row = [...controls];
-		while (row.length > 1) {
-			row = row.slice(1).map((p, i) => lerp(row[i], p, .5));
-			left.push(row[0]);
-			right.unshift(row.at(-1));
-		}
-		bezier(left, depth + 1);
-		bezier(right, depth + 1);
-	}
-	let from = path.start;
-	for (const segment of path.segments) {
-		if (segment.kind === "line") add(segment.to);
-		else if (segment.kind === "quadratic") bezier([
-			from,
-			segment.control,
-			segment.to
-		]);
-		else if (segment.kind === "cubic") bezier([
-			from,
-			segment.control1,
-			segment.control2,
-			segment.to
-		]);
-		else {
-			const arc = arcCenter(from, segment);
-			if (!arc) add(segment.to);
-			else {
-				const step = Math.min(Math.PI / 2, 2 * Math.acos(Math.max(-1, 1 - tolerance / Math.max(arc.rx, arc.ry))));
-				const count = Math.max(1, Math.ceil(Math.abs(arc.delta) / step));
-				if (!Number.isFinite(count) || points.length + count > max + 1) throw new RangeError("Path flattening exceeded maxSegments");
-				for (let i = 1; i < count; i++) {
-					const t = arc.theta + arc.delta * i / count;
-					add({
-						x: arc.center.x + arc.c * arc.rx * Math.cos(t) - arc.s * arc.ry * Math.sin(t),
-						y: arc.center.y + arc.s * arc.rx * Math.cos(t) + arc.c * arc.ry * Math.sin(t)
-					});
-				}
-				add(segment.to);
-			}
-		}
-		from = segment.to;
-	}
-	return points;
-}
-/** Conservative bounds: control hulls and full ellipse envelopes contain every curve. */
-function getPathBounds(path) {
-	const points = [path.start];
-	let from = path.start;
-	for (const segment of path.segments) {
-		points.push(segment.to);
-		if (segment.kind === "quadratic") points.push(segment.control);
-		if (segment.kind === "cubic") points.push(segment.control1, segment.control2);
-		if (segment.kind === "arc") {
-			const arc = arcCenter(from, segment);
-			if (arc) {
-				const dx = Math.hypot(arc.rx * arc.c, arc.ry * arc.s), dy = Math.hypot(arc.rx * arc.s, arc.ry * arc.c);
-				points.push({
-					x: arc.center.x - dx,
-					y: arc.center.y - dy
-				}, {
-					x: arc.center.x + dx,
-					y: arc.center.y + dy
-				});
-			}
-		}
-		from = segment.to;
-	}
-	const xs = points.map((p) => p.x), ys = points.map((p) => p.y);
-	const x = Math.min(...xs), y = Math.min(...ys);
-	return {
-		x,
-		y,
-		width: Math.max(...xs) - x,
-		height: Math.max(...ys) - y
-	};
-}
-function getPathLength(path, options) {
-	const points = flattenPath(path, options);
-	return points.reduce((sum, p, i) => sum + (i ? distance(points[i - 1], p) : 0), 0);
-}
-function locate(path, length, options) {
-	const points = flattenPath(path, options);
-	let remaining = Math.max(0, length);
-	for (let i = 1; i < points.length; i++) {
-		const a = points[i - 1], b = points[i], size$1 = distance(a, b);
-		if (size$1 && (remaining <= size$1 || i === points.length - 1)) return {
-			a,
-			b,
-			t: Math.min(1, remaining / size$1)
-		};
-		remaining -= size$1;
-	}
-	return {
-		a: points.at(-1),
-		b: points.at(-1),
-		t: 0
-	};
-}
-function getPointAtLength(path, length, options) {
-	const { a, b, t } = locate(path, length, options);
-	return lerp(a, b, t);
-}
-function getTangentAtLength(path, length, options) {
-	const { a, b } = locate(path, length, options), d = distance(a, b);
-	return d ? {
-		x: (b.x - a.x) / d,
-		y: (b.y - a.y) / d
-	} : {
-		x: 0,
-		y: 0
-	};
-}
-/** Round line-to-line corners only; existing curves and path endpoints are retained. */
-function roundCorners(path, options) {
-	const radius = options.radius;
-	if (!Number.isFinite(radius) || radius < 0) throw new RangeError("radius must be non-negative and finite");
-	if (!radius) return path;
-	const result = [];
-	let previous = path.start;
-	for (let i = 0; i < path.segments.length; i++) {
-		const segment = path.segments[i], next = path.segments[i + 1];
-		const corner = segment.to;
-		if (segment.kind === "line" && next?.kind === "line") {
-			const l1 = distance(previous, corner), l2 = distance(corner, next.to);
-			if (l1 > 0 && l2 > 0) {
-				const u = {
-					x: (corner.x - previous.x) / l1,
-					y: (corner.y - previous.y) / l1
-				}, v = {
-					x: (next.to.x - corner.x) / l2,
-					y: (next.to.y - corner.y) / l2
-				};
-				const angle = Math.acos(Math.max(-1, Math.min(1, u.x * v.x + u.y * v.y)));
-				if (angle > 1e-8 && angle < Math.PI - 1e-8) {
-					const tangent = Math.tan(angle / 2), trim = Math.min(radius * tangent, l1 / 2, l2 / 2), r = trim / tangent;
-					result.push({
-						kind: "line",
-						to: {
-							x: corner.x - u.x * trim,
-							y: corner.y - u.y * trim
-						}
-					}, {
-						kind: "arc",
-						rx: r,
-						ry: r,
-						rotation: 0,
-						largeArc: false,
-						sweep: u.x * v.y - u.y * v.x > 0,
-						to: {
-							x: corner.x + v.x * trim,
-							y: corner.y + v.y * trim
-						}
-					});
-					previous = corner;
-					continue;
-				}
-			}
-		}
-		result.push(segment);
-		previous = corner;
-	}
-	return {
-		start: path.start,
-		segments: result
-	};
-}
-function toSvgPath(path, options = {}) {
-	const shaped = options.radius ? roundCorners(path, { radius: options.radius }) : path;
-	const precision = options.precision ?? 6;
-	if (!Number.isInteger(precision) || precision < 0 || precision > 15) throw new RangeError("precision must be an integer from 0 to 15");
-	const n = (value) => {
-		if (!Number.isFinite(value)) throw new RangeError("Path coordinates must be finite");
-		return String(Number(value.toFixed(precision)));
-	};
-	const p = (point) => `${n(point.x)} ${n(point.y)}`;
-	return [`M ${p(shaped.start)}`, ...shaped.segments.map((s) => {
-		switch (s.kind) {
-			case "line": return `L ${p(s.to)}`;
-			case "quadratic": return `Q ${p(s.control)} ${p(s.to)}`;
-			case "cubic": return `C ${p(s.control1)} ${p(s.control2)} ${p(s.to)}`;
-			case "arc": return `A ${n(Math.abs(s.rx))} ${n(Math.abs(s.ry))} ${n(s.rotation)} ${Number(s.largeArc)} ${Number(s.sweep)} ${p(s.to)}`;
-		}
-	})].join(" ");
-}
-/** Test curve geometry, subdividing conservative bounds only where they overlap. */
-function segmentCrossesRect(start, segment, rect$1) {
-	const overlaps$1 = (points) => {
-		const xs = points.map((p) => p.x), ys = points.map((p) => p.y);
-		return Math.min(...xs) < rect$1.x + rect$1.width && Math.max(...xs) > rect$1.x && Math.min(...ys) < rect$1.y + rect$1.height && Math.max(...ys) > rect$1.y;
-	};
-	const inside = (p) => p.x > rect$1.x && p.x < rect$1.x + rect$1.width && p.y > rect$1.y && p.y < rect$1.y + rect$1.height;
-	function bezier(controls, depth) {
-		if (!overlaps$1(controls)) return false;
-		if (inside(controls[0]) || inside(controls.at(-1))) return true;
-		if (depth === 32) return true;
-		const left = [controls[0]], right = [controls.at(-1)];
-		let row = [...controls];
-		while (row.length > 1) {
-			row = row.slice(1).map((p, i) => lerp(row[i], p, .5));
-			left.push(row[0]);
-			right.unshift(row.at(-1));
-		}
-		return bezier(left, depth + 1) || bezier(right, depth + 1);
-	}
-	if (segment.kind === "line") return crossesRect(start, segment.to, rect$1);
-	if (segment.kind === "quadratic") return bezier([
-		start,
-		segment.control,
-		segment.to
-	], 0);
-	if (segment.kind === "cubic") return bezier([
-		start,
-		segment.control1,
-		segment.control2,
-		segment.to
-	], 0);
-	const arc = arcCenter(start, segment);
-	if (!arc) return crossesRect(start, segment.to, rect$1);
-	const point = (t) => ({
-		x: arc.center.x + arc.c * arc.rx * Math.cos(t) - arc.s * arc.ry * Math.sin(t),
-		y: arc.center.y + arc.s * arc.rx * Math.cos(t) + arc.c * arc.ry * Math.sin(t)
-	});
-	function interval(a, b, depth) {
-		const points = [point(a), point(b)];
-		for (const base of [Math.atan2(-arc.s * arc.ry, arc.c * arc.rx), Math.atan2(arc.c * arc.ry, arc.s * arc.rx)]) for (let k = Math.ceil((a - base) / Math.PI); base + k * Math.PI < b; k++) points.push(point(base + k * Math.PI));
-		if (!overlaps$1(points)) return false;
-		if (inside(points[0]) || inside(points[1])) return true;
-		if (depth === 32) return true;
-		const middle = (a + b) / 2;
-		return interval(a, middle, depth + 1) || interval(middle, b, depth + 1);
-	}
-	return interval(Math.min(arc.theta, arc.theta + arc.delta), Math.max(arc.theta, arc.theta + arc.delta), 0);
-}
-
-//#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));
-}
-/**
-* 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
-			});
-		}
-		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
-const segmentBounds = (a, b) => ({
-	x: Math.min(a.x, b.x),
-	y: Math.min(a.y, b.y),
-	width: Math.abs(b.x - a.x),
-	height: Math.abs(b.y - a.y)
-});
-function clear(a, b, context) {
-	return !context.obstacles(segmentBounds(a, b)).some((r) => crossesRect(a, b, r));
-}
-function simplify(points) {
-	const result = [];
-	for (const p of points) {
-		if (result.length && distance(result.at(-1), p) < 1e-9) continue;
-		while (result.length > 1) {
-			const a = result.at(-2), b = result.at(-1);
-			if (Math.abs((b.x - a.x) * (p.y - b.y) - (b.y - a.y) * (p.x - b.x)) > 1e-8 || (b.x - a.x) * (p.x - b.x) + (b.y - a.y) * (p.y - b.y) < 0) break;
-			result.pop();
-		}
-		result.push(p);
-	}
-	return result;
-}
-var Queue = class {
-	items = [];
-	push(value, priority) {
-		const item = {
-			value,
-			priority
-		};
-		let i = this.items.length;
-		this.items.push(item);
-		while (i > 0) {
-			const p = i - 1 >> 1;
-			if (this.items[p].priority <= priority) break;
-			this.items[i] = this.items[p];
-			i = p;
-		}
-		this.items[i] = item;
-	}
-	pop() {
-		const first = this.items[0], last = this.items.pop();
-		if (this.items.length) {
-			let i = 0;
-			while (i * 2 + 1 < this.items.length) {
-				let child = i * 2 + 1;
-				if (child + 1 < this.items.length && this.items[child + 1].priority < this.items[child].priority) child++;
-				if (last.priority <= this.items[child].priority) break;
-				this.items[i] = this.items[child];
-				i = child;
-			}
-			this.items[i] = last;
-		}
-		return first.value;
-	}
-};
-/** 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;
-		return dot < -1e-8 ? context.bendPenalty * 4 : Math.abs(cross) > 1e-8 ? context.bendPenalty : 0;
-	};
-	const delta = (a, b) => ({
-		x: b.x - a.x,
-		y: b.y - a.y
-	});
-	const attachmentCost = (points) => turnCost(terminals.incoming, delta(points[0], points[1])) + turnCost(delta(points.at(-2), points.at(-1)), terminals.outgoing);
-	const aligned = start.x === end.x || start.y === end.y;
-	if ((style === "polyline" || aligned || style === "octilinear" && Math.abs(start.x - end.x) === Math.abs(start.y - end.y)) && clear(start, end, context) && attachmentCost([start, end]) === 0 && (context.edgeCost?.(start, end) ?? 0) === 0) return [start, end];
-	if (style === "orthogonal") {
-		const candidates = [{
-			x: start.x,
-			y: end.y
-		}, {
-			x: end.x,
-			y: start.y
-		}].filter((bend) => clear(start, bend, context) && clear(bend, end, context)).map((bend) => simplify([
-			start,
-			bend,
-			end
-		]));
-		candidates.sort((a, b) => attachmentCost(a) - attachmentCost(b));
-		if (candidates.length && attachmentCost(candidates[0]) === 0 && candidates[0].slice(1).every((p, i) => (context.edgeCost?.(candidates[0][i], p) ?? 0) === 0)) return candidates[0];
-	}
-	for (let attempt = 0; attempt < 5 && context.visited < context.maxSearchNodes; attempt++) {
-		const area = inflate(segmentBounds(start, end), 32 * 2 ** attempt);
-		const guides = context.guides?.(area) ?? [];
-		const corners = [...context.obstacles(guides.reduce(union, area)), ...guides].flatMap((r) => [
-			{
-				x: r.x,
-				y: r.y
-			},
-			{
-				x: r.x + r.width,
-				y: r.y
-			},
-			{
-				x: r.x,
-				y: r.y + r.height
-			},
-			{
-				x: r.x + r.width,
-				y: r.y + r.height
-			}
-		]);
-		let points, neighbors;
-		if (style === "polyline") {
-			points = [
-				start,
-				end,
-				...corners
-			];
-			neighbors = () => points.map((_, i) => i);
-		} else {
-			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)
-			]);
-			const ys = coordinates([
-				start.y,
-				end.y,
-				area.y,
-				area.y + area.height,
-				...corners.map((p) => p.y)
-			]);
-			if (xs.length * ys.length > maxGridNodes) {
-				context.budgetExceeded = true;
-				return;
-			}
-			points = ys.flatMap((y) => xs.map((x) => ({
-				x,
-				y
-			})));
-			const width = xs.length;
-			if (style === "octilinear") {
-				const extra = [];
-				for (const p of [
-					start,
-					end,
-					...corners
-				]) for (const x of xs) for (const sign of [-1, 1]) {
-					const y = p.y + sign * (x - p.x);
-					if (y >= area.y && y <= area.y + area.height) extra.push({
-						x,
-						y
-					});
-				}
-				for (const p of [
-					start,
-					end,
-					...corners
-				]) for (const y of ys) for (const sign of [-1, 1]) {
-					const x = p.x + sign * (y - p.y);
-					if (x >= area.x && x <= area.x + area.width) extra.push({
-						x,
-						y
-					});
-				}
-				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 > maxGridNodes) {
-					context.budgetExceeded = true;
-					return;
-				}
-				const groups = /* @__PURE__ */ new Map();
-				const keys = (p) => [
-					`x:${p.x}`,
-					`y:${p.y}`,
-					`a:${(p.x - p.y).toFixed(8)}`,
-					`b:${(p.x + p.y).toFixed(8)}`
-				];
-				points.forEach((p, i) => {
-					for (const key of keys(p)) {
-						const list = groups.get(key) ?? [];
-						list.push(i);
-						groups.set(key, list);
-					}
-				});
-				const adjacent = points.map(() => /* @__PURE__ */ new Set());
-				for (const ids of groups.values()) {
-					ids.sort((a, b) => points[a].x - points[b].x || points[a].y - points[b].y);
-					for (let i = 1; i < ids.length; i++) {
-						adjacent[ids[i - 1]].add(ids[i]);
-						adjacent[ids[i]].add(ids[i - 1]);
-					}
-				}
-				neighbors = (i) => [...adjacent[i]];
-			} else neighbors = (i) => [
-				i % width ? i - 1 : -1,
-				i % width < width - 1 ? i + 1 : -1,
-				i >= width ? i - width : -1,
-				i + width < points.length ? i + width : -1
-			].filter((v) => v >= 0);
-		}
-		if (points.length > maxGridNodes) {
-			context.budgetExceeded = true;
-			return;
-		}
-		const from = points.findIndex((p) => distance(p, start) < 1e-8), to = points.findIndex((p) => distance(p, end) < 1e-8);
-		const queue = new Queue();
-		const costs = /* @__PURE__ */ new Map(), parents = /* @__PURE__ */ new Map(), vertices = /* @__PURE__ */ new Map(), visibility = /* @__PURE__ */ new Map(), edgeCosts = /* @__PURE__ */ new Map();
-		const visible = (a, b) => {
-			const key = a < b ? a * points.length + b : b * points.length + a;
-			let result = visibility.get(key);
-			if (result === void 0) {
-				result = clear(points[a], points[b], context);
-				visibility.set(key, result);
-			}
-			return result;
-		};
-		const first = `${from}:-1`;
-		costs.set(first, 0);
-		vertices.set(first, from);
-		queue.push({
-			index: from,
-			previous: -1,
-			key: first,
-			cost: 0
-		}, remainingDistance(start));
-		while (queue.items.length && context.visited < context.maxSearchNodes) {
-			const current = queue.pop();
-			if (costs.get(current.key) !== current.cost) continue;
-			context.visited++;
-			if (current.index === to) {
-				const result = [];
-				let key = current.key;
-				while (key !== void 0) {
-					result.push(points[vertices.get(key)]);
-					key = parents.get(key);
-				}
-				return simplify(result.reverse());
-			}
-			const a = points[current.index];
-			for (const next of neighbors(current.index)) {
-				if (next === current.index || next === current.previous) continue;
-				const b = points[next];
-				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);
-				if (edgeCost === void 0) {
-					edgeCost = context.edgeCost?.(a, b) ?? 0;
-					edgeCosts.set(pair, edgeCost);
-				}
-				const cost = current.cost + distance(a, b) + bend + edgeCost;
-				const key = `${next}:${current.index}`;
-				if (cost >= (costs.get(key) ?? Infinity)) continue;
-				costs.set(key, cost);
-				parents.set(key, current.key);
-				vertices.set(key, next);
-				queue.push({
-					index: next,
-					previous: current.index,
-					key,
-					cost
-				}, 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
-function reservations(route) {
-	return route.sections.flatMap((section) => pathReservations(section.path).map((segment) => ({
-		...segment,
-		sharedId: section.sharedId
-	})));
-}
-function pathReservations(path) {
-	const points = flattenPath(path, { tolerance: .5 });
-	return points.slice(1).map((b, i) => ({
-		a: points[i],
-		b
-	}));
-}
-function reservationBounds(segment, spacing) {
-	return inflate(segmentBounds(segment.a, segment.b), Math.max(1, spacing));
-}
-/** Finite penalties: a crossing is preferable to an arbitrarily long detour. */
-function conflictCost(a, b, other, config) {
-	const dx = b.x - a.x, dy = b.y - a.y;
-	const ex = other.b.x - other.a.x, ey = other.b.y - other.a.y;
-	const length = Math.hypot(dx, dy), otherLength = Math.hypot(ex, ey);
-	if (length < 1e-8 || otherLength < 1e-8) return 0;
-	const cross = dx * ey - dy * ex;
-	const ox = other.a.x - a.x, oy = other.a.y - a.y;
-	if (Math.abs(cross) > 1e-8 * length * otherLength) {
-		const t = (ox * ey - oy * ex) / cross;
-		const u = (ox * dy - oy * dx) / cross;
-		if (t < -1e-8 || t > 1.00000001 || u < -1e-8 || u > 1.00000001) return 0;
-		return config.crossingPenalty * (t < 1e-8 || t > .99999999 ? .5 : 1) * (u < 1e-8 || u > .99999999 ? .5 : 1);
-	}
-	const separation = Math.abs(ox * dy - oy * dx) / length;
-	const spacing = Math.max(1e-8, config.edgeSpacing);
-	if (separation >= spacing) return 0;
-	const lo = (ox * dx + oy * dy) / length;
-	const hi = lo + (ex * dx + ey * dy) / length;
-	const overlap = Math.max(0, Math.min(length, Math.max(lo, hi)) - Math.max(0, Math.min(lo, hi)));
-	return config.overlapPenalty * overlap * (1 - separation / spacing);
-}
-/** Remove only the common terminal's attachment region from soft reservations. */
-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 [[
-		segment.a.x,
-		dx,
-		rect$1.x,
-		rect$1.x + rect$1.width
-	], [
-		segment.a.y,
-		dy,
-		rect$1.y,
-		rect$1.y + rect$1.height
-	]]) if (Math.abs(delta) < 1e-8) {
-		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 (closed ? lo > hi : lo >= hi) return [segment];
-	const at = (t) => ({
-		x: segment.a.x + dx * t,
-		y: segment.a.y + dy * t
-	});
-	return [...lo > 1e-8 ? [{
-		...segment,
-		b: at(lo)
-	}] : [], ...hi < .99999999 ? [{
-		...segment,
-		a: at(hi)
-	}] : []];
-}
-
-//#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: Math.max(1, Math.floor(state.settings.maxSearchNodes / 2)),
-		maxGridNodes: state.settings.maxSearchNodes,
-		bendPenalty: state.settings.bendPenalty,
-		visited: 0,
-		budgetExceeded: false,
-		obstacles(bounds) {
-			const queried = inflate(bounds, state.settings.clearance + padding);
-			batch.dependencyBounds = batch.dependencyBounds ? union(batch.dependencyBounds, queried) : queried;
-			const ids = state.obstacles.query(queried);
-			metrics$1.obstacleCandidates += ids.length;
-			return ids.filter((id) => !excluded.has(id)).map((id) => inflate(state.obstacles.bounds.get(id), endpoints.has(id) ? 0 : state.settings.clearance + padding));
-		}
-	};
-}
-function pathLength(path) {
-	return pathReservations(path).reduce((sum, segment) => sum + distance(segment.a, segment.b), 0);
-}
-function pathCost(path, context) {
-	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;
-	for (const segment of path.segments) {
-		const bounds = getPathBounds({
-			start,
-			segments: [segment]
-		});
-		if (context.obstacles(bounds).some((rect$1) => segmentCrossesRect(start, segment, rect$1))) return false;
-		start = segment.to;
-	}
-	return true;
-}
-function cubic(start, end) {
-	const amount = Math.max(20, distance(start.point, end.point) / 2), a = vector(start.side), b = vector(end.side);
-	return {
-		start: start.point,
-		segments: [{
-			kind: "cubic",
-			control1: {
-				x: start.point.x + a.x * amount,
-				y: start.point.y + a.y * amount
-			},
-			control2: {
-				x: end.point.x + b.x * amount,
-				y: end.point.y + b.y * amount
-			},
-			to: end.point
-		}]
-	};
-}
-function curve(points, state, context) {
-	const path = pathFromPoints(points);
-	for (let radius = state.settings.radius; radius > .01; radius /= 2) {
-		const rounded = roundCorners(path, { radius });
-		if (safe(rounded, context)) return rounded;
-	}
-	return path;
-}
-/** Elastic string relaxation, constrained by collision checks on each proposed move. */
-function organic(points, state, context) {
-	let samples = [];
-	for (let i = 1; i < points.length; i++) {
-		const a = points[i - 1], b = points[i], count = Math.min(16, Math.max(2, Math.ceil(distance(a, b) / 32)));
-		for (let j = 0; j < count; j++) samples.push({
-			x: a.x + (b.x - a.x) * j / count,
-			y: a.y + (b.y - a.y) * j / count
-		});
-	}
-	samples.push(points.at(-1));
-	for (let iteration = 0; iteration < state.settings.organicIterations; iteration++) {
-		const next = [...samples];
-		for (let i = 1; i < samples.length - 1; i++) {
-			const p = samples[i], a = samples[i - 1], b = samples[i + 1];
-			let x = (a.x + b.x - 2 * p.x) * .2, y = (a.y + b.y - 2 * p.y) * .2;
-			for (const r of context.obstacles(inflate({
-				...p,
-				width: 0,
-				height: 0
-			}, 24))) {
-				const q = {
-					x: Math.max(r.x, Math.min(r.x + r.width, p.x)),
-					y: Math.max(r.y, Math.min(r.y + r.height, p.y))
-				}, d = distance(p, q);
-				if (d > 0 && d < 24) {
-					x += (p.x - q.x) / d * (24 - d) * .2;
-					y += (p.y - q.y) / d * (24 - d) * .2;
-				}
-			}
-			const candidate = {
-				x: p.x + x,
-				y: p.y + y
-			};
-			if (clear(next[i - 1], candidate, context) && clear(candidate, b, context)) next[i] = candidate;
-		}
-		samples = next;
-	}
-	return curve(simplify(samples), state, context);
-}
-function groupPlan(key, state, metrics$1, batch, style) {
-	if (batch.plans.has(key)) return batch.plans.get(key);
-	const edges = [...state.groups.get(key)?.keys() ?? []].map((id) => state.edges.get(id));
-	const nodes = [...new Set(edges.flatMap((e) => [e.sourceId, e.targetId]))];
-	const rectangles = nodes.map((id) => state.nodes.get(id)).map((n) => n && worldRect(n, state)).filter((r) => r !== void 0);
-	if (rectangles.length !== nodes.length || !rectangles.length) {
-		batch.plans.set(key, null);
-		return null;
-	}
-	const common = new Set(ancestors(nodes[0], state));
-	for (const id of nodes.slice(1)) {
-		const set = new Set(ancestors(id, state));
-		for (const parent of common) if (!set.has(parent)) common.delete(parent);
-	}
-	const context = contextFor(state, new Set([...common].map((id) => `n:${id}`)), /* @__PURE__ */ new Set(), metrics$1, batch);
-	const bounds = rectangles.reduce(union), spacing = state.settings.clearance + state.settings.edgeSpacing + 1;
-	let result = null;
-	const targets = edges.map((e) => labelRect(e, state) ?? worldRect(state.nodes.get(e.targetId), state));
-	const sources = edges.map((e) => worldRect(state.nodes.get(e.sourceId), state));
-	const candidates = [];
-	if (new Set(edges.map((e) => e.sourceId)).size === 1) {
-		const source = sources[0], target = targets.reduce(union);
-		const side = sideToward(center(source), center(target)), v = vector(side);
-		const port = edges[0].sourcePort;
-		const named = port === void 0 ? void 0 : state.nodes.get(edges[0].sourceId).ports?.find((p) => p.name === port);
-		const attachment = named && Number.isFinite(named.x) && Number.isFinite(named.y) ? {
-			x: source.x + named.x + (named.width ?? 0) / 2,
-			y: source.y + named.y + (named.height ?? 0) / 2
-		} : anchor(source, side);
-		const start = {
-			x: attachment.x + v.x * spacing,
-			y: attachment.y + v.y * spacing
-		};
-		const end = side === "right" ? {
-			x: target.x - spacing,
-			y: start.y
-		} : side === "left" ? {
-			x: target.x + target.width + spacing,
-			y: start.y
-		} : side === "bottom" ? {
-			x: start.x,
-			y: target.y - spacing
-		} : {
-			x: start.x,
-			y: target.y + target.height + spacing
-		};
-		if ((end.x - start.x) * v.x + (end.y - start.y) * v.y > 1e-8) candidates.push({
-			start,
-			end
-		});
-	}
-	const xs = [bounds.x - spacing, bounds.x + bounds.width + spacing];
-	const ys = [bounds.y - spacing, bounds.y + bounds.height + spacing];
-	const exterior = [...xs.map((x) => ({
-		start: {
-			x,
-			y: ys[0]
-		},
-		end: {
-			x,
-			y: ys[1]
-		}
-	})), ...ys.map((y) => ({
-		start: {
-			x: xs[0],
-			y
-		},
-		end: {
-			x: xs[1],
-			y
-		}
-	}))].flatMap((p) => [p, {
-		start: p.end,
-		end: p.start
-	}]);
-	const score = (p) => distance(p.start, p.end) + sources.reduce((sum, r) => sum + distance(center(r), p.start), 0) + targets.reduce((sum, r) => sum + distance(p.end, center(r)), 0);
-	exterior.sort((a, b) => score(a) - score(b));
-	candidates.push(...exterior);
-	for (const candidate of candidates) {
-		const points = findPath(candidate.start, candidate.end, "orthogonal", context);
-		if (!points) continue;
-		result = {
-			id: `trunk:${key}`,
-			path: style === "bundle" ? curve(points, state, context) : pathFromPoints(points)
-		};
-		break;
-	}
-	metrics$1.searchNodes += context.visited;
-	batch.plans.set(key, result);
-	return result;
-}
-function routeEdge(edge, state, style, metrics$1, batch) {
-	const config = state.settings, perEdge = config.edges[edge.id] ?? {}, diagnostics = [];
-	const report = (code, message) => {
-		if (!diagnostics.some((d) => d.code === code)) diagnostics.push({
-			code,
-			message,
-			edgeId: edge.id
-		});
-	};
-	const sourceNode = state.nodes.get(edge.sourceId), targetNode = state.nodes.get(edge.targetId);
-	const sourceRect = sourceNode && worldRect(sourceNode, state), targetRect = targetNode && worldRect(targetNode, state);
-	if (!sourceRect || !targetRect) report("MISSING_GEOMETRY", "Missing endpoint geometry; rendered a fallback connection");
-	const sourceBounds = sourceRect ?? {
-		x: 0,
-		y: 0,
-		width: 0,
-		height: 0
-	}, targetBounds = targetRect ?? {
-		x: sourceBounds.x + 40,
-		y: sourceBounds.y + 40,
-		width: 0,
-		height: 0
-	};
-	const loop = edge.sourceId === edge.targetId;
-	const group = groupKey(edge, style, config), peers = group ? [...state.groups.get(group)?.keys() ?? []] : [];
-	const grouped = peers.length > 1 && [
-		"bus",
-		"bundle",
-		"fan"
-	].includes(style);
-	const lane = !grouped && peers.length > 1 ? peers.length - 1 - peers.indexOf(edge.id) : 0;
-	function terminal(source$1) {
-		const node$1 = source$1 ? sourceNode : targetNode, outer = source$1 ? sourceBounds : targetBounds, attachment = source$1 ? perEdge.sourceAttachment : perEdge.targetAttachment, bounds = attachment ? {
-			...attachment.bounds,
-			x: outer.x + attachment.bounds.x,
-			y: outer.y + attachment.bounds.y
-		} : outer, other = source$1 ? targetBounds : sourceBounds;
-		const name = source$1 ? edge.sourcePort : edge.targetPort;
-		let side = (source$1 ? perEdge.sourceSide : perEdge.targetSide) ?? (loop ? source$1 ? "right" : "top" : sideToward(center(bounds), center(other)));
-		let point = anchor(bounds, side);
-		if (attachment) {
-			const toward = labelRect(edge, state) ?? other;
-			side = (source$1 ? perEdge.sourceSide : perEdge.targetSide) ?? sideToward(center(bounds), center(toward));
-			point = anchor(bounds, side);
-			const margin = Math.min(config.clearance, Math.min(bounds.width, bounds.height) / 2);
-			if (side === "left" || side === "right") point = {
-				...point,
-				y: Math.max(bounds.y + margin, Math.min(bounds.y + bounds.height - margin, center(toward).y))
-			};
-			else point = {
-				...point,
-				x: Math.max(bounds.x + margin, Math.min(bounds.x + bounds.width - margin, center(toward).x))
-			};
-		}
-		if (!attachment && name === void 0 && ![
-			"bus",
-			"fan",
-			"bundle"
-		].includes(style) && !loop) {
-			const nodeId = source$1 ? edge.sourceId : edge.targetId;
-			const adjacent = [...state.incident.get(nodeId)?.keys() ?? []].filter((id) => {
-				const e = state.edges.get(id);
-				if (e.sourceId === e.targetId) return false;
-				const from = e.sourceId === nodeId;
-				if ((from ? e.sourcePort : e.targetPort) !== void 0) return false;
-				const otherNode = state.nodes.get(from ? e.targetId : e.sourceId);
-				const rect$1 = otherNode && worldRect(otherNode, state);
-				if (!rect$1) return false;
-				return ((from ? config.edges[id]?.sourceSide : config.edges[id]?.targetSide) ?? sideToward(center(bounds), center(rect$1))) === side;
-			});
-			const horizontal = side === "left" || side === "right";
-			const projected = (id) => {
-				const e = state.edges.get(id);
-				const p = center(worldRect(state.nodes.get(e.sourceId === nodeId ? e.targetId : e.sourceId), state));
-				return horizontal ? p.y : p.x;
-			};
-			adjacent.sort((a, b) => projected(a) - projected(b) || (a < b ? -1 : a > b ? 1 : 0));
-			const span = horizontal ? bounds.height : bounds.width;
-			const spacing = Math.min(config.edgeSpacing, span * .7 / Math.max(1, adjacent.length - 1));
-			const shift = (adjacent.indexOf(edge.id) - (adjacent.length - 1) / 2) * spacing;
-			point = horizontal ? {
-				x: point.x,
-				y: point.y + shift
-			} : {
-				x: point.x + shift,
-				y: point.y
-			};
-		}
-		if (name !== void 0) {
-			const port = node$1?.ports?.find((p) => p.name === name);
-			if (port && Number.isFinite(port.x) && Number.isFinite(port.y) && Number.isFinite(port.width ?? 0) && Number.isFinite(port.height ?? 0)) {
-				point = {
-					x: outer.x + port.x + (port.width ?? 0) / 2,
-					y: outer.y + port.y + (port.height ?? 0) / 2
-				};
-				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" ? {
-				left: "right",
-				right: "left",
-				top: "bottom",
-				bottom: "top"
-			}[side] : side,
-			ref: {
-				kind: "node",
-				nodeId: source$1 ? edge.sourceId : edge.targetId,
-				...name === void 0 ? {} : { port: name }
-			}
-		};
-	}
-	const source = terminal(true), target = terminal(false), label = labelRect(edge, state);
-	const excluded = new Set([...ancestors(edge.sourceId, state), ...ancestors(edge.targetId, state)].filter((id) => id !== edge.sourceId && id !== edge.targetId).map((id) => `n:${id}`));
-	if (perEdge.sourceAttachment !== void 0) excluded.add(`n:${edge.sourceId}`);
-	if (perEdge.targetAttachment !== void 0) excluded.add(`n:${edge.targetId}`);
-	const context = contextFor(state, excluded, new Set([
-		`n:${edge.sourceId}`,
-		`n:${edge.targetId}`,
-		`e:${edge.id}`
-	]), metrics$1, batch, lane * config.edgeSpacing);
-	const searchContext = [
-		"curved",
-		"organic",
-		"bundle",
-		"bezier"
-	].includes(style) ? contextFor(state, excluded, new Set([
-		`n:${edge.sourceId}`,
-		`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 {
-			x: point.x,
-			y: toward.y
-		};
-		if ((side === "top" || side === "bottom") && toward.x > label.x && toward.x < label.x + label.width) return {
-			x: toward.x,
-			y: point.y
-		};
-		return point;
-	};
-	const firstTarget = label ? {
-		point: labelAnchor(source.point),
-		side: sideToward(center(label), source.point),
-		ref: {
-			kind: "label",
-			edgeId: edge.id
-		}
-	} : target;
-	const lastSource = label ? {
-		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
-		}
-	} : void 0;
-	metrics$1.routedEdges++;
-	const sections = [];
-	const stub = (t) => {
-		if (t.ref.kind === "junction") return t.point;
-		const v = vector(t.side), length = config.clearance + 1 + (!grouped && peers.length > 1 ? peers.indexOf(edge.id) : 0) * config.edgeSpacing;
-		return {
-			x: t.point.x + v.x * length,
-			y: t.point.y + v.y * length
-		};
-	};
-	function connection(a, b, via$1 = []) {
-		let path, preferred;
-		if (distance(a.point, b.point) < 1e-8 && !via$1.length) {
-			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 + v.x * gap,
-					y: a.point.y + v.y * gap
-				},
-				b.point
-			]);
-		}
-		if (loop && !via$1.length && a.ref.kind === "node" && b.ref.kind === "node" && a.side === "right" && b.side === "top") {
-			const r = inflate(sourceBounds, config.clearance + config.edgeSpacing + 1);
-			const points = [
-				a.point,
-				{
-					x: r.x + r.width,
-					y: a.point.y
-				},
-				{
-					x: r.x + r.width,
-					y: r.y
-				},
-				{
-					x: b.point.x,
-					y: r.y
-				},
-				b.point
-			];
-			const loopPath = pathFromPoints(points);
-			if (safe(loopPath, context)) return [
-				"curved",
-				"bezier",
-				"bundle"
-			].includes(style) ? curve(points, state, context) : style === "organic" ? organic(points, state, context) : loopPath;
-		}
-		if (style === "straight" && !via$1.length && !loop) path = pathFromPoints([a.point, b.point]);
-		else if (style === "bezier" && !via$1.length && !loop) {
-			const direct = cubic(a, b);
-			if (safe(direct, context)) {
-				if (pathCost(direct, context) === pathLength(direct)) return direct;
-				preferred = direct;
-			}
-		}
-		if (!path) {
-			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 = 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;
-				if (base && base.length > 2) waypoints.push(mid);
-				for (const sign of base && base.length > 2 ? [] : [orientation, -orientation]) {
-					const lane$1 = {
-						x: mid.x - (end.y - start.y) / d * config.edgeSpacing * rank * sign,
-						y: mid.y + (end.x - start.x) / d * config.edgeSpacing * rank * sign
-					};
-					if (clear(lane$1, lane$1, context)) {
-						waypoints.push(lane$1);
-						break;
-					}
-				}
-				if (waypoints.length === via$1.length) report("CONSTRAINT_VIOLATION", "No clear parallel lane; rendered an individual route");
-			}
-			const points = [a.point], anchors = [
-				start,
-				...waypoints,
-				end
-			];
-			const searchStyle = style === "polyline" || style === "organic" || style === "parallel" ? "polyline" : style === "octilinear" ? "octilinear" : "orthogonal";
-			let ok = clear(a.point, start, context) && clear(end, b.point, context);
-			for (let i = 1; ok && i < anchors.length; i++) {
-				const directions = {
-					incoming: i === 1 && a.ref.kind !== "junction" ? vector(a.side) : void 0,
-					outgoing: i === anchors.length - 1 ? {
-						x: -vector(b.side).x,
-						y: -vector(b.side).y
-					} : void 0
-				};
-				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 = 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 (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;
-			}
-		}
-		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);
-			return pathFromPoints([
-				a.point,
-				{
-					x: r.x + r.width,
-					y: a.point.y
-				},
-				{
-					x: r.x + r.width,
-					y: r.y
-				},
-				{
-					x: b.point.x,
-					y: r.y
-				},
-				b.point
-			]);
-		}
-		return pathFromPoints([
-			a.point,
-			...via$1,
-			b.point
-		]);
-	}
-	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) {
-		const start = plan.path.start, end = plan.path.segments.at(-1)?.to ?? start;
-		const j0 = {
-			point: start,
-			side: sideToward(start, source.point),
-			ref: {
-				kind: "junction",
-				id: `${plan.id}:start`
-			}
-		};
-		const j1 = {
-			point: end,
-			side: sideToward(end, firstTarget.point),
-			ref: {
-				kind: "junction",
-				id: `${plan.id}:end`
-			}
-		};
-		sections.push({
-			id: `${edge.id}:source`,
-			from: source.ref,
-			to: j0.ref,
-			path: connection(source, j0, via)
-		}, {
-			id: `${edge.id}:trunk`,
-			sharedId: plan.id,
-			from: j0.ref,
-			to: j1.ref,
-			path: plan.path
-		}, {
-			id: `${edge.id}:target`,
-			from: j1.ref,
-			to: firstTarget.ref,
-			path: connection(j1, firstTarget)
-		});
-	} else sections.push({
-		id: `${edge.id}:0`,
-		from: source.ref,
-		to: firstTarget.ref,
-		path: connection(source, firstTarget, via)
-	});
-	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 {
-		edgeId: edge.id,
-		sections,
-		status: diagnostics.length ? "fallback" : "routed",
-		diagnostics
-	};
-}
-function routeBounds(route) {
-	return route.sections.map((s) => getPathBounds(s.path)).reduce(union);
-}
-
-//#endregion
-//#region src/routing/engine.ts
-const STATE = Symbol("routingState");
-const metrics = () => ({
-	routedEdges: 0,
-	reusedEdges: 0,
-	affectedEdges: 0,
-	searchNodes: 0,
-	obstacleCandidates: 0
-});
-function snapshot(state, style, revision, counts) {
-	return Object.freeze({
-		strategy: style,
-		revision,
-		routes: state.routes,
-		metrics: Object.freeze(counts),
-		[STATE]: Object.freeze(state)
-	});
-}
-function edgeMembership(state, edge, style, add) {
-	let incident = state.incident, groups = state.groups;
-	for (const id of new Set([edge.sourceId, edge.targetId])) incident = members(incident, id, edge.id, add);
-	const key = groupKey(edge, style, state.settings);
-	if (key !== void 0) groups = members(groups, key, edge.id, add);
-	return {
-		...state,
-		incident,
-		groups
-	};
-}
-function initialState(graph, config, style) {
-	let nodes = new PersistentMap(), edges = new PersistentMap(), children = new PersistentMap();
-	for (const n of graph.nodes) {
-		if (nodes.has(n.id)) throw new Error(`Duplicate routing node ${n.id}`);
-		nodes = nodes.set(n.id, nodeGeometry(n));
-		if (n.parentId != null) children = members(children, n.parentId, n.id, true);
-	}
-	for (const e of graph.edges) {
-		if (edges.has(e.id)) throw new Error(`Duplicate routing edge ${e.id}`);
-		edges = edges.set(e.id, edgeGeometry(e));
-	}
-	let state = {
-		graphId: graph.id,
-		direction: graph.direction,
-		settings: settings(config),
-		nodes,
-		edges,
-		children,
-		incident: new PersistentMap(),
-		groups: new PersistentMap(),
-		obstacles: new SpatialIndex(),
-		routeIndex: new SpatialIndex(),
-		routes: new PersistentMap()
-	};
-	for (const [id, n] of nodes) state = {
-		...state,
-		obstacles: state.obstacles.set(`n:${id}`, worldRect(n, state))
-	};
-	for (const [id, e] of edges) {
-		state = edgeMembership(state, e, style, true);
-		state = {
-			...state,
-			obstacles: state.obstacles.set(`e:${id}`, labelRect(e, state))
-		};
-	}
-	return state;
-}
-function calculate(state, style, affected, counts, previous) {
-	let routes = state.routes, routeIndex = state.routeIndex;
-	const input = {
-		nodes: state.nodes,
-		incident: state.incident,
-		edges: state.edges,
-		groups: state.groups,
-		obstacles: state.obstacles,
-		settings: state.settings
-	};
-	const patches = [], batch = { plans: /* @__PURE__ */ new Map() };
-	const pending = new Set(affected);
-	const processed = /* @__PURE__ */ new Set();
-	const priorities = /* @__PURE__ */ new Map();
-	const priority = (id) => {
-		let result = priorities.get(id);
-		if (result !== void 0) return result;
-		const edge = state.edges.get(id) ?? previous?.edges.get(id);
-		const key = edge && groupKey(edge, style, state.settings);
-		result = key ? (state.edges.has(id) ? state.groups : previous?.groups)?.get(key)?.keys().next().value ?? id : id;
-		priorities.set(id, result);
-		return result;
-	};
-	const later = (candidate, id) => priority(candidate) > priority(id) || priority(candidate) === priority(id) && candidate > id;
-	const invalidate = (id, bounds) => {
-		for (const candidate of routeIndex.query(inflate(bounds, state.settings.edgeSpacing))) {
-			if (!later(candidate, id) || processed.has(candidate)) continue;
-			pending.add(candidate);
-			const edge = state.edges.get(candidate);
-			const key = edge && groupKey(edge, style, state.settings);
-			if (key) {
-				for (const peer of state.groups.get(key)?.keys() ?? []) if (!processed.has(peer)) pending.add(peer);
-			}
-		}
-	};
-	if (previous) for (const id of affected) {
-		const edge = previous.edges.get(id);
-		if (!edge) continue;
-		const key = groupKey(edge, style, previous.settings);
-		if ((key ? previous.groups.get(key)?.keys().next().value ?? id : id) === priority(id)) continue;
-		const oldRoute = previous.routes.get(id);
-		if (oldRoute) for (const candidate of previous.routeIndex.query(inflate(routeBounds(oldRoute), state.settings.edgeSpacing))) {
-			pending.add(candidate);
-			const current = state.edges.get(candidate);
-			const group = current && groupKey(current, style, state.settings);
-			if (group) for (const peer of state.groups.get(group)?.keys() ?? []) pending.add(peer);
-		}
-	}
-	const segmentCache = /* @__PURE__ */ new Map();
-	while (pending.size) {
-		const id = [...pending].sort((a, b) => (priority(a) < priority(b) ? -1 : priority(a) > priority(b) ? 1 : 0) || (a < b ? -1 : a > b ? 1 : 0))[0];
-		pending.delete(id);
-		processed.add(id);
-		const edge = state.edges.get(id), oldRoute = previous?.routes.get(id);
-		if (!edge) {
-			if (routes.has(id)) {
-				invalidate(id, routeBounds(routes.get(id)));
-				routes = routes.delete(id);
-				routeIndex = routeIndex.set(id);
-				patches.push({
-					op: "delete",
-					edgeId: id
-				});
-			}
-			continue;
-		}
-		batch.dependencyBounds = void 0;
-		const query = (bounds) => {
-			const area = inflate(bounds, state.settings.edgeSpacing);
-			batch.dependencyBounds = batch.dependencyBounds ? union(batch.dependencyBounds, area) : area;
-			const result = [];
-			const shared = /* @__PURE__ */ new Set();
-			for (const otherId of routeIndex.query(area)) {
-				if (!later(id, otherId)) continue;
-				const other = state.edges.get(otherId), route$1 = routes.get(otherId);
-				if (!other || !route$1) continue;
-				if ([
-					"bus",
-					"fan",
-					"bundle"
-				].includes(style) && groupKey(other, style, state.settings) === groupKey(edge, style, state.settings)) continue;
-				const terminalRegions = [edge.sourceId, edge.targetId].filter((node$1) => node$1 === other.sourceId || node$1 === other.targetId).flatMap((id$1) => {
-					const node$1 = state.nodes.get(id$1), bounds$1 = node$1 && worldRect(node$1, state);
-					return bounds$1 ? [inflate(bounds$1, state.settings.clearance + state.settings.edgeSpacing * 2 + 1)] : [];
-				});
-				let segments = segmentCache.get(otherId);
-				if (!segments) {
-					segments = reservations(route$1);
-					segmentCache.set(otherId, segments);
-				}
-				const outside = terminalRegions.reduce((segments$1, rect$1) => segments$1.flatMap((segment) => outsideTerminal(segment, rect$1)), segments);
-				for (const segment of outside) {
-					if (!intersects(segmentBounds(segment.a, segment.b), area)) continue;
-					if (segment.sharedId !== void 0) {
-						const key = JSON.stringify([
-							segment.sharedId,
-							segment.a,
-							segment.b
-						]);
-						if (shared.has(key)) continue;
-						shared.add(key);
-					}
-					result.push(segment);
-				}
-			}
-			return result;
-		};
-		batch.edgeCost = (a, b) => query(segmentBounds(a, b)).reduce((cost, other) => cost + conflictCost(a, b, other, state.settings), 0);
-		batch.conflicts = (a, b) => query(segmentBounds(a, b)).some((other) => conflictCost(a, b, other, {
-			...state.settings,
-			crossingPenalty: 1,
-			overlapPenalty: 1
-		}) > 1e-8);
-		batch.guides = (bounds) => query(bounds).map((segment) => reservationBounds(segment, state.settings.edgeSpacing));
-		let route = routeEdge(edge, input, style, counts, batch);
-		if (oldRoute && JSON.stringify(oldRoute) === JSON.stringify(route)) route = oldRoute;
-		const drawnBounds = routeBounds(route);
-		if (route !== oldRoute) {
-			if (oldRoute) invalidate(id, routeBounds(oldRoute));
-			invalidate(id, drawnBounds);
-		}
-		routeIndex = routeIndex.set(id, batch.dependencyBounds ? union(batch.dependencyBounds, drawnBounds) : drawnBounds);
-		if (route === oldRoute) continue;
-		route = freeze(route);
-		routes = routes.set(id, route);
-		segmentCache.delete(id);
-		patches.push({
-			op: "set",
-			edgeId: id,
-			route
-		});
-	}
-	counts.affectedEdges = processed.size;
-	counts.reusedEdges = Math.max(0, state.routes.size - [...processed].filter((id) => state.routes.has(id)).length);
-	patches.sort((a, b) => a.edgeId < b.edgeId ? -1 : a.edgeId > b.edgeId ? 1 : 0);
-	return {
-		state: {
-			...state,
-			routes,
-			routeIndex
-		},
-		patches
-	};
-}
-function descendants(state, ids) {
-	const queue = [...ids];
-	for (let i = 0; i < queue.length; i++) for (const child of state.children.get(queue[i])?.keys() ?? []) if (!ids.has(child)) {
-		ids.add(child);
-		queue.push(child);
-	}
-}
-function verifyOld(record, old, id) {
-	if (!record) throw new Error(`Routing diff updates missing entity ${id}`);
-	for (const [key, value] of Object.entries(old)) if (key in record && JSON.stringify(record[key]) !== JSON.stringify(key === "ports" ? nodeGeometry({
-		id,
-		ports: value
-	}).ports : value)) throw new Error(`Stale routing diff for ${id}.${key}`);
-}
-function updateState(graph, prior, diff, style, config) {
-	if (graph.id !== prior.graphId) throw new Error("A routing snapshot belongs to a different graph");
-	const candidateSettings = config === void 0 ? prior.settings : settings(config);
-	const nextSettings = JSON.stringify(candidateSettings) === JSON.stringify(prior.settings) ? prior.settings : candidateSettings;
-	const settingsChanged = JSON.stringify(nextSettings) !== JSON.stringify(prior.settings) || prior.direction !== graph.direction;
-	let state = {
-		...prior,
-		settings: nextSettings,
-		direction: graph.direction
-	};
-	const changedNodes = /* @__PURE__ */ new Set(), changedEdges = /* @__PURE__ */ new Set(), affected = /* @__PURE__ */ new Set();
-	for (const n of diff.nodes.removed) {
-		if (!state.nodes.has(n.id)) throw new Error(`Routing diff removes missing node ${n.id}`);
-		const old = state.nodes.get(n.id);
-		if (old.parentId != null) state = {
-			...state,
-			children: members(state.children, old.parentId, n.id, false)
-		};
-		state = {
-			...state,
-			nodes: state.nodes.delete(n.id)
-		};
-		changedNodes.add(n.id);
-	}
-	for (const n of diff.nodes.added) {
-		if (state.nodes.has(n.id)) throw new Error(`Routing diff adds existing node ${n.id}`);
-		state = {
-			...state,
-			nodes: state.nodes.set(n.id, nodeGeometry(n))
-		};
-		if (n.parentId != null) state = {
-			...state,
-			children: members(state.children, n.parentId, n.id, true)
-		};
-		changedNodes.add(n.id);
-	}
-	for (const change of diff.nodes.updated) {
-		const old = state.nodes.get(change.id);
-		verifyOld(old, change.old, change.id);
-		const next = nodeGeometry({
-			...old,
-			...change.new,
-			id: change.id
-		});
-		if (JSON.stringify(old) === JSON.stringify(next)) continue;
-		if (old.parentId != null) state = {
-			...state,
-			children: members(state.children, old.parentId, change.id, false)
-		};
-		if (next.parentId != null) state = {
-			...state,
-			children: members(state.children, next.parentId, change.id, true)
-		};
-		state = {
-			...state,
-			nodes: state.nodes.set(change.id, next)
-		};
-		changedNodes.add(change.id);
-	}
-	for (const e of diff.edges.removed) {
-		const old = state.edges.get(e.id);
-		if (!old) throw new Error(`Routing diff removes missing edge ${e.id}`);
-		state = edgeMembership(state, old, style, false);
-		state = {
-			...state,
-			edges: state.edges.delete(e.id)
-		};
-		changedEdges.add(e.id);
-	}
-	for (const e of diff.edges.added) {
-		if (state.edges.has(e.id)) throw new Error(`Routing diff adds existing edge ${e.id}`);
-		const next = edgeGeometry(e);
-		state = {
-			...state,
-			edges: state.edges.set(e.id, next)
-		};
-		state = edgeMembership(state, next, style, true);
-		changedEdges.add(e.id);
-	}
-	for (const change of diff.edges.updated) {
-		const old = state.edges.get(change.id);
-		verifyOld(old, change.old, change.id);
-		const next = edgeGeometry({
-			...old,
-			...change.new,
-			id: change.id
-		});
-		if (JSON.stringify(old) === JSON.stringify(next)) continue;
-		state = edgeMembership(state, old, style, false);
-		state = {
-			...state,
-			edges: state.edges.set(change.id, next)
-		};
-		state = edgeMembership(state, next, style, true);
-		changedEdges.add(change.id);
-	}
-	if (settingsChanged) {
-		state = {
-			...state,
-			groups: new PersistentMap()
-		};
-		for (const [id, e] of state.edges) {
-			const key = groupKey(e, style, nextSettings);
-			if (key !== void 0) state = {
-				...state,
-				groups: members(state.groups, key, id, true)
-			};
-			changedEdges.add(id);
-		}
-		for (const id of state.nodes.keys()) changedNodes.add(id);
-		for (const id of prior.routes.keys()) affected.add(id);
-	}
-	descendants(prior, changedNodes);
-	descendants(state, changedNodes);
-	function invalidateObstacle(id, bounds) {
-		const old = prior.obstacles.bounds.get(id);
-		for (const rect$1 of [old, bounds]) if (rect$1) for (const edgeId of prior.routeIndex.query(inflate(rect$1, Math.max(prior.settings.clearance, nextSettings.clearance)))) affected.add(edgeId);
-		state = {
-			...state,
-			obstacles: state.obstacles.set(id, bounds)
-		};
-	}
-	for (const id of changedNodes) {
-		const node$1 = state.nodes.get(id);
-		invalidateObstacle(`n:${id}`, node$1 && worldRect(node$1, state));
-		for (const index of [prior.incident, state.incident]) for (const edgeId of index.get(id)?.keys() ?? []) changedEdges.add(edgeId);
-	}
-	for (const id of changedEdges) {
-		const edge = state.edges.get(id);
-		invalidateObstacle(`e:${id}`, edge && labelRect(edge, state));
-		affected.add(id);
-	}
-	if (![
-		"bus",
-		"fan",
-		"bundle"
-	].includes(style)) for (const id of changedEdges) {
-		const before = prior.edges.get(id), after = state.edges.get(id);
-		if (!(!before || !after || before.sourceId !== after.sourceId || before.targetId !== after.targetId || before.sourcePort !== after.sourcePort || before.targetPort !== after.targetPort || [
-			before.sourceId,
-			before.targetId,
-			after.sourceId,
-			after.targetId
-		].some((nodeId) => changedNodes.has(nodeId)))) continue;
-		for (const version of [prior, state]) {
-			const edge = version.edges.get(id);
-			if (!edge) continue;
-			for (const nodeId of [edge.sourceId, edge.targetId]) for (const peer of version.incident.get(nodeId)?.keys() ?? []) affected.add(peer);
-		}
-	}
-	for (const id of [...affected]) for (const version of [prior, state]) {
-		const edge = version.edges.get(id);
-		if (!edge) continue;
-		const key = groupKey(edge, style, version.settings);
-		if (key !== void 0) for (const peer of version.groups.get(key)?.keys() ?? []) affected.add(peer);
-	}
-	return {
-		state,
-		affected
-	};
-}
-function createRoutingStrategy(id) {
-	return Object.freeze({
-		id,
-		route(graph, config = {}) {
-			const initial = initialState(graph, config, id), counts = metrics();
-			return snapshot(calculate(initial, id, new Set(initial.edges.keys()), counts).state, id, 0, counts);
-		},
-		update(graph, previous, diff, config) {
-			const prior = previous[STATE];
-			if (!prior || previous.strategy !== id) throw new Error("Update requires a snapshot from the same routing strategy; route again after serialization or strategy changes");
-			const { state, affected } = updateState(graph, prior, diff, id, config), counts = metrics();
-			const result = calculate(state, id, affected, counts, prior);
-			return Object.freeze({
-				base: previous,
-				snapshot: snapshot(result.state, id, previous.revision + 1, counts),
-				patches: Object.freeze(result.patches.map((patch) => Object.freeze(patch)))
-			});
-		}
-	});
-}
-function applyRoutePatches(routes, patches) {
-	let result = routes instanceof PersistentMap ? routes : new PersistentMap();
-	if (!(routes instanceof PersistentMap)) for (const [id, route] of routes) result = result.set(id, route);
-	for (const patch of patches) result = patch.op === "set" ? result.set(patch.edgeId, patch.route) : result.delete(patch.edgeId);
-	return result;
-}
-
-//#endregion
-//#region src/routing/index.ts
-const straightRouting = createRoutingStrategy("straight");
-const bezierRouting = createRoutingStrategy("bezier");
-const orthogonalRouting = createRoutingStrategy("orthogonal");
-const polylineRouting = createRoutingStrategy("polyline");
-const octilinearRouting = createRoutingStrategy("octilinear");
-const curvedRouting = createRoutingStrategy("curved");
-const organicRouting = createRoutingStrategy("organic");
-const parallelRouting = createRoutingStrategy("parallel");
-const selfLoopRouting = createRoutingStrategy("self-loop");
-const fanRouting = createRoutingStrategy("fan");
-const busRouting = createRoutingStrategy("bus");
-const bundleRouting = createRoutingStrategy("bundle");
-const routingStrategies = Object.freeze({
-	straight: straightRouting,
-	bezier: bezierRouting,
-	orthogonal: orthogonalRouting,
-	polyline: polylineRouting,
-	octilinear: octilinearRouting,
-	curved: curvedRouting,
-	organic: organicRouting,
-	parallel: parallelRouting,
-	"self-loop": selfLoopRouting,
-	fan: fanRouting,
-	bus: busRouting,
-	bundle: bundleRouting
-});
-
-//#endregion
-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 };