@mark1russell7/highways 0.1.3 → 0.1.4

package/build/index.js

@@ -702,6 +702,32 @@ function manyGroupsBoard() {
 	for (let n = 0; n < groups.length * 3; n++) b.link(pick(groups[Math.floor(R() * groups.length)]), pick(groups[Math.floor(R() * groups.length)]));
 	return b.graph();
 }
+/**
+* This function makes the far view of a board after a host layout packs it.
+* The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+* The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+* The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+*
+* The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+*/
+function packedGridBoard() {
+	const R = rng(11);
+	const b = new Board();
+	const cols = 12;
+	const rows = 8;
+	const w = 140;
+	const h = 90;
+	const id = (r, c) => `p${r}-${c}`;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * w, r * h, w, h);
+	const step = () => Math.floor(R() * 5) - 2;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const rr = Math.max(0, Math.min(7, r + step()));
+		const cc = Math.max(0, Math.min(11, c + step()));
+		b.link(id(r, c), id(rr, cc));
+	}
+	for (let n = 0; n < 48; n++) b.link(id(Math.floor(R() * rows), Math.floor(R() * cols)), id(Math.floor(R() * rows), Math.floor(R() * cols)));
+	return b.graph();
+}
 /** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
 const CASES = [
 	{
@@ -888,207 +914,786 @@ function roundCorners(p, radius, steps = 4) {
 	out.push(p[p.length - 1]);
 	return out;
 }
-// src/visibility.ts
-/** The nodes as obstacles, with a grid for fast tests. */
-var Obstacles = class {
-	#grid;
-	/** This constructor indexes the boxes of the nodes. */
-	constructor(nodes, cell) {
-		this.#grid = new Grid(cell);
-		for (const n of nodes) this.#grid.add(n, n.box);
-	}
-	/** This method tells if the segment `ab` stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
-	clear(a, b, pad, skip) {
-		return this.hit(a, b, pad, skip) === void 0;
-	}
-	/**
-	* This method gives a node whose box, made larger by `pad`, the segment `ab` goes into, or `undefined` when the segment is clear.
-	* The nodes in `skip` do not count. The test stops at the first such node.
-	*/
-	hit(a, b, pad, skip) {
-		let found;
-		this.#grid.someSegment(a, b, pad, (n) => {
-			if (skip?.has(n) || !hits(a, b, n, pad)) return false;
-			found = n;
-			return true;
-		});
-		return found;
-	}
-	/** This method tells if the polyline stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
-	clearPath(p, pad, skip) {
-		for (let i = 1; i < p.length; i++) if (!this.clear(p[i - 1], p[i], pad, skip)) return false;
-		return true;
-	}
-	/** This method gives each node whose bucket the box touches to `visit`. A node can be outside the box. */
-	query(box, visit) {
-		this.#grid.query(box, visit);
-	}
-	/** This method tells if the point is inside a box, made larger by `pad`. The node `skip` does not count. */
-	inside(p, pad, skip) {
-		let hit = false;
-		this.#grid.query({
-			x: p.x,
-			y: p.y,
-			w: 0,
-			h: 0
-		}, (n) => {
-			if (!hit && n !== skip) {
-				const b = n.box;
-				hit = p.x > b.x - pad && p.x < b.x + b.w + pad && p.y > b.y - pad && p.y < b.y + b.h + pad;
-			}
-		});
-		return hit;
+// src/curves/model.ts
+/** The curve types, in the order of the benchmark. */
+const CURVE_TYPES = [
+	"straight",
+	"rounded",
+	"spline",
+	"arc"
+];
+/** This function gives the points of a polyline without the points that are nearer than `eps` to the point before them. */
+function distinctPoints(points, eps = 1e-9) {
+	const out = [];
+	for (const p of points) {
+		const q = out[out.length - 1];
+		if (q === void 0 || Math.hypot(p.x - q.x, p.y - q.y) > eps) out.push(p);
 	}
-};
-/** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
-function hits(a, b, n, pad) {
-	const x = n.box;
-	return segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad);
+	return out;
 }
+// src/bench/properties.ts
+/** The tolerance of the hard rules, in units of the plane. */
+const TOLERANCE = .5;
 /**
-* A sparse visibility graph. Its vertices are the corners of the boxes, made larger by `margin`.
-* Each corner links to its `k` nearest corners that it can see. A lattice of free points links the groups of nodes.
-* A path goes from corner to corner around the boxes.
-* The obstacle test uses half of the margin, so a path keeps a clearance of at least half of the margin.
+* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
+* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
+* Each link of a level starts on the box of its source and ends on the box of its target.
+*
+* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
+* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
+* The function gives at most `limit` violations.
 */
-var CornerGraph = class {
-	points = [];
-	#adj = [];
-	#len = [];
-	#obstacles;
-	#pointGrid;
-	#cell;
-	#pad;
-	#k;
-	#g = /* @__PURE__ */ new Float64Array(0);
-	#parent = /* @__PURE__ */ new Int32Array(0);
-	#open = /* @__PURE__ */ new Int32Array(0);
-	#closed = /* @__PURE__ */ new Int32Array(0);
-	#stamp = 0;
-	#buckets = /* @__PURE__ */ new Map();
-	#dist = /* @__PURE__ */ new Float64Array(0);
-	#near = new MinHeap();
-	#endCache = /* @__PURE__ */ new Map();
-	#fewCache = /* @__PURE__ */ new Map();
-	#part;
-	/** This constructor makes the graph of the nodes. */
-	constructor(nodes, obstacles, options) {
-		this.#obstacles = obstacles;
-		this.#pad = options.margin / 2;
-		this.#k = options.k;
-		let size = 0;
-		for (const n of nodes) size += (n.box.w + n.box.h) / 2;
-		this.#cell = Math.max(1, size / Math.max(1, nodes.length) + 2 * options.margin);
-		this.#pointGrid = new Grid(this.#cell);
-		for (const n of nodes) {
-			const b = inflate(n.box, options.margin);
-			for (const c of [
-				{
-					x: b.x,
-					y: b.y
-				},
-				{
-					x: b.x + b.w,
-					y: b.y
-				},
-				{
-					x: b.x + b.w,
-					y: b.y + b.h
-				},
-				{
-					x: b.x,
-					y: b.y + b.h
-				}
-			]) if (!obstacles.inside(c, this.#pad)) this.#addPoint(c);
+function checkProperties(graph, result, limit = 100) {
+	const out = [];
+	const add = (v) => {
+		out.push(v);
+		return out.length >= limit;
+	};
+	const byId = nodeIndex(graph);
+	const grid = new Grid(180);
+	for (const n of graph.nodes) grid.add(n, n.box);
+	const routes = /* @__PURE__ */ new Map();
+	for (const r of result.routes) routes.set(r.edge, r);
+	for (const e of graph.edges) {
+		const r = routes.get(e.id);
+		const s = byId.get(e.source.node);
+		const t = byId.get(e.target.node);
+		if (!s || !t) continue;
+		if (!r || r.points.length < 2) {
+			if (add({
+				rule: "complete",
+				edge: e.id,
+				detail: "no route"
+			})) return out;
+			continue;
 		}
-		const spacing = (options.lattice ?? 3) * this.#cell;
-		if (spacing > 0 && nodes.length > 0) {
-			let x0 = Infinity;
-			let y0 = Infinity;
-			let x1 = -Infinity;
-			let y1 = -Infinity;
-			for (const n of nodes) {
-				x0 = Math.min(x0, n.box.x);
-				y0 = Math.min(y0, n.box.y);
-				x1 = Math.max(x1, n.box.x + n.box.w);
-				y1 = Math.max(y1, n.box.y + n.box.h);
-			}
-			for (let x = x0 - spacing / 2; x <= x1 + spacing; x += spacing) for (let y = y0 - spacing / 2; y <= y1 + spacing; y += spacing) {
-				const c = {
-					x,
-					y
-				};
-				if (!obstacles.inside(c, options.margin)) this.#addPoint(c);
-			}
+		const a = r.points[0];
+		const b = r.points[r.points.length - 1];
+		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
+			if (add({
+				rule: "ends-at-plugs",
+				edge: e.id,
+				detail: "an end of the route is away from its node"
+			})) return out;
 		}
-		const links = this.points.map(() => /* @__PURE__ */ new Set());
-		for (let i = 0; i < this.points.length; i++) for (const j of this.nearestVisible(this.points[i], this.#k, i)) {
-			links[i].add(j);
-			links[j].add(i);
+		const fs = fixedPortPoint(s, e.source);
+		const ft = fixedPortPoint(t, e.target);
+		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
+			if (add({
+				rule: "fixed-plugs",
+				edge: e.id,
+				detail: "the route does not start or end at its fixed plug"
+			})) return out;
 		}
-		links.forEach((s, i) => {
-			const adj = [...s].sort((a, b) => a - b);
-			this.#adj.push(adj);
-			this.#len.push(adj.map((j) => dist(this.points[i], this.points[j])));
-		});
-	}
-	#addPoint(c) {
-		const j = this.points.length;
-		this.#pointGrid.add(j, {
-			x: c.x,
-			y: c.y,
-			w: 0,
-			h: 0
-		});
-		const key = bucketKey(Math.floor(c.x / this.#cell), Math.floor(c.y / this.#cell));
-		const list = this.#buckets.get(key);
-		if (list === void 0) this.#buckets.set(key, [j]);
-		else list.push(j);
-		this.points.push(c);
-	}
-	/** This method gives the number of links of the graph. */
-	get linkCount() {
-		let n = 0;
-		for (const a of this.#adj) n += a.length;
-		return n / 2;
-	}
-	/** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
-	nearest(p) {
-		for (let r = this.#cell; r <= this.#cell * 64; r *= 2) {
-			let best = -1;
-			let bestD = Infinity;
-			this.#pointGrid.query({
-				x: p.x - r,
-				y: p.y - r,
-				w: 2 * r,
-				h: 2 * r
-			}, (j) => {
-				const d = dist(p, this.points[j]);
-				if (d < bestD || d === bestD && j < best) {
-					bestD = d;
-					best = j;
-				}
+		for (let i = 1; i < r.points.length; i++) {
+			const p = r.points[i - 1];
+			const q = r.points[i];
+			let hit;
+			grid.querySegment(p, q, 0, (n) => {
+				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
 			});
-			if (best >= 0 && bestD <= r) return best;
+			if (hit) {
+				if (add({
+					rule: "no-pass-through",
+					edge: e.id,
+					detail: `segment ${i} goes through ${hit.id}`
+				})) return out;
+				break;
+			}
 		}
-		return -1;
 	}
-	/** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
-	nearestVisible(p, k, self = -1) {
-		return this.#nearestVisible(p, k, self, this.#pad);
-	}
-	/**
-	* This method tests the corners in rings of radius `r` = 1, 2, 4 and 8 cells. In each ring, it tests the corners
-	* within `r` that an earlier ring did not test, nearest first, and equal distances by index.
-	* The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
+	const bundled = /* @__PURE__ */ new Set();
+	for (const b of result.bundles ?? []) for (const id of b.edges) {
+		const r = routes.get(id);
+		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
+		if (bundled.has(id) || !shares) {
+			if (add({
+				rule: "bundle-trunk",
+				edge: id,
+				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
+			})) return out;
+		}
+		bundled.add(id);
+	}
+	for (const run of result.runs ?? []) {
+		if (run.edges.length < 2) {
+			if (add({
+				rule: "run-shared",
+				detail: `run ${run.id} has fewer than two edges`
+			})) return out;
+		}
+		for (const id of run.edges) {
+			const r = routes.get(id);
+			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
+				if (add({
+					rule: "run-shared",
+					edge: id,
+					detail: `run ${run.id}: the route does not hold the points of the run in a row`
+				})) return out;
+			}
+		}
+	}
+	for (const level of result.levels ?? []) {
+		const itemOf = /* @__PURE__ */ new Map();
+		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
+		if (itemOf.size !== graph.nodes.length) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
+			})) return out;
+		}
+		let between = 0;
+		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
+		const sum = level.links.reduce((s, l) => s + l.count, 0);
+		if (sum !== between) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
+			})) return out;
+		}
+		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
+		for (const l of level.links) {
+			const s = boxOf.get(l.source);
+			const t = boxOf.get(l.target);
+			const p = l.points;
+			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
+				if (add({
+					rule: "link-ends",
+					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
+				})) return out;
+			}
+		}
+	}
+	return out;
+}
+/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
+function onBoundary(p, b) {
+	const inner = inflate(b, -.5);
+	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+}
+/** This function tells if the polyline `p` holds the points of `part` in a row. */
+function holds(p, part) {
+	if (part.length === 0) return true;
+	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
+	return false;
+}
+// src/curves/sample.ts
+/** The largest number of points that `sampleCurve` gives for one segment. */
+const MAX_STEPS = 1024;
+/**
+* This function gives a polyline that follows the curve. The distance from each part of the curve to the polyline is `tolerance` or less.
+* The polyline starts at the point of the `move` and goes through the end of each segment.
+* Hit tests, measures and renderers that draw only lines use this polyline.
+*/
+function sampleCurve(segments, tolerance = .5) {
+	const tol = Math.max(1e-6, tolerance);
+	const out = [];
+	let at;
+	for (const s of segments) {
+		if (s.kind === "move" || at === void 0) {
+			out.push(s.to);
+			at = s.to;
+			continue;
+		}
+		if (s.kind === "cubic") {
+			const d = Math.max(Math.hypot(at.x - 2 * s.c1.x + s.c2.x, at.y - 2 * s.c1.y + s.c2.y), Math.hypot(s.c1.x - 2 * s.c2.x + s.to.x, s.c1.y - 2 * s.c2.y + s.to.y));
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.sqrt(3 * d / (4 * tol)))));
+			for (let k = 1; k < n; k++) out.push(cubicAt(at, s.c1, s.c2, s.to, k / n));
+		} else if (s.kind === "arc") {
+			const step = s.radius <= tol ? Math.PI : 2 * Math.acos(1 - tol / s.radius);
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.abs(s.sweep) / step)));
+			for (let k = 1; k < n; k++) {
+				const a = s.start + s.sweep * k / n;
+				out.push({
+					x: s.center.x + s.radius * Math.cos(a),
+					y: s.center.y + s.radius * Math.sin(a)
+				});
+			}
+		}
+		out.push(s.to);
+		at = s.to;
+	}
+	return out;
+}
+/** This function gives the point at the parameter `t` of the cubic Bezier curve with the control points `p0`, `p1`, `p2` and `p3`. */
+function cubicAt(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	const a = u * u * u;
+	const b = 3 * u * u * t;
+	const c = 3 * u * t * t;
+	const d = t * t * t;
+	return {
+		x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+		y: a * p0.y + b * p1.y + c * p2.y + d * p3.y
+	};
+}
+/**
+* This function writes the segments as the data of an SVG path: the commands `M`, `L`, `C` and `A`.
+* Each number has at most `digits` digits after the point.
+*/
+function toSvgPath(segments, digits = 2) {
+	const n = (v) => {
+		const s = String(Number(v.toFixed(digits)));
+		return s === "-0" ? "0" : s;
+	};
+	const p = (q) => `${n(q.x)} ${n(q.y)}`;
+	const parts = [];
+	for (const s of segments) if (s.kind === "move") parts.push(`M ${p(s.to)}`);
+	else if (s.kind === "line") parts.push(`L ${p(s.to)}`);
+	else if (s.kind === "cubic") parts.push(`C ${p(s.c1)} ${p(s.c2)} ${p(s.to)}`);
+	else parts.push(`A ${n(s.radius)} ${n(s.radius)} 0 ${Math.abs(s.sweep) > Math.PI ? 1 : 0} ${s.sweep > 0 ? 1 : 0} ${p(s.to)}`);
+	return parts.join(" ");
+}
+// src/curves/space.ts
+/**
+* This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
+* The curves sample each piece within `tolerance` of the curve for the test.
+*/
+function curveSpace(boxes, tolerance = .25) {
+	const inner = boxes.map((b) => inflate(b, -.5));
+	let size = 0;
+	for (const b of boxes) size += Math.max(b.w, b.h);
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.length)));
+	inner.forEach((b, i) => grid.add(i, b));
+	const hits = (p) => {
+		const out = /* @__PURE__ */ new Set();
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			grid.querySegment(a, b, 0, (id) => {
+				if (!out.has(id) && segmentHitsBox(a, b, inner[id], .5)) out.add(id);
+			});
+		}
+		return out;
+	};
+	return {
+		boxes,
+		tolerance,
+		addsHit(q, p) {
+			let before;
+			for (let i = 1; i < q.length; i++) {
+				const a = q[i - 1];
+				const b = q[i];
+				if (grid.someSegment(a, b, 0, (id) => {
+					if (!segmentHitsBox(a, b, inner[id], .5)) return false;
+					before ??= hits(p);
+					return !before.has(id);
+				})) return true;
+			}
+			return false;
+		}
+	};
+}
+/**
+* This function finds the largest size from `max` down to 0 that keeps a piece of a curve clear.
+* A clear piece goes through no box that its polyline avoids.
+*
+* The function `piece` gives the segments of the piece at a size. They start with a `move`.
+* The polyline `chord` is the part of the original polyline that the piece replaces.
+* The function tries `max` first, then it halves the interval `steps` times. The result is 0 when no size of the search is clear.
+*/
+function fitSize(space, max, chord, piece, steps = 8) {
+	if (space === void 0 || max <= 0) return Math.max(0, max);
+	const clear = (size) => !space.addsHit(sampleCurve(piece(size), space.tolerance), chord(size));
+	if (clear(max)) return max;
+	let lo = 0;
+	let hi = max;
+	for (let i = 0; i < steps; i++) {
+		const mid = (lo + hi) / 2;
+		if (clear(mid)) lo = mid;
+		else hi = mid;
+	}
+	return lo;
+}
+// src/curves/arc/index.ts
+/** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle stays sharp. */
+const FLAT = 1e-6;
+/**
+* This function puts a circular arc at each inner vertex of a polyline. The arc is tangent to the two legs of its corner.
+* The tangent points stay on the first half of each leg, so the ends of the polyline stay.
+* With `space`, the function makes the radius of a corner smaller until the arc goes through no box that the polyline avoids.
+* On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
+*/
+function arcCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ux = (v.x - a.x) / la;
+		const uy = (v.y - a.y) / la;
+		const wx = (b.x - v.x) / lb;
+		const wy = (b.y - v.y) / lb;
+		const turn = Math.atan2(ux * wy - uy * wx, ux * wx + uy * wy);
+		if (Math.abs(turn) < FLAT || Math.PI - Math.abs(turn) < FLAT) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const k = Math.tan(Math.abs(turn) / 2);
+		const side = Math.sign(turn);
+		const ends = (r) => [{
+			x: v.x - ux * r * k,
+			y: v.y - uy * r * k
+		}, {
+			x: v.x + wx * r * k,
+			y: v.y + wy * r * k
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			const center = {
+				x: p1.x - side * uy * r,
+				y: p1.y + side * ux * r
+			};
+			return [{
+				kind: "arc",
+				center,
+				radius: r,
+				start: Math.atan2(p1.y - center.y, p1.x - center.x),
+				sweep: turn,
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, Math.min(la, lb) / (2 * k)), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, out[out.length - 1].to) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+// src/curves/rounded/index.ts
+/**
+* This function rounds each inner vertex of a polyline with a quadratic Bezier curve, as `roundCorners` does.
+* The curve of a corner starts and ends at most `radius` from the vertex, and at most half of each leg. The ends of the polyline stay.
+* The function gives each quadratic curve as the same cubic curve. With `space`, it makes the radius of a corner smaller until the curve
+* goes through no box that the polyline avoids.
+*/
+function roundedCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ends = (r) => [{
+			x: v.x + (a.x - v.x) * r / la,
+			y: v.y + (a.y - v.y) * r / la
+		}, {
+			x: v.x + (b.x - v.x) * r / lb,
+			y: v.y + (b.y - v.y) * r / lb
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			return [{
+				kind: "cubic",
+				c1: {
+					x: p1.x + 2 * (v.x - p1.x) / 3,
+					y: p1.y + 2 * (v.y - p1.y) / 3
+				},
+				c2: {
+					x: p2.x + 2 * (v.x - p2.x) / 3,
+					y: p2.y + 2 * (v.y - p2.y) / 3
+				},
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, la / 2, lb / 2), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, at(out)) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+/** This function gives the end of the last segment. */
+function at(segments) {
+	return segments[segments.length - 1].to;
+}
+// src/curves/spline/index.ts
+/**
+* This function draws a centripetal Catmull-Rom spline through the points of a polyline (Yuksel, Schaefer and Keyser, 2011).
+* Each piece between two points is one cubic Bezier curve. The centripetal knots keep the curve free of cusps and loops in a piece.
+* The curve goes through each point. Its tangent at a point keeps one direction on the two sides of the point.
+*
+* With `space`, the function makes the tangents of a piece shorter until the piece goes through no box that its leg avoids.
+* A piece with no tangent is the straight leg.
+*/
+function splineCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	const n = p.length;
+	if (n === 1) return out;
+	const scale = 1 - Math.max(0, Math.min(1, options.tension ?? 0));
+	const dt = Array.from({ length: n - 1 }, (_, i) => Math.sqrt(dist(p[i], p[i + 1])));
+	const unit = (q) => {
+		const l = Math.hypot(q.x, q.y);
+		return l === 0 ? {
+			x: 0,
+			y: 0
+		} : {
+			x: q.x / l,
+			y: q.y / l
+		};
+	};
+	const m = p.map((v, i) => {
+		if (i === 0) {
+			const leg = {
+				x: p[1].x - v.x,
+				y: p[1].y - v.y
+			};
+			if (!options.startNormal) return {
+				x: leg.x / dt[0],
+				y: leg.y / dt[0]
+			};
+			const u = unit(options.startNormal);
+			return {
+				x: u.x * dt[0],
+				y: u.y * dt[0]
+			};
+		}
+		if (i === n - 1) {
+			const a = p[i - 1];
+			const leg = {
+				x: v.x - a.x,
+				y: v.y - a.y
+			};
+			if (!options.endNormal) return {
+				x: leg.x / dt[i - 1],
+				y: leg.y / dt[i - 1]
+			};
+			const u = unit(options.endNormal);
+			return {
+				x: -u.x * dt[i - 1],
+				y: -u.y * dt[i - 1]
+			};
+		}
+		const a = p[i - 1];
+		const b = p[i + 1];
+		const t0 = dt[i - 1];
+		const t1 = dt[i];
+		return {
+			x: (v.x - a.x) / t0 - (b.x - a.x) / (t0 + t1) + (b.x - v.x) / t1,
+			y: (v.y - a.y) / t0 - (b.y - a.y) / (t0 + t1) + (b.y - v.y) / t1
+		};
+	});
+	for (let i = 0; i + 1 < n; i++) {
+		const a = p[i];
+		const b = p[i + 1];
+		const h = dt[i] / 3;
+		const piece = (s) => [{
+			kind: "move",
+			to: a
+		}, {
+			kind: "cubic",
+			c1: {
+				x: a.x + m[i].x * h * s,
+				y: a.y + m[i].y * h * s
+			},
+			c2: {
+				x: b.x - m[i + 1].x * h * s,
+				y: b.y - m[i + 1].y * h * s
+			},
+			to: b
+		}];
+		const s = fitSize(options.space, scale, () => [a, b], piece);
+		out.push(s > 0 ? piece(s)[1] : {
+			kind: "line",
+			to: b
+		});
+	}
+	return out;
+}
+// src/curves/straight/index.ts
+/** This function gives the polyline as it is: one `move` to the first point and one `line` to each other point. */
+function straightCurve(points) {
+	return points.map((to, i) => i === 0 ? {
+		kind: "move",
+		to
+	} : {
+		kind: "line",
+		to
+	});
+}
+// src/curves/index.ts
+/**
+* This function gives the curve of a route: a polyline of a router, a lane of `laneRoutes` or a link of a zoom level.
+* The curve starts at the first point and ends at the last point of the polyline.
+* The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+*/
+function curveOf(points, options) {
+	switch (options.type) {
+		case "straight": return straightCurve(points);
+		case "rounded": return roundedCurve(points, options);
+		case "spline": return splineCurve(points, options);
+		case "arc": return arcCurve(points, options);
+	}
+}
+// src/visibility.ts
+/** The nodes as obstacles, with a grid for fast tests. */
+var Obstacles = class {
+	#grid;
+	/** This constructor indexes the boxes of the nodes. */
+	constructor(nodes, cell) {
+		this.#grid = new Grid(cell);
+		for (const n of nodes) this.#grid.add(n, n.box);
+	}
+	/** This method tells if the segment `ab` stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
+	clear(a, b, pad, skip) {
+		return this.hit(a, b, pad, skip) === void 0;
+	}
+	/**
+	* This method gives a node whose box, made larger by `pad`, the segment `ab` goes into, or `undefined` when the segment is clear.
+	* The nodes in `skip` do not count. The test stops at the first such node.
+	*/
+	hit(a, b, pad, skip) {
+		let found;
+		this.#grid.someSegment(a, b, pad, (n) => {
+			if (skip?.has(n) || !hits(a, b, n, pad)) return false;
+			found = n;
+			return true;
+		});
+		return found;
+	}
+	/** This method tells if the polyline stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
+	clearPath(p, pad, skip) {
+		for (let i = 1; i < p.length; i++) if (!this.clear(p[i - 1], p[i], pad, skip)) return false;
+		return true;
+	}
+	/** This method gives each node whose bucket the box touches to `visit`. A node can be outside the box. */
+	query(box, visit) {
+		this.#grid.query(box, visit);
+	}
+	/** This method tells if the point is inside a box, made larger by `pad`. The node `skip` does not count. */
+	inside(p, pad, skip) {
+		let hit = false;
+		this.#grid.query({
+			x: p.x,
+			y: p.y,
+			w: 0,
+			h: 0
+		}, (n) => {
+			if (!hit && n !== skip) {
+				const b = n.box;
+				hit = p.x > b.x - pad && p.x < b.x + b.w + pad && p.y > b.y - pad && p.y < b.y + b.h + pad;
+			}
+		});
+		return hit;
+	}
+};
+/** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
+function hits(a, b, n, pad) {
+	const x = n.box;
+	return segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad);
+}
+/**
+* A sparse visibility graph. Its vertices are the corners of the boxes, made larger by `margin`.
+* Each corner links to its `k` nearest corners that it can see. A lattice of free points links the groups of nodes.
+* A path goes from corner to corner around the boxes.
+* The obstacle test uses half of the margin, so a path keeps a clearance of at least half of the margin.
+*/
+var CornerGraph = class {
+	points = [];
+	#adj = [];
+	#len = [];
+	#obstacles;
+	#pointGrid;
+	#cell;
+	#pad;
+	#k;
+	#g = /* @__PURE__ */ new Float64Array(0);
+	#parent = /* @__PURE__ */ new Int32Array(0);
+	#open = /* @__PURE__ */ new Int32Array(0);
+	#closed = /* @__PURE__ */ new Int32Array(0);
+	#stamp = 0;
+	#buckets = /* @__PURE__ */ new Map();
+	#dist = /* @__PURE__ */ new Float64Array(0);
+	#near = new MinHeap();
+	#endCache = /* @__PURE__ */ new Map();
+	#fewCache = /* @__PURE__ */ new Map();
+	#part;
+	/** This constructor makes the graph of the nodes. */
+	constructor(nodes, obstacles, options) {
+		this.#obstacles = obstacles;
+		this.#pad = options.margin / 2;
+		this.#k = options.k;
+		let size = 0;
+		for (const n of nodes) size += (n.box.w + n.box.h) / 2;
+		this.#cell = Math.max(1, size / Math.max(1, nodes.length) + 2 * options.margin);
+		this.#pointGrid = new Grid(this.#cell);
+		for (const n of nodes) {
+			const b = inflate(n.box, options.margin);
+			for (const c of [
+				{
+					x: b.x,
+					y: b.y
+				},
+				{
+					x: b.x + b.w,
+					y: b.y
+				},
+				{
+					x: b.x + b.w,
+					y: b.y + b.h
+				},
+				{
+					x: b.x,
+					y: b.y + b.h
+				}
+			]) if (!obstacles.inside(c, this.#pad)) this.#addPoint(c);
+		}
+		const spacing = (options.lattice ?? 3) * this.#cell;
+		if (spacing > 0 && nodes.length > 0) {
+			let x0 = Infinity;
+			let y0 = Infinity;
+			let x1 = -Infinity;
+			let y1 = -Infinity;
+			for (const n of nodes) {
+				x0 = Math.min(x0, n.box.x);
+				y0 = Math.min(y0, n.box.y);
+				x1 = Math.max(x1, n.box.x + n.box.w);
+				y1 = Math.max(y1, n.box.y + n.box.h);
+			}
+			for (let x = x0 - spacing / 2; x <= x1 + spacing; x += spacing) for (let y = y0 - spacing / 2; y <= y1 + spacing; y += spacing) {
+				const c = {
+					x,
+					y
+				};
+				if (!obstacles.inside(c, options.margin)) this.#addPoint(c);
+			}
+		}
+		const links = this.points.map(() => /* @__PURE__ */ new Set());
+		for (let i = 0; i < this.points.length; i++) for (const j of this.#nearestVisible(this.points[i], this.#k, i, this.#pad, options.cones ?? false)) {
+			links[i].add(j);
+			links[j].add(i);
+		}
+		links.forEach((s, i) => {
+			const adj = [...s].sort((a, b) => a - b);
+			this.#adj.push(adj);
+			this.#len.push(adj.map((j) => dist(this.points[i], this.points[j])));
+		});
+	}
+	#addPoint(c) {
+		const j = this.points.length;
+		this.#pointGrid.add(j, {
+			x: c.x,
+			y: c.y,
+			w: 0,
+			h: 0
+		});
+		const key = bucketKey(Math.floor(c.x / this.#cell), Math.floor(c.y / this.#cell));
+		const list = this.#buckets.get(key);
+		if (list === void 0) this.#buckets.set(key, [j]);
+		else list.push(j);
+		this.points.push(c);
+	}
+	/** This method gives the number of links of the graph. */
+	get linkCount() {
+		let n = 0;
+		for (const a of this.#adj) n += a.length;
+		return n / 2;
+	}
+	/** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
+	nearest(p) {
+		for (let r = this.#cell; r <= this.#cell * 64; r *= 2) {
+			let best = -1;
+			let bestD = Infinity;
+			this.#pointGrid.query({
+				x: p.x - r,
+				y: p.y - r,
+				w: 2 * r,
+				h: 2 * r
+			}, (j) => {
+				const d = dist(p, this.points[j]);
+				if (d < bestD || d === bestD && j < best) {
+					bestD = d;
+					best = j;
+				}
+			});
+			if (best >= 0 && bestD <= r) return best;
+		}
+		return -1;
+	}
+	/** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
+	nearestVisible(p, k, self = -1) {
+		return this.#nearestVisible(p, k, self, this.#pad);
+	}
+	/**
+	* This method tests the corners in rings of radius `r` = 1, 2, 4 and 8 cells. In each ring, it tests the corners
+	* within `r` that an earlier ring did not test, nearest first, and equal distances by index.
+	* The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
 	* A corner of these buckets beyond `r` waits for the next ring. So the method visits each bucket one time.
+	* With `cones`, the method also gives the nearest visible corner of each of four cones around the axes that the `k` nearest corners leave empty.
 	*/
-	#nearestVisible(p, k, self, pad) {
+	#nearestVisible(p, k, self, pad, cones = false) {
 		const out = [];
+		let full = 0;
 		if (this.#dist.length < this.points.length) this.#dist = new Float64Array(this.points.length);
 		const dd = this.#dist;
 		const points = this.points;
 		const cell = this.#cell;
+		const reach = CONE_CELLS * cell;
 		const blockers = [];
 		const now = this.#near;
 		let wait = [];
@@ -1097,6 +1702,7 @@ var CornerGraph = class {
 		let pj0 = 1;
 		let pj1 = 0;
 		for (let r = cell; r <= cell * 8; r *= 2) {
+			if (out.length >= k && r / 2 >= reach) return out;
 			const x0 = p.x - r;
 			const y0 = p.y - r;
 			const i0 = Math.floor(x0 / cell);
@@ -1126,6 +1732,11 @@ var CornerGraph = class {
 			while (now.size > 0) {
 				const j = now.pop();
 				const q = points[j];
+				const cone = cones ? coneOf(q.x - p.x, q.y - p.y) : 0;
+				if (out.length >= k) {
+					if (dd[j] > reach) return out;
+					if ((full & cone) !== 0) continue;
+				}
 				let blocked = false;
 				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
 				if (blocked) continue;
@@ -1133,7 +1744,8 @@ var CornerGraph = class {
 				if (hit !== void 0) blockers.push(hit);
 				else {
 					out.push(j);
-					if (out.length >= k) return out;
+					full |= cone;
+					if (out.length >= k && (!cones || full === 15)) return out;
 				}
 			}
 			wait = later;
@@ -1321,6 +1933,10 @@ var CornerGraph = class {
 		return out;
 	}
 };
+/** A link of a cone is at most this number of cells long. A longer search costs time on a dense level and finds few new links. */
+const CONE_CELLS = 3;
+/** This function gives the bit of the cone of the offset (`dx`, `dy`): 1 is +x, 2 is +y, 4 is -x and 8 is -y. A diagonal offset is in a cone of the x axis. */
+const coneOf = (dx, dy) => Math.abs(dx) >= Math.abs(dy) ? dx > 0 ? 1 : 4 : dy > 0 ? 2 : 8;
 /** This function packs the two indices of a bucket into one number. Each index stays within ±2^20. */
 const bucketKey = (i, j) => (i + 1048576) * 2097152 + (j + 1048576);
 /**
@@ -1602,415 +2218,269 @@ function offsetPolyline(p, d) {
 		};
 		const cos = (mx * a.x + my * a.y) / ml;
 		const k = Math.min(2, 1 / Math.max(cos, 1e-9)) * d;
-		return {
-			x: q.x + mx / ml * k,
-			y: q.y + my / ml * k
-		};
-	});
-}
-/**
-* This function pulls the lanes of each shared segment apart, and gives a route for each edge.
-* The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
-*/
-function pullApart(graph, options) {
-	return lanePaths(graph, (s) => s.count > 1 ? Math.min(options.spacing, options.maxWidth / (s.count - 1)) : 0);
-}
-/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
-function runKey(edges) {
-	return [...edges].sort().join(",");
-}
-/**
-* This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
-* The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
-*
-* Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
-* The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
-* The key of a segment is `runKey` of its edges.
-*/
-function laneRoutes(source, open, laneWidth, maxWidth = Infinity) {
-	const graph = "paths" in source ? source : segmentsOf(source);
-	if (open.size === 0) return graph.paths.map((path) => ({
-		edge: path.edge,
-		points: pathPoints(graph, path)
-	}));
-	return lanePaths(graph, (s) => s.count > 1 && open.has(runKey(s.edges)) ? Math.min(laneWidth, maxWidth / (s.count - 1)) : 0);
-}
-/** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
-function lanePaths(graph, spacingOf) {
-	const byId = new Map(graph.segments.map((s) => [s.id, s]));
-	const routes = [];
-	for (const path of graph.paths) {
-		const ends = pathPoints(graph, path);
-		const out = [];
-		for (const ref of path.segments) {
-			const s = byId.get(ref.segment);
-			if (!s) continue;
-			const spacing = spacingOf(s);
-			const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
-			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME) out.push(q);
-		}
-		if (out.length >= 2 && ends.length >= 2) {
-			out[0] = ends[0];
-			out[out.length - 1] = ends[ends.length - 1];
-		}
-		routes.push({
-			edge: path.edge,
-			points: out
-		});
-	}
-	return routes;
-}
-/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
-function turn$1(from, base, to) {
-	const dx = base.x - from.x;
-	const dy = base.y - from.y;
-	const vx = to.x - base.x;
-	const vy = to.y - base.y;
-	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
-}
-/**
-* This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
-* past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
-* Two routes can part only before the first point. Then the route that comes from more to the left gets the lane more to the left.
-* A route that does not hold the run goes last.
-*/
-function orderLanes(run, routes) {
-	const placed = [];
-	const lost = [];
-	for (const r of routes) {
-		let at = indexOf(r.points, run, 0);
-		if (at >= 0) placed.push({
-			edge: r.edge,
-			p: r.points,
-			s: at,
-			e: at + run.length - 1
-		});
-		else {
-			const p = [...r.points].reverse();
-			at = indexOf(p, run, 0);
-			if (at >= 0) placed.push({
-				edge: r.edge,
-				p,
-				s: at,
-				e: at + run.length - 1
-			});
-			else lost.push(r.edge);
-		}
-	}
-	const same = (a, b) => dist(a, b) <= SAME;
-	placed.sort((P, Q) => {
-		for (let j = 1;; j++) {
-			const a = P.p[P.e + j];
-			const b = Q.p[Q.e + j];
-			if (a === void 0 || b === void 0) break;
-			if (!same(a, b)) {
-				const d = turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], a) - turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], b);
-				if (d !== 0) return d;
-				break;
-			}
-		}
-		for (let j = 1;; j++) {
-			const a = P.p[P.s - j];
-			const b = Q.p[Q.s - j];
-			if (a === void 0 || b === void 0) break;
-			if (!same(a, b)) {
-				const d = turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], b) - turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], a);
-				if (d !== 0) return d;
-				break;
-			}
-		}
-		return P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
-	});
-	return [...placed.map((x) => x.edge), ...lost.sort()];
-}
-// src/sections.ts
-/**
-* This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
-* When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
-*/
-function buildSections(nodes, options = {}) {
-	const cap = Math.max(1, options.cap ?? 8);
-	const maxDepth = options.maxDepth ?? 16;
-	const centers = nodes.map((n) => center(n.box));
-	let x0 = Infinity;
-	let y0 = Infinity;
-	let x1 = -Infinity;
-	let y1 = -Infinity;
-	for (const n of nodes) {
-		x0 = Math.min(x0, n.box.x);
-		y0 = Math.min(y0, n.box.y);
-		x1 = Math.max(x1, n.box.x + n.box.w);
-		y1 = Math.max(y1, n.box.y + n.box.h);
-	}
-	const root = nodes.length ? {
-		x: x0,
-		y: y0,
-		w: x1 - x0,
-		h: y1 - y0
-	} : {
-		x: 0,
-		y: 0,
-		w: 0,
-		h: 0
-	};
-	const make = (id, depth, cell, list) => {
-		let box = cell;
-		for (let guard = 0; list.length > cap && depth < maxDepth && guard < 32; guard++) {
-			const mx = box.x + box.w / 2;
-			const my = box.y + box.h / 2;
-			const parts = [
-				[],
-				[],
-				[],
-				[]
-			];
-			for (const i of list) parts[(centers[i].x < mx ? 0 : 1) + (centers[i].y < my ? 0 : 2)].push(i);
-			const quarter = (q) => ({
-				x: q % 2 === 0 ? box.x : mx,
-				y: q < 2 ? box.y : my,
-				w: box.w / 2,
-				h: box.h / 2
-			});
-			const full = parts.map((p, q) => [p, q]).filter(([p]) => p.length > 0);
-			if (full.length === 1) {
-				box = quarter(full[0][1]);
-				continue;
-			}
-			const children = full.map(([p, q]) => make(`${id}${q}`, depth + 1, quarter(q), p));
-			return {
-				id,
-				depth,
-				cell: box,
-				nodes: list,
-				children
-			};
-		}
-		return {
-			id,
-			depth,
-			cell: box,
-			nodes: list,
-			children: []
-		};
-	};
-	return make("s", 0, root, nodes.map((_, i) => i));
-}
-/** This function gives the sections of the tree, parents before children. */
-function allSections(root) {
-	const out = [];
-	const walk = (s) => {
-		out.push(s);
-		for (const c of s.children) walk(c);
-	};
-	walk(root);
-	return out;
-}
-/** This function gives the depth of the deepest section. */
-function treeDepth(root) {
-	return root.children.reduce((d, c) => Math.max(d, treeDepth(c)), root.depth);
-}
-// src/routers/corners.ts
-/**
-* This function makes a router that goes around the nodes.
-* Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
-* of the box corners, without the needless corners. It enters the target plug along its normal.
-*/
-function cornersRouter(options) {
-	const router = {
-		name: options.name,
-		route(graph) {
-			const byId = nodeIndex(graph);
-			const ways = new WayFinder(graph.nodes, options);
-			const routes = [];
-			for (const e of graph.edges) {
-				const s = byId.get(e.source.node);
-				const t = byId.get(e.target.node);
-				if (!s || !t) continue;
-				const ps = placePlug(s, e.source, center(t.box));
-				const pt = placePlug(t, e.target, center(s.box));
-				routes.push({
-					edge: e.id,
-					points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
-				});
-			}
-			return { routes };
-		}
-	};
-	return options.maxNodes === void 0 ? router : {
-		...router,
-		maxNodes: options.maxNodes
-	};
+		return {
+			x: q.x + mx / ml * k,
+			y: q.y + my / ml * k
+		};
+	});
 }
-// src/routers/plugs.ts
 /**
-* Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
-* It goes to the target plug on the curve of the rule. This router measures the rule alone.
+* This function pulls the lanes of each shared segment apart, and gives a route for each edge.
+* The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
 */
-const plugsRouter = {
-	name: "plugs",
-	route(graph) {
-		const byId = nodeIndex(graph);
-		const routes = [];
-		for (const e of graph.edges) {
-			const s = byId.get(e.source.node);
-			const t = byId.get(e.target.node);
-			if (!s || !t) continue;
-			const ps = placePlug(s, e.source, center(t.box));
-			const pt = placePlug(t, e.target, center(s.box));
-			routes.push({
-				edge: e.id,
-				points: inflectionCurve(ps.point, ps.normal, pt.point)
-			});
-		}
-		return { routes };
-	}
-};
-// src/bench/properties.ts
-/** The tolerance of the hard rules, in units of the plane. */
-const TOLERANCE = .5;
+function pullApart(graph, options) {
+	return lanePaths(graph, (s) => s.count > 1 ? Math.min(options.spacing, options.maxWidth / (s.count - 1)) : 0);
+}
+/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
+function runKey(edges) {
+	return [...edges].sort().join(",");
+}
 /**
-* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
-* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
-* Each link of a level starts on the box of its source and ends on the box of its target.
+* This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
+* The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
 *
-* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
-* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
-* The function gives at most `limit` violations.
+* Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
+* The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
+* The key of a segment is `runKey` of its edges.
 */
-function checkProperties(graph, result, limit = 100) {
-	const out = [];
-	const add = (v) => {
-		out.push(v);
-		return out.length >= limit;
-	};
-	const byId = nodeIndex(graph);
-	const grid = new Grid(180);
-	for (const n of graph.nodes) grid.add(n, n.box);
-	const routes = /* @__PURE__ */ new Map();
-	for (const r of result.routes) routes.set(r.edge, r);
-	for (const e of graph.edges) {
-		const r = routes.get(e.id);
-		const s = byId.get(e.source.node);
-		const t = byId.get(e.target.node);
-		if (!s || !t) continue;
-		if (!r || r.points.length < 2) {
-			if (add({
-				rule: "complete",
-				edge: e.id,
-				detail: "no route"
-			})) return out;
-			continue;
-		}
-		const a = r.points[0];
-		const b = r.points[r.points.length - 1];
-		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
-			if (add({
-				rule: "ends-at-plugs",
-				edge: e.id,
-				detail: "an end of the route is away from its node"
-			})) return out;
-		}
-		const fs = fixedPortPoint(s, e.source);
-		const ft = fixedPortPoint(t, e.target);
-		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
-			if (add({
-				rule: "fixed-plugs",
-				edge: e.id,
-				detail: "the route does not start or end at its fixed plug"
-			})) return out;
+function laneRoutes(source, open, laneWidth, maxWidth = Infinity) {
+	const graph = "paths" in source ? source : segmentsOf(source);
+	if (open.size === 0) return graph.paths.map((path) => ({
+		edge: path.edge,
+		points: pathPoints(graph, path)
+	}));
+	return lanePaths(graph, (s) => s.count > 1 && open.has(runKey(s.edges)) ? Math.min(laneWidth, maxWidth / (s.count - 1)) : 0);
+}
+/** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
+function lanePaths(graph, spacingOf) {
+	const byId = new Map(graph.segments.map((s) => [s.id, s]));
+	const routes = [];
+	for (const path of graph.paths) {
+		const ends = pathPoints(graph, path);
+		const out = [];
+		for (const ref of path.segments) {
+			const s = byId.get(ref.segment);
+			if (!s) continue;
+			const spacing = spacingOf(s);
+			const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
+			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME) out.push(q);
 		}
-		for (let i = 1; i < r.points.length; i++) {
-			const p = r.points[i - 1];
-			const q = r.points[i];
-			let hit;
-			grid.querySegment(p, q, 0, (n) => {
-				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
-			});
-			if (hit) {
-				if (add({
-					rule: "no-pass-through",
-					edge: e.id,
-					detail: `segment ${i} goes through ${hit.id}`
-				})) return out;
-				break;
-			}
+		if (out.length >= 2 && ends.length >= 2) {
+			out[0] = ends[0];
+			out[out.length - 1] = ends[ends.length - 1];
 		}
+		routes.push({
+			edge: path.edge,
+			points: out
+		});
 	}
-	const bundled = /* @__PURE__ */ new Set();
-	for (const b of result.bundles ?? []) for (const id of b.edges) {
-		const r = routes.get(id);
-		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
-		if (bundled.has(id) || !shares) {
-			if (add({
-				rule: "bundle-trunk",
-				edge: id,
-				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
-			})) return out;
+	return routes;
+}
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn$1(from, base, to) {
+	const dx = base.x - from.x;
+	const dy = base.y - from.y;
+	const vx = to.x - base.x;
+	const vy = to.y - base.y;
+	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+/**
+* This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
+* past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
+* Two routes can part only before the first point. Then the route that comes from more to the left gets the lane more to the left.
+* A route that does not hold the run goes last.
+*/
+function orderLanes(run, routes) {
+	const placed = [];
+	const lost = [];
+	for (const r of routes) {
+		let at = indexOf(r.points, run, 0);
+		if (at >= 0) placed.push({
+			edge: r.edge,
+			p: r.points,
+			s: at,
+			e: at + run.length - 1
+		});
+		else {
+			const p = [...r.points].reverse();
+			at = indexOf(p, run, 0);
+			if (at >= 0) placed.push({
+				edge: r.edge,
+				p,
+				s: at,
+				e: at + run.length - 1
+			});
+			else lost.push(r.edge);
 		}
-		bundled.add(id);
 	}
-	for (const run of result.runs ?? []) {
-		if (run.edges.length < 2) {
-			if (add({
-				rule: "run-shared",
-				detail: `run ${run.id} has fewer than two edges`
-			})) return out;
-		}
-		for (const id of run.edges) {
-			const r = routes.get(id);
-			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
-				if (add({
-					rule: "run-shared",
-					edge: id,
-					detail: `run ${run.id}: the route does not hold the points of the run in a row`
-				})) return out;
+	const same = (a, b) => dist(a, b) <= SAME;
+	placed.sort((P, Q) => {
+		for (let j = 1;; j++) {
+			const a = P.p[P.e + j];
+			const b = Q.p[Q.e + j];
+			if (a === void 0 || b === void 0) break;
+			if (!same(a, b)) {
+				const d = turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], a) - turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], b);
+				if (d !== 0) return d;
+				break;
 			}
 		}
-	}
-	for (const level of result.levels ?? []) {
-		const itemOf = /* @__PURE__ */ new Map();
-		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
-		if (itemOf.size !== graph.nodes.length) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
-			})) return out;
-		}
-		let between = 0;
-		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
-		const sum = level.links.reduce((s, l) => s + l.count, 0);
-		if (sum !== between) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
-			})) return out;
+		for (let j = 1;; j++) {
+			const a = P.p[P.s - j];
+			const b = Q.p[Q.s - j];
+			if (a === void 0 || b === void 0) break;
+			if (!same(a, b)) {
+				const d = turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], b) - turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], a);
+				if (d !== 0) return d;
+				break;
+			}
 		}
-		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
-		for (const l of level.links) {
-			const s = boxOf.get(l.source);
-			const t = boxOf.get(l.target);
-			const p = l.points;
-			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
-				if (add({
-					rule: "link-ends",
-					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
-				})) return out;
+		return P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
+	});
+	return [...placed.map((x) => x.edge), ...lost.sort()];
+}
+// src/sections.ts
+/**
+* This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
+* When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
+*/
+function buildSections(nodes, options = {}) {
+	const cap = Math.max(1, options.cap ?? 8);
+	const maxDepth = options.maxDepth ?? 16;
+	const centers = nodes.map((n) => center(n.box));
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of nodes) {
+		x0 = Math.min(x0, n.box.x);
+		y0 = Math.min(y0, n.box.y);
+		x1 = Math.max(x1, n.box.x + n.box.w);
+		y1 = Math.max(y1, n.box.y + n.box.h);
+	}
+	const root = nodes.length ? {
+		x: x0,
+		y: y0,
+		w: x1 - x0,
+		h: y1 - y0
+	} : {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+	const make = (id, depth, cell, list) => {
+		let box = cell;
+		for (let guard = 0; list.length > cap && depth < maxDepth && guard < 32; guard++) {
+			const mx = box.x + box.w / 2;
+			const my = box.y + box.h / 2;
+			const parts = [
+				[],
+				[],
+				[],
+				[]
+			];
+			for (const i of list) parts[(centers[i].x < mx ? 0 : 1) + (centers[i].y < my ? 0 : 2)].push(i);
+			const quarter = (q) => ({
+				x: q % 2 === 0 ? box.x : mx,
+				y: q < 2 ? box.y : my,
+				w: box.w / 2,
+				h: box.h / 2
+			});
+			const full = parts.map((p, q) => [p, q]).filter(([p]) => p.length > 0);
+			if (full.length === 1) {
+				box = quarter(full[0][1]);
+				continue;
 			}
+			const children = full.map(([p, q]) => make(`${id}${q}`, depth + 1, quarter(q), p));
+			return {
+				id,
+				depth,
+				cell: box,
+				nodes: list,
+				children
+			};
 		}
-	}
+		return {
+			id,
+			depth,
+			cell: box,
+			nodes: list,
+			children: []
+		};
+	};
+	return make("s", 0, root, nodes.map((_, i) => i));
+}
+/** This function gives the sections of the tree, parents before children. */
+function allSections(root) {
+	const out = [];
+	const walk = (s) => {
+		out.push(s);
+		for (const c of s.children) walk(c);
+	};
+	walk(root);
 	return out;
 }
-/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
-function onBoundary(p, b) {
-	const inner = inflate(b, -.5);
-	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+/** This function gives the depth of the deepest section. */
+function treeDepth(root) {
+	return root.children.reduce((d, c) => Math.max(d, treeDepth(c)), root.depth);
 }
-/** This function tells if the polyline `p` holds the points of `part` in a row. */
-function holds(p, part) {
-	if (part.length === 0) return true;
-	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
-	return false;
+// src/routers/corners.ts
+/**
+* This function makes a router that goes around the nodes.
+* Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
+* of the box corners, without the needless corners. It enters the target plug along its normal.
+*/
+function cornersRouter(options) {
+	const router = {
+		name: options.name,
+		route(graph) {
+			const byId = nodeIndex(graph);
+			const ways = new WayFinder(graph.nodes, options);
+			const routes = [];
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				if (!s || !t) continue;
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				routes.push({
+					edge: e.id,
+					points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+				});
+			}
+			return { routes };
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
 }
+// src/routers/plugs.ts
+/**
+* Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
+* It goes to the target plug on the curve of the rule. This router measures the rule alone.
+*/
+const plugsRouter = {
+	name: "plugs",
+	route(graph) {
+		const byId = nodeIndex(graph);
+		const routes = [];
+		for (const e of graph.edges) {
+			const s = byId.get(e.source.node);
+			const t = byId.get(e.target.node);
+			if (!s || !t) continue;
+			const ps = placePlug(s, e.source, center(t.box));
+			const pt = placePlug(t, e.target, center(s.box));
+			routes.push({
+				edge: e.id,
+				points: inflectionCurve(ps.point, ps.normal, pt.point)
+			});
+		}
+		return { routes };
+	}
+};
 // src/bench/links.ts
 /** A link goes out and back when its distance to its target grows by more than this share of the distance between its ends. */
 const BACKTRACK_SHARE = .25;
@@ -2224,6 +2694,7 @@ function sideWay(ways, s, t, inset) {
 /**
 * This function makes the obstacles and the corner graph of the items of a level.
 * The buckets of the obstacles grow with the items, so a long link visits few buckets.
+* The corner graphs use `cones`, so a link goes along the corridors between the groups, not around the outer edge of the board.
 */
 function levelWays(nodes, options) {
 	const margin = options.margin ?? 5;
@@ -2233,7 +2704,8 @@ function levelWays(nodes, options) {
 	const obstacles = new Obstacles(nodes, Math.max(180, 2 * size / Math.max(1, nodes.length)));
 	const corners = new CornerGraph(nodes, obstacles, {
 		margin,
-		k
+		k,
+		cones: true
 	});
 	const out = (p) => ({
 		x: p.point.x + p.normal.x * margin,
@@ -2242,7 +2714,8 @@ function levelWays(nodes, options) {
 	let tight;
 	const tightGraph = () => tight ??= new CornerGraph(nodes, obstacles, {
 		margin: Math.min(margin, TIGHT_MARGIN),
-		k
+		k,
+		cones: true
 	});
 	return {
 		obstacles,
@@ -3264,6 +3737,287 @@ const ROUTERS = [
 		maxNodes: 1e5
 	})
 ];
+// src/room/index.ts
+const DEFAULT_GUTTER = 8;
+const DEFAULT_SPACING = 4;
+const DEFAULT_SNAP = .5;
+const lo = (b, a) => a === "x" ? b.x : b.y;
+const len = (b, a) => a === "x" ? b.w : b.h;
+const other = (a) => a === "x" ? "y" : "x";
+/**
+* This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+* Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
+*/
+function boardGaps(items, snap = DEFAULT_SNAP) {
+	return [...axisGaps(items, "x", snap), ...axisGaps(items, "y", snap)];
+}
+function axisGaps(items, axis, snap) {
+	const starts = [...new Set(items.map((i) => lo(i.box, axis)))].sort((u, v) => u - v);
+	const bounds = [];
+	for (const s of starts) if (bounds.length === 0 || s - bounds[bounds.length - 1] > snap) bounds.push(s);
+	const after = bounds.map(() => []);
+	for (const i of items) after[lastAtOrBefore(bounds, lo(i.box, axis) + snap)].push(i.id);
+	const ends = items.map((i) => ({
+		id: i.id,
+		end: lo(i.box, axis) + len(i.box, axis)
+	})).sort((u, v) => u.end - v.end);
+	const gaps = [];
+	let k = 0;
+	for (let n = 1; n < bounds.length; n++) {
+		const at = bounds[n];
+		while (k < ends.length && ends[k].end <= at + snap) k++;
+		const near = k > 0 ? ends[k - 1].end : at;
+		const before = [];
+		for (let j = k - 1; j >= 0 && ends[j].end >= near - snap; j--) before.push(ends[j].id);
+		gaps.push({
+			axis,
+			index: n - 1,
+			at,
+			before: before.reverse(),
+			after: after[n],
+			width: Math.max(0, at - near),
+			lanes: 0,
+			need: Math.max(0, at - near)
+		});
+	}
+	return gaps;
+}
+/** This function gives the index of the last value of the sorted list `v` that is at or before `x`, or 0. */
+function lastAtOrBefore(v, x) {
+	let a = 0;
+	let b = v.length - 1;
+	while (a < b) {
+		const m = a + b + 1 >> 1;
+		if (v[m] <= x) a = m;
+		else b = m - 1;
+	}
+	return a;
+}
+/**
+* This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+* A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+* The function moves no box nearer to another box, so it makes no overlap.
+*/
+function openGaps(items, gaps, snap = DEFAULT_SNAP) {
+	const shift = (axis) => {
+		const list = gaps.filter((g) => g.axis === axis).sort((u, v) => u.at - v.at);
+		const at = list.map((g) => g.at);
+		const sum = [];
+		let s = 0;
+		for (const g of list) sum.push(s += Math.max(0, g.need - g.width));
+		return (v) => list.length === 0 || at[0] > v + snap ? 0 : sum[lastAtOrBefore(at, v + snap)];
+	};
+	const sx = shift("x");
+	const sy = shift("y");
+	return items.map((i) => ({
+		...i,
+		box: {
+			...i.box,
+			x: i.box.x + sx(i.box.x),
+			y: i.box.y + sy(i.box.y)
+		}
+	}));
+}
+/**
+* This function gives the room that the links need in each gap of the board.
+* The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+*/
+function roomDemand(items, links, options = {}) {
+	const gutter = options.gutter ?? DEFAULT_GUTTER;
+	const spacing = options.spacing ?? DEFAULT_SPACING;
+	const snap = options.snap ?? DEFAULT_SNAP;
+	const weight = (l) => options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1;
+	const gaps = boardGaps(items, snap);
+	const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
+	return capGrowth(items, gaps.map((g, i) => ({
+		...g,
+		lanes: lanes[i],
+		need: Math.max(g.width, gutter + lanes[i] * spacing)
+	})), gutter, options.maxGrowth ?? Infinity);
+}
+/** This function gives the demand of the board and the board with each gap open to its need. */
+function makeRoom(items, links, options = {}) {
+	const gaps = roomDemand(items, links, options);
+	return {
+		gaps,
+		items: openGaps(items, gaps, options.snap ?? DEFAULT_SNAP)
+	};
+}
+/** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
+function roomLinks(graph) {
+	const byPair = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const [s, t] = [e.source.node, e.target.node];
+		if (s === t) continue;
+		const key = s < t ? `${s}\u0000${t}` : `${t}\u0000${s}`;
+		const known = byPair.get(key);
+		if (known) known.count++;
+		else byPair.set(key, {
+			source: s,
+			target: t,
+			count: 1
+		});
+	}
+	return [...byPair.values()];
+}
+/** This function counts, for each gap, the straight lines between the centers of the boxes of a link that cross the gap. */
+function lineLanes(items, links, gaps, weight) {
+	const byId = new Map(items.map((i) => [i.id, center(i.box)]));
+	return gaps.map((g) => {
+		let n = 0;
+		for (const l of links) {
+			const a = byId.get(l.source);
+			const b = byId.get(l.target);
+			if (a && b && Math.min(a[g.axis], b[g.axis]) < g.at && Math.max(a[g.axis], b[g.axis]) > g.at) n += weight(l);
+		}
+		return n;
+	});
+}
+/**
+* This function routes the links one time on the board with each gap open to the gutter.
+* The lanes of a gap are the largest number of routes that run along the gap at one place.
+* A piece of a route goes along a gap when it is in the channel of the gap.
+* It must also go farther along the gap than across it.
+*/
+function routeLanes(items, links, gaps, gutter, snap, weight, router) {
+	const probeGaps = gaps.map((g) => ({
+		...g,
+		need: Math.max(g.width, gutter)
+	}));
+	const ways = probeWays(openGaps(items, probeGaps, snap), links, gutter, router);
+	return probeGaps.map((g) => {
+		let grow = 0;
+		for (const h of probeGaps) if (h.axis === g.axis && h.at <= g.at + snap) grow += h.need - h.width;
+		const hi = g.at + grow;
+		const lo = hi - g.need;
+		const spans = [];
+		ways.forEach((points, i) => {
+			const along = alongSpans(points, g.axis, lo, hi);
+			for (const [from, to] of merge(along)) spans.push({
+				from,
+				to,
+				w: weight(links[i])
+			});
+		});
+		return density(spans);
+	});
+}
+/** This function gives the points of the way of each link on the probe board, in the order of the links. */
+function probeWays(items, links, gutter, router) {
+	if (router) {
+		const edges = links.map((l, i) => ({
+			id: `l${i}`,
+			source: { node: l.source },
+			target: { node: l.target }
+		}));
+		const routes = new Map(router.route({
+			nodes: items,
+			edges
+		}).routes.map((r) => [r.edge, r.points]));
+		return edges.map((e) => routes.get(e.id) ?? []);
+	}
+	const out = levelLinks(items.map((i) => ({
+		id: i.id,
+		box: i.box,
+		nodes: [i.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})), { margin: Math.max(1, gutter / 2) });
+	const byPair = new Map(out.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+	return links.map((l) => byPair.get(`${l.source}\u0000${l.target}`) ?? []);
+}
+/**
+* This function gives the spans along the axis of a gap where the polyline goes along the channel from `lo` to `hi`.
+* The axis `x` gap is a vertical channel, so its spans are on the y axis.
+*/
+function alongSpans(p, axis, lo, hi) {
+	const across = axis;
+	const along = other(axis);
+	const out = [];
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		const da = b[across] - a[across];
+		let t0 = 0;
+		let t1 = 1;
+		if (Math.abs(da) < 1e-9) {
+			if (a[across] < lo - 1e-6 || a[across] > hi + 1e-6) continue;
+		} else {
+			const u = (lo - a[across]) / da;
+			const v = (hi - a[across]) / da;
+			t0 = Math.max(0, Math.min(u, v));
+			t1 = Math.min(1, Math.max(u, v));
+			if (t1 <= t0) continue;
+		}
+		const s = a[along] + (b[along] - a[along]) * t0;
+		const e = a[along] + (b[along] - a[along]) * t1;
+		const run = Math.abs(e - s);
+		if (run > Math.abs(da) * (t1 - t0) && run > 1e-6) out.push([Math.min(s, e), Math.max(s, e)]);
+	}
+	return out;
+}
+/** This function joins the spans that overlap, so that one link counts one time at each place. */
+function merge(spans) {
+	spans.sort((u, v) => u[0] - v[0]);
+	const out = [];
+	for (const s of spans) {
+		const last = out[out.length - 1];
+		if (last && s[0] <= last[1]) last[1] = Math.max(last[1], s[1]);
+		else out.push([s[0], s[1]]);
+	}
+	return out;
+}
+/** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
+function density(spans) {
+	const events = [];
+	for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
+	events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
+	let n = 0;
+	let best = 0;
+	for (const [, w] of events) {
+		n += w;
+		best = Math.max(best, n);
+	}
+	return best;
+}
+/**
+* This function keeps the growth of the board on each axis at most `maxGrowth` times its size.
+* Each gap keeps its gutter. The lanes of all gaps of the axis share the rest of the growth in proportion.
+*/
+function capGrowth(items, gaps, gutter, maxGrowth) {
+	if (!Number.isFinite(maxGrowth)) return gaps;
+	const out = [...gaps];
+	for (const axis of ["x", "y"]) {
+		let x0 = Infinity;
+		let x1 = -Infinity;
+		for (const i of items) {
+			x0 = Math.min(x0, lo(i.box, axis));
+			x1 = Math.max(x1, lo(i.box, axis) + len(i.box, axis));
+		}
+		const budget = Math.max(0, maxGrowth) * Math.max(0, x1 - x0);
+		let base = 0;
+		let spare = 0;
+		for (const g of gaps) {
+			if (g.axis !== axis) continue;
+			const b = Math.max(0, gutter - g.width);
+			base += b;
+			spare += Math.max(0, g.need - g.width - b);
+		}
+		if (base + spare <= budget || spare === 0) continue;
+		const f = Math.max(0, (budget - base) / spare);
+		gaps.forEach((g, i) => {
+			if (g.axis !== axis) return;
+			const b = Math.max(0, gutter - g.width);
+			out[i] = {
+				...g,
+				need: g.width + b + f * Math.max(0, g.need - g.width - b)
+			};
+		});
+	}
+	return out;
+}
 // src/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -3449,7 +4203,7 @@ function measureStability(before, after) {
 	};
 }
 // src/bench/run.ts
-const now = () => globalThis.performance?.now() ?? Date.now();
+const now$2 = () => globalThis.performance?.now() ?? Date.now();
 /** This function routes each fixture with each router, checks the hard rules and measures the quality. */
 function runBenchmark(routers, fixtures, options = {}) {
 	const rows = [];
@@ -3488,9 +4242,9 @@ function benchOne(router, fixture, graph, repeat = 3) {
 	let first;
 	let deterministic = true;
 	for (let i = 0; i < Math.max(2, repeat); i++) {
-		const t0 = now();
+		const t0 = now$2();
 		const r = router.route(graph);
-		times.push(now() - t0);
+		times.push(now$2() - t0);
 		if (!first) first = r;
 		else if (i === 1 && !sameData(r, first)) deterministic = false;
 	}
@@ -3552,6 +4306,178 @@ function formatFaults(rows) {
 		})
 	].join("\n");
 }
-export { BACKTRACK_MIN, BACKTRACK_SHARE, CASES, CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, backtrackOf, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, denseGroupsBoard, dist, fixedPortPoint, formatFaults, formatTable, frechet, goesOutAndBack, groupEdges, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, manyGroupsBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, orderLanes, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roundCorners, runBenchmark, runKey, sameData, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splitPoint, straightRouter, sumFaults, treeDepth, trunksRouter, turns };
+// src/bench/curves.ts
+const now$1 = () => globalThis.performance?.now() ?? Date.now();
+/**
+* This function routes a graph with a router and makes each curve type of each route.
+* It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+* The type `spline` leaves each plug along the normal of the nearest side of its node.
+*/
+function benchCurves(router, fixture, graph, options = {}) {
+	const tolerance = options.tolerance ?? .25;
+	const result = router.route(graph);
+	const byId = nodeIndex(graph);
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	const space = curveSpace(graph.nodes.map((n) => n.box), tolerance);
+	const routes = result.routes.flatMap((r) => {
+		const e = edges.get(r.edge);
+		const s = e && byId.get(e.source.node);
+		const t = e && byId.get(e.target.node);
+		if (!e || !s || !t || r.points.length < 2) return [];
+		const first = r.points[0];
+		const last = r.points[r.points.length - 1];
+		return [{
+			source: s.id,
+			target: t.id,
+			points: r.points,
+			startNormal: SIDE_NORMAL[nearestSide(s.box, first)],
+			endNormal: SIDE_NORMAL[nearestSide(t.box, last)]
+		}];
+	});
+	const base = measureLinks(boxes, routes);
+	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
+	return CURVE_TYPES.map((type) => {
+		const make = (withSpace) => routes.map((r) => ({
+			source: r.source,
+			target: r.target,
+			points: sampleCurve(curveOf(r.points, {
+				type,
+				radius: options.radius ?? 12,
+				startNormal: r.startNormal,
+				endNormal: r.endNormal,
+				...withSpace ? { space } : {}
+			}), tolerance)
+		}));
+		const free = measureLinks(boxes, make(false));
+		const t0 = now$1();
+		const clamped = make(true);
+		const ms = now$1() - t0;
+		const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
+		return {
+			router: router.name,
+			fixture,
+			type,
+			links: routes.length,
+			through: base.through,
+			free: free.through,
+			clamped: measureLinks(boxes, clamped).through,
+			length: ink > 0 ? length / ink : 1,
+			ms
+		};
+	});
+}
+/** This function writes the rows of `benchCurves` as a Markdown table. */
+function formatCurves(rows) {
+	return [
+		"| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |",
+		"|---|---|---|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`)
+	].join("\n");
+}
+// src/bench/room.ts
+const now = () => globalThis.performance?.now() ?? Date.now();
+/** This function gives the area of the bounding box of the nodes. */
+function areaOf(nodes) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of nodes) {
+		x0 = Math.min(x0, n.box.x);
+		y0 = Math.min(y0, n.box.y);
+		x1 = Math.max(x1, n.box.x + n.box.w);
+		y1 = Math.max(y1, n.box.y + n.box.h);
+	}
+	return nodes.length ? (x1 - x0) * (y1 - y0) : 0;
+}
+/**
+* This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
+* It also measures the lane routes of the router `sections` at the lane width `spacing`.
+*/
+function measureBoard(graph, spacing) {
+	const links = roomLinks(graph);
+	const drawn = levelLinks(graph.nodes.map((n) => ({
+		id: n.id,
+		box: n.box,
+		nodes: [n.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})));
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edgeOf = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const key = `${e.source.node}\u0000${e.target.node}`;
+		if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+	}
+	const q = measureQuality(graph, { routes: drawn.map((l) => ({
+		edge: edgeOf.get(`${l.source}\u0000${l.target}`),
+		points: l.points
+	})) });
+	const segments = segmentsOf(sectionsRouter({ name: "sections" }).route(graph));
+	const lanes = laneRoutes(segments, new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges))), spacing);
+	return {
+		faults: measureLinks(boxes, drawn),
+		crossings: q.crossings,
+		ink: q.ink,
+		detour: q.detour,
+		laneThrough: measureRouteFaults(graph, { routes: lanes }).through
+	};
+}
+/**
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
+* The options of `makeRoom` are the same for each method, except `method`.
+*/
+function benchRoom(fixture, graph, options = {}) {
+	const spacing = options.spacing ?? 4;
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing)
+	});
+	const rows = [row("packed", graph.nodes, 0)];
+	const states = [
+		["gutter", {
+			...options,
+			spacing: 0,
+			method: "routes"
+		}],
+		["routes", {
+			...options,
+			method: "routes"
+		}],
+		["lines", {
+			...options,
+			method: "lines"
+		}]
+	];
+	for (const [board, o] of states) {
+		const t0 = now();
+		const room = makeRoom(graph.nodes, links, o);
+		rows.push(row(board, room.items, now() - t0));
+	}
+	return rows;
+}
+/** This function writes the rows of `benchRoom` as a Markdown table. */
+function formatRoom(rows) {
+	return [
+		"| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			return `| ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${f.links} | ${f.through} | ${f.outside} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${r.crossings} | ${Math.round(r.ink)} | ${r.detour.toFixed(3)} | ${r.laneThrough} | ${r.ms.toFixed(1)} |`;
+		})
+	].join("\n");
+}
+export { BACKTRACK_MIN, BACKTRACK_SHARE, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, Grid, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, arcCurve, backtrackOf, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, cubicAt, curveOf, curveSpace, denseGroupsBoard, dist, distinctPoints, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatTable, frechet, goesOutAndBack, groupEdges, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roomDemand, roomLinks, roundCorners, roundedCurve, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splineCurve, splitPoint, straightCurve, straightRouter, sumFaults, toSvgPath, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map