@mark1russell7/highways 0.1.1 → 0.1.3

package/build/index.js

@@ -228,6 +228,53 @@ var Grid = class {
 			}
 		}
 	}
+	/**
+	* This method gives each item in the buckets along the segment `ab`, widened by `margin`, to `visit`, one time each.
+	* The buckets are those of `#segment`, in the same order, so the items come in the same order.
+	* A bucket in the range of the step before has no new item, so the walk skips it.
+	* The walk stops when `visit` gives true, and then the method gives true.
+	*/
+	#walk(a, b, margin, visit) {
+		const stamp = ++this.#stamp;
+		const c = this.#cell;
+		const items = this.#items;
+		const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (c / 2)));
+		let px = a.x;
+		let py = a.y;
+		let pi0 = 1;
+		let pi1 = 0;
+		let pj0 = 1;
+		let pj1 = 0;
+		for (let k = 1; k <= n; k++) {
+			const qx = k === n ? b.x : a.x + (b.x - a.x) * k / n;
+			const qy = k === n ? b.y : a.y + (b.y - a.y) * k / n;
+			const i0 = Math.floor((Math.min(px, qx) - margin) / c);
+			const j0 = Math.floor((Math.min(py, qy) - margin) / c);
+			const i1 = Math.floor((Math.max(px, qx) + margin) / c);
+			const j1 = Math.floor((Math.max(py, qy) + margin) / c);
+			const seen = this.#seen;
+			for (let i = i0; i <= i1; i++) {
+				const before = i >= pi0 && i <= pi1;
+				for (let j = j0; j <= j1; j++) {
+					if (before && j >= pj0 && j <= pj1) continue;
+					const list = this.#buckets.get(this.#key(i, j));
+					if (list === void 0) continue;
+					for (const id of list) {
+						if (seen[id] === stamp) continue;
+						seen[id] = stamp;
+						if (visit(items[id]) === true) return true;
+					}
+				}
+			}
+			pi0 = i0;
+			pi1 = i1;
+			pj0 = j0;
+			pj1 = j1;
+			px = qx;
+			py = qy;
+		}
+		return false;
+	}
 	#segment(a, b, margin, each) {
 		const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (this.#cell / 2)));
 		let px = a.x;
@@ -255,8 +302,16 @@ var Grid = class {
 	}
 	/** This method gives each item whose buckets come within `margin` of the segment `ab` to `visit`, one time each. */
 	querySegment(a, b, margin, visit) {
-		const stamp = ++this.#stamp;
-		this.#segment(a, b, margin, (x0, y0, x1, y1) => this.#take(stamp, x0, y0, x1, y1, visit));
+		this.#walk(a, b, margin, (item) => {
+			visit(item);
+		});
+	}
+	/**
+	* This method tells if `test` gives true for an item whose buckets come within `margin` of the segment `ab`.
+	* It gives the items in the order of `querySegment`, and it stops at the first item that passes the test.
+	*/
+	someSegment(a, b, margin, test) {
+		return this.#walk(a, b, margin, test);
 	}
 };
 /** This function gives the bounding box of the segment `ab`. */
@@ -372,7 +427,7 @@ const COLLECTIONS = [
 	"scores",
 	"teams"
 ];
-const SIDES = [
+const SIDES$1 = [
 	"north",
 	"east",
 	"south",
@@ -441,7 +496,7 @@ function makeFixture(spec) {
 		clusterOf.push(cluster);
 		const id = `n${nodes.length}`;
 		if (R() < (spec.fixedPorts ?? 0)) {
-			const s = SIDES[Math.floor(R() * 4)];
+			const s = SIDES$1[Math.floor(R() * 4)];
 			const t = .2 + .6 * R();
 			const at = s === "north" ? {
 				x: w * t,
@@ -546,6 +601,125 @@ function makeEdges(spec, nodes, clusterOf, R) {
 	}
 	return edges;
 }
+// src/cases.ts
+/** A board while it grows: the functions add nodes and edges in order. */
+var Board = class {
+	nodes = [];
+	edges = [];
+	#pairs = /* @__PURE__ */ new Set();
+	node(id, x, y, w, h) {
+		this.nodes.push({
+			id,
+			box: {
+				x,
+				y,
+				w,
+				h
+			}
+		});
+		return id;
+	}
+	/** This method adds an edge. It adds nothing for a loop or for a second edge between the same two nodes. */
+	link(source, target) {
+		const key = source < target ? `${source}|${target}` : `${target}|${source}`;
+		if (source === target || this.#pairs.has(key)) return;
+		this.#pairs.add(key);
+		this.edges.push({
+			id: `e${this.edges.length}`,
+			source: { node: source },
+			target: { node: target }
+		});
+	}
+	graph() {
+		return {
+			nodes: this.nodes,
+			edges: this.edges
+		};
+	}
+};
+/**
+* This function makes a dense board: 150 nodes in tight clusters. At the far view, the boxes of the groups overlap.
+* Then a level link starts or ends in a group that another group covers.
+*/
+function denseGroupsBoard() {
+	return makeFixture({
+		name: "dense-groups",
+		kind: "clustered",
+		nodes: 150,
+		edgesPerNode: 2,
+		seed: 3
+	});
+}
+/**
+* This function makes a board of three rows of 32 cards. Each card links to the next card of its row.
+* Forty long links join cards far apart. The hub of a section is near the middle of its cards.
+* So a long link climbs to hubs behind its source or past its target, and comes back.
+*/
+function hubChainBoard() {
+	const R = rng(3);
+	const b = new Board();
+	const rows = 3;
+	const cols = 32;
+	const id = (r, c) => `c${r}-${c}`;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * 128, r * 84, 80, 36);
+	for (let r = 0; r < rows; r++) for (let c = 0; c + 1 < cols; c++) b.link(id(r, c), id(r, c + 1));
+	for (let n = 0; n < 40; n++) {
+		const r = Math.floor(R() * rows);
+		const c = Math.floor(R() * cols);
+		const span = Math.floor(cols / 8 + R() * cols / 2);
+		if (c + span < cols) b.link(id(r, c), id((r + 1) % rows, c + span));
+	}
+	return b.graph();
+}
+/**
+* This function makes a board of 32 groups in 8 columns and 4 rows. Each group has 4 cards in a square.
+* The cards of a group link in a chain, and 96 random links join cards of two groups.
+* On a level with many groups, some level links go around the outer edge of the board.
+*/
+function manyGroupsBoard() {
+	const R = rng(7);
+	const b = new Board();
+	const cols = 8;
+	const rows = 4;
+	const per = 4;
+	const w = 60;
+	const h = 30;
+	const cardGap = 12;
+	const side = Math.ceil(Math.sqrt(per));
+	Math.ceil(per / side) * h + (Math.ceil(per / side) - 1) * cardGap;
+	const groups = [];
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const list = [];
+		for (let i = 0; i < per; i++) {
+			const x = c * 192 + i % side * 72;
+			const y = r * 132 + Math.floor(i / side) * 42;
+			list.push(b.node(`g${r}-${c}-${i}`, x, y, w, h));
+		}
+		groups.push(list);
+	}
+	for (const list of groups) for (let i = 1; i < list.length; i++) b.link(list[i - 1], list[i]);
+	const pick = (list) => list[Math.floor(R() * list.length)];
+	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();
+}
+/** 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 = [
+	{
+		name: "case-dense-groups",
+		defect: "Groups overlap at the far view, and level links go through other groups.",
+		make: denseGroupsBoard
+	},
+	{
+		name: "case-hub-chain",
+		defect: "A route climbs a chain of hubs away from its target and comes back.",
+		make: hubChainBoard
+	},
+	{
+		name: "case-many-groups",
+		defect: "On a level with many groups, links go around the outer edge of the board.",
+		make: manyGroupsBoard
+	}
+];
 // src/plugs.ts
 /** The outward normal of each side, in a frame with the y axis down. */
 const SIDE_NORMAL = {
@@ -725,20 +899,30 @@ var Obstacles = class {
 	}
 	/** 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) {
-		let ok = true;
-		this.#grid.querySegment(a, b, pad, (n) => {
-			if (ok && !skip?.has(n)) {
-				const x = n.box;
-				if (segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad)) ok = false;
-			}
+		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 ok;
+		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;
@@ -756,6 +940,11 @@ var Obstacles = class {
 		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.
@@ -776,8 +965,12 @@ var CornerGraph = class {
 	#open = /* @__PURE__ */ new Int32Array(0);
 	#closed = /* @__PURE__ */ new Int32Array(0);
 	#stamp = 0;
-	#tested = /* @__PURE__ */ new Int32Array(0);
-	#testStamp = 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;
@@ -840,12 +1033,17 @@ var CornerGraph = class {
 		});
 	}
 	#addPoint(c) {
-		this.#pointGrid.add(this.points.length, {
+		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. */
@@ -877,27 +1075,72 @@ var CornerGraph = class {
 	}
 	/** 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.
+	*/
+	#nearestVisible(p, k, self, pad) {
 		const out = [];
-		if (this.#tested.length < this.points.length) this.#tested = new Int32Array(this.points.length);
-		const tested = this.#tested;
-		const stamp = ++this.#testStamp;
-		for (let r = this.#cell; r <= this.#cell * 8; r *= 2) {
-			const cands = [];
-			this.#pointGrid.query({
-				x: p.x - r,
-				y: p.y - r,
-				w: 2 * r,
-				h: 2 * r
-			}, (j) => {
-				if (j !== self && tested[j] !== stamp) cands.push([dist(p, this.points[j]), j]);
-			});
-			cands.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-			for (const [d, j] of cands) {
-				if (d > r) break;
-				tested[j] = stamp;
-				if (this.#obstacles.clear(p, this.points[j], this.#pad)) out.push(j);
-				if (out.length >= k) return out;
+		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 blockers = [];
+		const now = this.#near;
+		let wait = [];
+		let pi0 = 1;
+		let pi1 = 0;
+		let pj0 = 1;
+		let pj1 = 0;
+		for (let r = cell; r <= cell * 8; r *= 2) {
+			const x0 = p.x - r;
+			const y0 = p.y - r;
+			const i0 = Math.floor(x0 / cell);
+			const j0 = Math.floor(y0 / cell);
+			const i1 = Math.floor((x0 + 2 * r) / cell);
+			const j1 = Math.floor((y0 + 2 * r) / cell);
+			const later = [];
+			now.clear();
+			for (const j of wait) if (dd[j] > r) later.push(j);
+			else now.add(dd[j], j);
+			for (let bi = i0; bi <= i1; bi++) {
+				const before = bi >= pi0 && bi <= pi1;
+				for (let bj = j0; bj <= j1; bj++) {
+					if (before && bj >= pj0 && bj <= pj1) continue;
+					const list = this.#buckets.get(bucketKey(bi, bj));
+					if (list === void 0) continue;
+					for (const j of list) {
+						if (j === self) continue;
+						const d = dist(p, points[j]);
+						dd[j] = d;
+						if (d > r) later.push(j);
+						else now.add(d, j);
+					}
+				}
 			}
+			now.build();
+			while (now.size > 0) {
+				const j = now.pop();
+				const q = points[j];
+				let blocked = false;
+				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
+				if (blocked) continue;
+				const hit = this.#obstacles.hit(p, q, pad);
+				if (hit !== void 0) blockers.push(hit);
+				else {
+					out.push(j);
+					if (out.length >= k) return out;
+				}
+			}
+			wait = later;
+			pi0 = i0;
+			pi1 = i1;
+			pj0 = j0;
+			pj1 = j1;
 		}
 		return out;
 	}
@@ -909,6 +1152,35 @@ var CornerGraph = class {
 	*/
 	path(from, to, cost, floor = 1) {
 		if (this.#obstacles.clear(from, to, this.#pad)) return [from, to];
+		return this.#search([{
+			point: from,
+			cost: 0
+		}], [{
+			point: to,
+			cost: 0
+		}], cost, floor, this.#k * 2)?.points;
+	}
+	/**
+	* This method gives the shortest path from a point of `from` to a point of `to`, or `undefined` when the graph has none.
+	* The cost of a path includes the costs of its two points. One search finds the path, so this method is faster than a call of `path` for each pair.
+	*/
+	pathAmong(from, to) {
+		const found = this.#search(from, to, void 0, 1, this.#k);
+		const lines = [];
+		from.forEach((a, i) => to.forEach((b, k) => {
+			const c = a.cost + dist(a.point, b.point) + b.cost;
+			if (!found || c < found.cost) lines.push({
+				points: [a.point, b.point],
+				from: i,
+				to: k,
+				cost: c
+			});
+		}));
+		lines.sort((u, v) => u.cost - v.cost);
+		return lines.find((l) => this.#obstacles.clear(l.points[0], l.points[1], this.#pad)) ?? found;
+	}
+	/** This method is the search (A*) of `path` and `pathAmong`. */
+	#search(from, to, cost, floor, count) {
 		const n = this.points.length;
 		if (this.#g.length < n) {
 			this.#g = new Float64Array(n);
@@ -917,28 +1189,51 @@ var CornerGraph = class {
 			this.#closed = new Int32Array(n);
 		}
 		const stamp = ++this.#stamp;
+		const points = this.points;
 		const goal = /* @__PURE__ */ new Map();
-		for (const j of this.nearestVisible(to, this.#k * 2)) goal.set(j, dist(this.points[j], to));
+		const goalOf = /* @__PURE__ */ new Map();
+		to.forEach((b, k) => {
+			for (const j of this.#ends(b.point, count)) {
+				const tail = dist(points[j], b.point) + b.cost;
+				const now = goal.get(j);
+				if (now === void 0 || tail < now) {
+					goal.set(j, tail);
+					goalOf.set(j, k);
+				}
+			}
+		});
 		if (goal.size === 0) return void 0;
+		const starts = from.map((a) => this.#ends(a.point, count));
+		if (!starts.some((list) => this.#joined(list, goal))) return void 0;
 		const heap = new MinHeap();
-		const h = (i) => floor * dist(this.points[i], to);
+		const G = this.#g;
+		const parentOf = this.#parent;
+		const open = this.#open;
+		const closed = this.#closed;
+		const estimate = (p) => {
+			let h = Infinity;
+			for (const b of to) h = Math.min(h, dist(p, b.point));
+			return floor * h;
+		};
 		const relax = (j, g, parent) => {
-			if (this.#closed[j] === stamp) return;
-			if (this.#open[j] === stamp && this.#g[j] <= g) return;
-			this.#open[j] = stamp;
-			this.#g[j] = g;
-			this.#parent[j] = parent;
-			heap.push(g + h(j), j);
+			if (closed[j] === stamp) return;
+			if (open[j] === stamp && G[j] <= g) return;
+			open[j] = stamp;
+			G[j] = g;
+			parentOf[j] = parent;
+			heap.push(g + estimate(points[j]), j);
 		};
-		for (const j of this.nearestVisible(from, this.#k * 2)) relax(j, dist(from, this.points[j]), -1);
+		from.forEach((a, i) => {
+			for (const j of starts[i]) relax(j, a.cost + dist(a.point, points[j]), -1 - i);
+		});
 		let best = Infinity;
 		let bestEnd = -1;
 		while (heap.size > 0) {
 			if (heap.topKey >= best) break;
 			const i = heap.pop();
-			if (this.#closed[i] === stamp) continue;
-			this.#closed[i] = stamp;
-			const gi = this.#g[i];
+			if (closed[i] === stamp) continue;
+			closed[i] = stamp;
+			const gi = G[i];
 			const tail = goal.get(i);
 			if (tail !== void 0 && gi + tail < best) {
 				best = gi + tail;
@@ -948,15 +1243,69 @@ var CornerGraph = class {
 			const len = this.#len[i];
 			for (let m = 0; m < adj.length; m++) {
 				const j = adj[m];
+				if (closed[j] === stamp) continue;
 				const d = len[m];
 				relax(j, gi + (cost ? cost(i, j, d) : d), i);
 			}
 		}
 		if (bestEnd < 0) return void 0;
-		const out = [to];
-		for (let i = bestEnd; i >= 0; i = this.#parent[i]) out.push(this.points[i]);
-		out.push(from);
-		return out.reverse();
+		const k = goalOf.get(bestEnd);
+		const out = [to[k].point];
+		for (let i = bestEnd;; i = parentOf[i]) {
+			out.push(points[i]);
+			if (parentOf[i] < 0) {
+				const f = -1 - parentOf[i];
+				out.push(from[f].point);
+				return {
+					points: out.reverse(),
+					from: f,
+					to: k,
+					cost: best
+				};
+			}
+		}
+	}
+	/** This method tells if a corner of `starts` and a corner of `goal` are in one connected part of the graph. */
+	#joined(starts, goal) {
+		const part = this.#part ??= this.#parts();
+		const goals = /* @__PURE__ */ new Set();
+		for (const j of goal.keys()) goals.add(part[j]);
+		for (const j of starts) if (goals.has(part[j])) return true;
+		return false;
+	}
+	/** This method gives the number of the connected part of each corner. */
+	#parts() {
+		const part = new Int32Array(this.points.length).fill(-1);
+		const stack = [];
+		let count = 0;
+		for (let i = 0; i < part.length; i++) {
+			if (part[i] !== -1) continue;
+			part[i] = count;
+			stack.push(i);
+			while (stack.length > 0) for (const j of this.#adj[stack.pop()]) {
+				if (part[j] !== -1) continue;
+				part[j] = count;
+				stack.push(j);
+			}
+			count++;
+		}
+		return part;
+	}
+	/**
+	* This method gives at most `count` corners that an end of a path can see. An end near a box sees no corner with the clearance.
+	* Then the end takes the corners that it sees without the clearance, so the path does not cut through the boxes.
+	* The graph does not change, so the method keeps the corners of each end.
+	*/
+	#ends(p, count) {
+		const cache = count === this.#k * 2 ? this.#endCache : this.#fewCache;
+		const key = `${p.x},${p.y}`;
+		let out = cache.get(key);
+		if (!out) {
+			out = this.nearestVisible(p, count);
+			if (out.length === 0) out = this.#nearestVisible(p, count, -1, 0);
+			cache.set(key, out);
+		}
+		return out;
 	}
 	/** This method removes the vertices that a later vertex makes needless: from each vertex, it goes to the farthest vertex in view. */
 	pull(p, lookahead = 16) {
@@ -972,61 +1321,85 @@ var CornerGraph = class {
 		return out;
 	}
 };
-/** A binary min-heap of (key, value) pairs. Equal keys come out by the smaller value, so the order is deterministic. */
+/** 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);
+/**
+* A binary min-heap of (key, value) pairs in typed arrays. The pairs come out by key, and equal keys by value, so the order is deterministic.
+* The method `push` adds a pair to the heap. The method `add` only appends a pair, and the method `build` then makes the heap of all the pairs.
+*/
 var MinHeap = class {
-	#k = [];
-	#v = [];
-	get size() {
-		return this.#k.length;
-	}
-	#less(a, b) {
-		return this.#k[a] < this.#k[b] || this.#k[a] === this.#k[b] && this.#v[a] < this.#v[b];
-	}
-	#swap(a, b) {
-		const k = this.#k[a];
-		this.#k[a] = this.#k[b];
-		this.#k[b] = k;
-		const v = this.#v[a];
-		this.#v[a] = this.#v[b];
-		this.#v[b] = v;
-	}
+	#d = /* @__PURE__ */ new Float64Array(64);
+	#j = /* @__PURE__ */ new Int32Array(64);
+	size = 0;
 	/** The smallest key. */
 	get topKey() {
-		return this.#k[0];
+		return this.#d[0];
 	}
 	push(key, value) {
-		this.#k.push(key);
-		this.#v.push(value);
-		let i = this.#k.length - 1;
+		this.add(key, value);
+		const d = this.#d;
+		const jj = this.#j;
+		let i = this.size - 1;
 		while (i > 0) {
 			const p = i - 1 >> 1;
-			if (!this.#less(i, p)) break;
-			this.#swap(i, p);
+			if (!(key < d[p] || key === d[p] && value < jj[p])) break;
+			d[i] = d[p];
+			jj[i] = jj[p];
 			i = p;
 		}
+		d[i] = key;
+		jj[i] = value;
+	}
+	clear() {
+		this.size = 0;
+	}
+	add(d, j) {
+		if (this.size === this.#d.length) {
+			const dd = new Float64Array(2 * this.size);
+			dd.set(this.#d);
+			this.#d = dd;
+			const jj = new Int32Array(2 * this.size);
+			jj.set(this.#j);
+			this.#j = jj;
+		}
+		this.#d[this.size] = d;
+		this.#j[this.size] = j;
+		this.size++;
+	}
+	build() {
+		for (let i = (this.size >> 1) - 1; i >= 0; i--) this.#down(i);
 	}
 	/** This method removes the pair with the smallest key and gives its value. */
 	pop() {
-		const top = this.#v[0];
-		const k = this.#k.pop();
-		const v = this.#v.pop();
-		if (this.#k.length > 0) {
-			this.#k[0] = k;
-			this.#v[0] = v;
-			let i = 0;
-			for (;;) {
-				const l = 2 * i + 1;
-				const r = l + 1;
-				let m = i;
-				if (l < this.#k.length && this.#less(l, m)) m = l;
-				if (r < this.#k.length && this.#less(r, m)) m = r;
-				if (m === i) break;
-				this.#swap(i, m);
-				i = m;
-			}
+		const top = this.#j[0];
+		this.size--;
+		if (this.size > 0) {
+			this.#d[0] = this.#d[this.size];
+			this.#j[0] = this.#j[this.size];
+			this.#down(0);
 		}
 		return top;
 	}
+	#down(i) {
+		const d = this.#d;
+		const jj = this.#j;
+		const n = this.size;
+		const di = d[i];
+		const ji = jj[i];
+		for (;;) {
+			const l = 2 * i + 1;
+			if (l >= n) break;
+			const r = l + 1;
+			let m = l;
+			if (r < n && (d[r] < d[l] || d[r] === d[l] && jj[r] < jj[l])) m = r;
+			if (!(d[m] < di || d[m] === di && jj[m] < ji)) break;
+			d[i] = d[m];
+			jj[i] = jj[m];
+			i = m;
+		}
+		d[i] = di;
+		jj[i] = ji;
+	}
 };
 // src/ways.ts
 /**
@@ -1492,162 +1865,888 @@ const plugsRouter = {
 		return { routes };
 	}
 };
-// src/routers/sections.ts
-const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+// src/bench/properties.ts
+/** The tolerance of the hard rules, in units of the plane. */
+const TOLERANCE = .5;
 /**
-* This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
-* An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
-* Each way from hub to hub is found one time, so all the edges on it share its points.
-* The edges in one section of the lowest level go straight around the nodes. The result gives one zoom level for each depth of the tree.
+* 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.
 */
-function sectionsRouter(options) {
-	const router = {
-		name: options.name,
-		route(graph) {
-			const stretch = options.stretch ?? 2;
-			const byId = nodeIndex(graph);
-			const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
-			const ways = new WayFinder(graph.nodes, options);
-			const corners = ways.corners;
-			const root = buildSections(graph.nodes, options);
-			const parent = /* @__PURE__ */ new Map();
-			const leafOf = [];
-			for (const s of allSections(root)) {
-				for (const c of s.children) parent.set(c, s);
-				if (s.children.length === 0) for (const i of s.nodes) leafOf[i] = s;
-			}
-			const hubs = /* @__PURE__ */ new Map();
-			const hub = (s) => {
-				let h = hubs.get(s);
-				if (!h) {
-					let x = 0;
-					let y = 0;
-					for (const i of s.nodes) {
-						const c = center(graph.nodes[i].box);
-						x += c.x;
-						y += c.y;
-					}
-					const c = {
-						x: x / Math.max(1, s.nodes.length),
-						y: y / Math.max(1, s.nodes.length)
-					};
-					const j = corners.nearest(c);
-					h = j >= 0 ? corners.points[j] : c;
-					hubs.set(s, h);
-				}
-				return h;
-			};
-			const up = (s) => {
-				const out = [];
-				for (let x = s; x; x = parent.get(x)) out.push(x);
-				return out;
-			};
-			const pieces = /* @__PURE__ */ new Map();
-			const users = /* @__PURE__ */ new Map();
-			const piece = (ka, a, kb, b, used) => {
-				const forward = ka <= kb;
-				const key = forward ? `${ka}>${kb}` : `${kb}>${ka}`;
-				let p = pieces.get(key);
-				if (!p) {
-					const [from, to] = forward ? [a, b] : [b, a];
-					const way = corners.path(from, to);
-					p = dedupe$1(way ? corners.pull(way) : [from, to]);
-					pieces.set(key, p);
-				}
-				if (!used.includes(key)) used.push(key);
-				return forward ? p : [...p].reverse();
-			};
-			const at = (p) => `${p.x},${p.y}`;
-			const routes = [];
-			const marks = /* @__PURE__ */ new Map();
-			for (const e of graph.edges) {
-				const s = byId.get(e.source.node);
-				const t = byId.get(e.target.node);
-				const iu = indexOfNode.get(e.source.node);
-				const iv = indexOfNode.get(e.target.node);
-				if (!s || !t || iu === void 0 || iv === void 0) continue;
-				const ps = placePlug(s, e.source, center(t.box));
-				const pt = placePlug(t, e.target, center(s.box));
-				const lu = leafOf[iu];
-				const lv = leafOf[iv];
-				if (lu === lv) {
-					routes.push({
-						edge: e.id,
-						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
-					});
-					continue;
-				}
-				const a = up(lu);
-				const b = up(lv);
-				const common = new Set(b);
-				const lca = a.find((x) => common.has(x));
-				const keep = options.hubs ?? Infinity;
-				const side = (list) => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
-				const chain = [...side(a), ...side(b).reverse()];
-				const out = [ps.point];
-				const mark = /* @__PURE__ */ new Map();
-				const append = (p) => {
-					for (const q of p) if (dist(q, out[out.length - 1]) > 1e-9) out.push(q);
-				};
-				const used = [];
-				const start = ways.out(ps);
-				append(piece(at(start), start, chain[0].id, hub(chain[0]), used));
-				mark.set(chain[0], out.length - 1);
-				for (let i = 1; i < chain.length; i++) {
-					append(piece(chain[i - 1].id, hub(chain[i - 1]), chain[i].id, hub(chain[i]), used));
-					mark.set(chain[i], out.length - 1);
-				}
-				const end = ways.out(pt);
-				append(piece(chain[chain.length - 1].id, hub(chain[chain.length - 1]), at(end), end, used));
-				append([pt.point]);
-				if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin) {
-					routes.push({
-						edge: e.id,
-						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
-					});
-					continue;
-				}
-				for (const key of used) {
-					const list = users.get(key);
-					if (list) list.push(e.id);
-					else users.set(key, [e.id]);
-				}
-				routes.push({
-					edge: e.id,
-					points: out
-				});
-				marks.set(e.id, mark);
-			}
-			const routeOf = new Map(routes.map((r) => [r.edge, r]));
-			const runs = [];
-			for (const [key, p] of pieces) {
-				const list = users.get(key) ?? [];
-				if (list.length < 2 || p.length < 2) continue;
-				runs.push({
-					id: `r${runs.length}`,
-					key,
-					points: p,
-					edges: orderLanes(p, list.map((id) => routeOf.get(id)))
-				});
-			}
-			return {
-				routes,
-				runs,
-				levels: makeLevels(graph, root, routeOf, marks)
-			};
-		}
-	};
-	return options.maxNodes === void 0 ? router : {
-		...router,
-		maxNodes: options.maxNodes
+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;
+		}
+		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;
+			}
+		}
+	}
+	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/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;
+/** A link goes out and back only when its distance to its target grows by more than this number of units. */
+const BACKTRACK_MIN = 40;
+/** The default `slack` of `LinkFaultOptions`. */
+const OUTSIDE_SLACK = 24;
+/**
+* This function gives the largest growth of the distance to the last point of a polyline.
+* The growth at a vertex is its distance to the last point, less the nearest approach of the polyline before that vertex.
+*/
+function backtrackOf(p) {
+	if (p.length < 3) return 0;
+	const end = p[p.length - 1];
+	let near = dist(p[0], end);
+	let worst = 0;
+	for (let i = 1; i < p.length; i++) {
+		worst = Math.max(worst, dist(p[i], end) - near);
+		near = Math.min(near, pointSegmentDistance(end, p[i - 1], p[i]));
+	}
+	return worst;
+}
+/** This function tells if the polyline `p` goes out and back: `backtrackOf(p)` is more than `BACKTRACK_MIN` and more than `BACKTRACK_SHARE` of the span. */
+function goesOutAndBack(p) {
+	if (p.length < 3) return false;
+	const span = dist(p[0], p[p.length - 1]);
+	return backtrackOf(p) > Math.max(40, BACKTRACK_SHARE * span);
+}
+/**
+* This function measures the faults of links between boxes. The map `boxes` gives the box of each end.
+* The bounding box of `outside` is the bounding box of all the boxes of the map.
+*/
+function measureLinks(boxes, links, options = {}) {
+	const slack = options.slack ?? 24;
+	let size = 0;
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const b of boxes.values()) {
+		size += Math.max(b.w, b.h);
+		x0 = Math.min(x0, b.x);
+		y0 = Math.min(y0, b.y);
+		x1 = Math.max(x1, b.x + b.w);
+		y1 = Math.max(y1, b.y + b.h);
+	}
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.size)));
+	for (const [id, b] of boxes) grid.add(id, b);
+	let through = 0;
+	let backtrack = 0;
+	let worstDetour = 0;
+	let outside = 0;
+	for (const l of links) {
+		const p = l.points;
+		if (p.length === 0) continue;
+		let hit = false;
+		for (let i = 1; i < p.length && !hit; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			grid.querySegment(a, b, 0, (id) => {
+				if (!hit && id !== l.source && id !== l.target && segmentHitsBox(a, b, inflate(boxes.get(id), -.5), .5)) hit = true;
+			});
+		}
+		if (hit) through++;
+		if (goesOutAndBack(p)) backtrack++;
+		const span = dist(p[0], p[p.length - 1]);
+		if (span > 1) worstDetour = Math.max(worstDetour, polylineLength(p) / span);
+		if (p.some((q) => q.x < x0 - slack || q.x > x1 + slack || q.y < y0 - slack || q.y > y1 + slack)) outside++;
+	}
+	return {
+		links: links.length,
+		through,
+		backtrack,
+		worstDetour,
+		outside
+	};
+}
+/** This function measures the faults of the routes of a result. The ends of a route are the nodes of its edge. */
+function measureRouteFaults(graph, result, options = {}) {
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	const links = [];
+	for (const r of result.routes) {
+		const e = edges.get(r.edge);
+		if (e) links.push({
+			source: e.source.node,
+			target: e.target.node,
+			points: r.points
+		});
+	}
+	return measureLinks(boxes, links, options);
+}
+/** This function counts the pairs of boxes that overlap by more than `TOLERANCE` on each axis. */
+function countOverlaps(boxes) {
+	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)));
+	boxes.forEach((b, i) => grid.add(i, b));
+	let n = 0;
+	boxes.forEach((a, i) => {
+		grid.query(a, (j) => {
+			const b = boxes[j];
+			if (j > i && Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x) > .5 && Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > .5) n++;
+		});
+	});
+	return n;
+}
+/** This function measures the faults of the links of one zoom level. The items of the level are the boxes. */
+function measureLevel(level, options = {}) {
+	const boxes = new Map(level.items.map((i) => [i.id, i.box]));
+	return {
+		depth: level.depth,
+		items: level.items.length,
+		groups: level.items.filter((i) => i.nodes.length > 1).length,
+		overlaps: countOverlaps(level.items.map((i) => i.box)),
+		...measureLinks(boxes, level.links, options)
+	};
+}
+/**
+* This function measures the faults of each zoom level of a result that has groups: the levels of the far view.
+* A level of single nodes only is the near view. Its links are routes, and `measureRouteFaults` measures them.
+*/
+function measureLevelFaults(result, options = {}) {
+	return (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1)).map((l) => measureLevel(l, options));
+}
+/** This function adds the faults of several levels: it sums the counts and keeps the largest `worstDetour`. */
+function sumFaults(list) {
+	return list.reduce((s, f) => ({
+		links: s.links + f.links,
+		through: s.through + f.through,
+		backtrack: s.backtrack + f.backtrack,
+		worstDetour: Math.max(s.worstDetour, f.worstDetour),
+		outside: s.outside + f.outside
+	}), {
+		links: 0,
+		through: 0,
+		backtrack: 0,
+		worstDetour: 0,
+		outside: 0
+	});
+}
+// src/levels.ts
+/** The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through. */
+const TIGHT_MARGIN = 1;
+const EPS = 1e-6;
+/**
+* This function removes the repeated points, the points in the middle of a straight run,
+* and the points where the way turns back on itself.
+*/
+function tidy(p) {
+	const out = [];
+	for (const q of p) {
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		while (out.length >= 2) {
+			const a = out[out.length - 2];
+			const b = out[out.length - 1];
+			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
+			if (Math.abs(cross) > EPS * (1 + dist(a, b) * dist(b, q))) break;
+			out.pop();
+		}
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		out.push(q);
+	}
+	return out;
+}
+/**
+* This function gives the links of one level. The items of the level are the obstacles.
+* A link starts on the boundary of the box of its source and ends on the boundary of the box of its target.
+* It goes around the boxes of the other items. Where there is space, its legs are parallel to the axes.
+*/
+function levelLinks(items, pairs, options = {}) {
+	if (pairs.length === 0) return [];
+	const nodes = items.map((i) => ({
+		id: i.id,
+		box: i.box
+	}));
+	const byId = new Map(nodes.map((n) => [n.id, n]));
+	const ways = levelWays(nodes, options);
+	const inset = Math.min(6, ways.margin);
+	const out = [];
+	for (const p of pairs) {
+		const s = byId.get(p.source);
+		const t = byId.get(p.target);
+		if (!s || !t) continue;
+		const [fs, ft] = facingPlugs(s.box, t.box, inset);
+		let points = isFree(ways, s, fs) && isFree(ways, t, ft) ? quickWay(ways, ends(ways, s, fs, t, ft)) : void 0;
+		points ??= sideWay(ways, s, t, inset);
+		out.push({
+			source: p.source,
+			target: p.target,
+			count: p.count,
+			points
+		});
+	}
+	return out;
+}
+/**
+* This function gives a way from plug to plug between the plugs at the middle of a side of the two nodes.
+* Without a way in the corner graph, the link goes straight between the ends, with legs parallel to the axes where they are clear.
+* When that line goes through another box, the link goes between the free plugs of the two nodes (`freeWay`) instead.
+*/
+function sideWay(ways, s, t, inset) {
+	const e = ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box)));
+	const quick = quickWay(ways, e);
+	if (quick) return quick;
+	const path = ways.corners.path(e.a, e.b);
+	const way = pulled(ways, e.ps, path ?? [e.a, e.b], e.pt);
+	if (path || ways.obstacles.clearPath(way, 0, /* @__PURE__ */ new Set([s, t]))) return way;
+	return freeWay(ways, s, t, inset) ?? way;
+}
+/**
+* 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.
+*/
+function levelWays(nodes, options) {
+	const margin = options.margin ?? 5;
+	const k = options.k ?? 8;
+	let size = 0;
+	for (const n of nodes) size += Math.max(n.box.w, n.box.h);
+	const obstacles = new Obstacles(nodes, Math.max(180, 2 * size / Math.max(1, nodes.length)));
+	const corners = new CornerGraph(nodes, obstacles, {
+		margin,
+		k
+	});
+	const out = (p) => ({
+		x: p.point.x + p.normal.x * margin,
+		y: p.point.y + p.normal.y * margin
+	});
+	let tight;
+	const tightGraph = () => tight ??= new CornerGraph(nodes, obstacles, {
+		margin: Math.min(margin, TIGHT_MARGIN),
+		k
+	});
+	return {
+		obstacles,
+		corners,
+		margin,
+		out,
+		tight: tightGraph,
+		free: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* This function gives the plugs of a link between two boxes. Each plug is on the side that faces the other box.
+* When the two sides face each other and their spans overlap, both plugs are at the middle of the overlap, so the link is straight.
+*/
+function facingPlugs(a, b, inset) {
+	const sa = sideToward(a, center(b));
+	const sb = sideToward(b, center(a));
+	const plug = (box, side, toward) => ({
+		point: pointOnSide(box, side, toward, inset),
+		normal: SIDE_NORMAL[side]
+	});
+	const across = sa === "east" && sb === "west" || sa === "west" && sb === "east";
+	if (across || sa === "south" && sb === "north" || sa === "north" && sb === "south") {
+		const lo = across ? Math.max(a.y, b.y) + inset : Math.max(a.x, b.x) + inset;
+		const hi = across ? Math.min(a.y + a.h, b.y + b.h) - inset : Math.min(a.x + a.w, b.x + b.w) - inset;
+		if (lo <= hi) {
+			const ca = center(a);
+			const cb = center(b);
+			const m = Math.max(lo, Math.min(hi, across ? (ca.y + cb.y) / 2 : (ca.x + cb.x) / 2));
+			const at = (box, side) => across ? {
+				x: side === "east" ? box.x + box.w : box.x,
+				y: m
+			} : {
+				x: m,
+				y: side === "south" ? box.y + box.h : box.y
+			};
+			return [{
+				point: at(a, sa),
+				normal: SIDE_NORMAL[sa]
+			}, {
+				point: at(b, sb),
+				normal: SIDE_NORMAL[sb]
+			}];
+		}
+	}
+	return [plug(a, sa, center(b)), plug(b, sb, center(a))];
+}
+const SIDES = [
+	"north",
+	"east",
+	"south",
+	"west"
+];
+/** This function tells if the way out of a plug is free. The plug and the point at `margin` from it are in no other box. */
+function isFree(ways, node, plug) {
+	return !ways.obstacles.inside(ways.out(plug), 0, node) && !ways.obstacles.inside(plug.point, 0, node);
+}
+/** This function gives the plug at the middle of a side of the node: the side with a free way out that faces `toward` most. */
+function sidePlug(ways, node, toward) {
+	const b = node.box;
+	const c = center(b);
+	const d = {
+		x: toward.x - c.x,
+		y: toward.y - c.y
+	};
+	const facing = (s) => SIDE_NORMAL[s].x * d.x + SIDE_NORMAL[s].y * d.y;
+	const order = [...SIDES].sort((u, v) => facing(v) - facing(u));
+	const plug = (s) => {
+		const n = SIDE_NORMAL[s];
+		return {
+			point: {
+				x: c.x + n.x * b.w / 2,
+				y: c.y + n.y * b.h / 2
+			},
+			normal: n
+		};
+	};
+	for (const s of order) if (isFree(ways, node, plug(s))) return plug(s);
+	return plug(order[0]);
+}
+/**
+* This function gives the free plugs of a node: on each side, the free point nearest to the middle of the side.
+* A point is free when it and the point at `margin` from it are in no other box. The function keeps the plugs of each node.
+*/
+function freePlugs(ways, node, inset) {
+	const known = ways.free.get(node);
+	if (known) return known;
+	const b = node.box;
+	const out = [];
+	for (const side of SIDES) {
+		const n = SIDE_NORMAL[side];
+		const across = n.x === 0;
+		const lo = across ? b.x : b.y;
+		const hi = across ? b.x + b.w : b.y + b.h;
+		const at = across ? n.y > 0 ? b.y + b.h : b.y : n.x > 0 ? b.x + b.w : b.x;
+		const far = at + (across ? n.y : n.x) * ways.margin;
+		const covered = [];
+		const strip = across ? {
+			x: lo,
+			y: Math.min(at, far),
+			w: hi - lo,
+			h: Math.abs(far - at)
+		} : {
+			x: Math.min(at, far),
+			y: lo,
+			w: Math.abs(far - at),
+			h: hi - lo
+		};
+		ways.obstacles.query(strip, (m) => {
+			if (m === node) return;
+			const o = m.box;
+			const [o0, o1, p0, p1] = across ? [
+				o.x,
+				o.x + o.w,
+				o.y,
+				o.y + o.h
+			] : [
+				o.y,
+				o.y + o.h,
+				o.x,
+				o.x + o.w
+			];
+			if (at > p0 && at < p1 || far > p0 && far < p1) covered.push([o0, o1]);
+		});
+		const mid = (lo + hi) / 2;
+		let best;
+		for (const [f0, f1] of freeSpans(lo, hi, covered)) {
+			const room = Math.min(inset, (f1 - f0) / 2);
+			const u = Math.max(f0 + room, Math.min(f1 - room, mid));
+			if (best === void 0 || Math.abs(u - mid) < Math.abs(best - mid)) best = u;
+		}
+		if (best !== void 0) out.push({
+			point: across ? {
+				x: best,
+				y: at
+			} : {
+				x: at,
+				y: best
+			},
+			normal: n
+		});
+	}
+	const free = {
+		plugs: out,
+		reach: out.map((p) => reach(ways, node, p))
+	};
+	ways.free.set(node, free);
+	return free;
+}
+/** This function gives the indices of the plugs, and the plugs that face `toward` most come first. */
+function facingOrder(plugs, from, toward) {
+	const facing = (p) => p.normal.x * (toward.x - from.x) + p.normal.y * (toward.y - from.y);
+	return plugs.map((_, i) => i).sort((u, v) => facing(plugs[v]) - facing(plugs[u]) || u - v);
+}
+/** This function gives the parts of the span from `lo` to `hi` outside each open interval of `covered`. A part of zero length does not count. */
+function freeSpans(lo, hi, covered) {
+	covered.sort((u, v) => u[0] - v[0]);
+	const out = [];
+	let x = lo;
+	for (const [c0, c1] of covered) {
+		if (c0 > x) out.push([x, Math.min(c0, hi)]);
+		x = Math.max(x, c1);
+		if (x >= hi) break;
+	}
+	if (x < hi) out.push([x, hi]);
+	return out.filter(([a, b]) => b - a > EPS);
+}
+/**
+* This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
+* A link uses it when its plugs at the middle of a side find no way. Other boxes can cover such a plug, or close the space in front of it.
+*/
+function freeWay(ways, s, t, inset) {
+	const fs = freePlugs(ways, s, inset);
+	const ft = freePlugs(ways, t, inset);
+	const cs = center(s.box);
+	const ct = center(t.box);
+	const is = facingOrder(fs.plugs, cs, ct);
+	const it = facingOrder(ft.plugs, ct, cs);
+	const from = is.map((i) => fs.plugs[i]);
+	const to = it.map((k) => ft.plugs[k]);
+	const ra = is.map((i) => fs.reach[i]);
+	const rb = it.map((k) => ft.reach[k]);
+	let best;
+	let bestLength = Infinity;
+	from.forEach((ps, i) => to.forEach((pt, k) => {
+		const way = quickWay(ways, endsAt(ps, ra[i], pt, rb[k]));
+		const length = way ? polylineLength(way) : Infinity;
+		if (length < bestLength) {
+			best = way;
+			bestLength = length;
+		}
+	}));
+	if (best) return best;
+	const a = from.map((ps, i) => ({
+		point: along(ps, ra[i]),
+		cost: ra[i]
+	}));
+	const b = to.map((pt, k) => ({
+		point: along(pt, rb[k]),
+		cost: rb[k]
+	}));
+	const found = ways.tight().pathAmong(a, b);
+	return found && pulled(ways, from[found.from], found.points, to[found.to]);
+}
+/**
+* This function gives the ends of a link. The link leaves each plug along its normal for the margin.
+* A box can be nearer than twice the margin in front of a plug. Then the link turns in the middle of the space before that box.
+* Two plugs that face each other across a narrow space make the link turn in the middle of that space.
+*/
+function ends(ways, s, ps, t, pt) {
+	return endsAt(ps, reach(ways, s, ps), pt, reach(ways, t, pt));
+}
+/** This function gives the ends of a link from the plug `ps` to the plug `pt`, with the reach of each plug. */
+function endsAt(ps, ra, pt, rb) {
+	if (ps.normal.x === -pt.normal.x && ps.normal.y === -pt.normal.y) {
+		const d = (pt.point.x - ps.point.x) * ps.normal.x + (pt.point.y - ps.point.y) * ps.normal.y;
+		if (d > 0 && ra + rb > d) ra = rb = d / 2;
+	}
+	return {
+		ps,
+		pt,
+		a: along(ps, ra),
+		b: along(pt, rb)
+	};
+}
+const along = (p, d) => ({
+	x: p.point.x + p.normal.x * d,
+	y: p.point.y + p.normal.y * d
+});
+/** This function gives the distance that a link goes along the normal of a plug before it turns. */
+function reach(ways, node, plug) {
+	const skip = /* @__PURE__ */ new Set([node]);
+	const far = 2 * ways.margin;
+	if (ways.obstacles.clear(plug.point, along(plug, far), 0, skip)) return ways.margin;
+	let lo = 0;
+	let hi = far;
+	for (let i = 0; i < 10; i++) {
+		const m = (lo + hi) / 2;
+		if (ways.obstacles.clear(plug.point, along(plug, m), 0, skip)) lo = m;
+		else hi = m;
+	}
+	return lo / 2;
+}
+/**
+* This function gives the way between the ends when one or two legs parallel to the axes are clear, or `undefined`.
+* The legs keep half the margin from the boxes, or less when an end turns nearer to a box.
+*/
+function quickWay(ways, e) {
+	const near = Math.min(dist(e.ps.point, e.a), dist(e.pt.point, e.b));
+	const pad = Math.max(0, Math.min(ways.margin / 2, near - 1));
+	const legs = square(e.a, e.b, ways.obstacles, pad, axisOf(e.ps.normal), axisOf(e.pt.normal));
+	return legs && tidy([
+		e.ps.point,
+		e.a,
+		...legs,
+		e.pt.point
+	]);
+}
+/**
+* This function gives a way from the plug `ps` through the points of `path` to the plug `pt`.
+* The way leaves and enters each plug along its normal. Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
+*/
+function pulled(ways, ps, path, pt) {
+	const legs = squarePull(path, ways.obstacles, ways.margin / 2, axisOf(ps.normal), axisOf(pt.normal));
+	return tidy([
+		ps.point,
+		...legs,
+		pt.point
+	]);
+}
+const axisOf = (n) => Math.abs(n.x) > Math.abs(n.y) ? "x" : "y";
+/**
+* This function pulls a path tight. From each vertex, it goes to the farthest vertex that one or two legs can reach.
+* These legs are parallel to the axes and clear of the obstacles by `pad`. It keeps a diagonal leg only where no such legs are clear.
+* `first` is the axis of the way into the first vertex, and `last` is the axis of the way out of the last vertex.
+*/
+function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
+	if (p.length === 0) return [];
+	const out = [p[0]];
+	let axis = first;
+	let i = 0;
+	while (i < p.length - 1) {
+		let step;
+		for (let j = Math.min(p.length - 1, i + lookahead); j > i && !step; j--) {
+			const legs = square(p[i], p[j], obstacles, pad, axis, j === p.length - 1 ? last : void 0);
+			if (legs) step = {
+				j,
+				legs
+			};
+		}
+		step ??= {
+			j: i + 1,
+			legs: square(p[i], p[i + 1], obstacles, 0, axis, i + 1 === p.length - 1 ? last : void 0) ?? [p[i + 1]]
+		};
+		out.push(...step.legs);
+		const end = out[out.length - 1];
+		const before = out[out.length - 2];
+		axis = Math.abs(end.y - before.y) < EPS ? "x" : Math.abs(end.x - before.x) < EPS ? "y" : void 0;
+		i = step.j;
+	}
+	return out;
+}
+/**
+* This function gives one or two legs parallel to the axes from `a` to `b`, clear of the obstacles by `pad`, or `undefined`.
+* Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
+*/
+function square(a, b, obstacles, pad, from, to) {
+	if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	const options = [{
+		c: {
+			x: b.x,
+			y: a.y
+		},
+		bends: (from === "y" ? 1 : 0) + (to === "x" ? 1 : 0)
+	}, {
+		c: {
+			x: a.x,
+			y: b.y
+		},
+		bends: (from === "x" ? 1 : 0) + (to === "y" ? 1 : 0)
+	}];
+	options.sort((u, v) => u.bends - v.bends);
+	for (const { c } of options) if (obstacles.clear(a, c, pad) && obstacles.clear(c, b, pad)) return [c, b];
+}
+// src/routers/sections.ts
+const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+/**
+* A hub can be this many units farther from the target than the nearest approach of the way before it.
+* A hub farther away goes out and back, so the way skips it.
+*/
+const HUB_SLACK = 80;
+/**
+* This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+* An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+* Each way from hub to hub is found one time, so all the edges on it share its points.
+* The edges in one section of the lowest level go straight around the nodes.
+*
+* An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+*
+* The result gives one zoom level for each depth of the tree.
+* A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+*/
+function sectionsRouter(options) {
+	const router = {
+		name: options.name,
+		route(graph) {
+			const stretch = options.stretch ?? 2;
+			const byId = nodeIndex(graph);
+			const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+			const ways = new WayFinder(graph.nodes, options);
+			const corners = ways.corners;
+			const root = buildSections(graph.nodes, options);
+			const parent = /* @__PURE__ */ new Map();
+			const leafOf = [];
+			for (const s of allSections(root)) {
+				for (const c of s.children) parent.set(c, s);
+				if (s.children.length === 0) for (const i of s.nodes) leafOf[i] = s;
+			}
+			const hubs = /* @__PURE__ */ new Map();
+			const hub = (s) => {
+				let h = hubs.get(s);
+				if (!h) {
+					let x = 0;
+					let y = 0;
+					for (const i of s.nodes) {
+						const c = center(graph.nodes[i].box);
+						x += c.x;
+						y += c.y;
+					}
+					const c = {
+						x: x / Math.max(1, s.nodes.length),
+						y: y / Math.max(1, s.nodes.length)
+					};
+					const j = corners.nearest(c);
+					h = j >= 0 ? corners.points[j] : c;
+					hubs.set(s, h);
+				}
+				return h;
+			};
+			const forward = (list, from, to) => {
+				const kept = [];
+				let near = dist(from, to);
+				let last = from;
+				for (const c of list) {
+					const h = hub(c);
+					if (dist(h, to) > near + HUB_SLACK) continue;
+					near = Math.min(near, pointSegmentDistance(to, last, h));
+					last = h;
+					kept.push(c);
+				}
+				return kept;
+			};
+			const up = (s) => {
+				const out = [];
+				for (let x = s; x; x = parent.get(x)) out.push(x);
+				return out;
+			};
+			const pieces = /* @__PURE__ */ new Map();
+			const users = /* @__PURE__ */ new Map();
+			const piece = (ka, a, kb, b, used) => {
+				const forward = ka <= kb;
+				const key = forward ? `${ka}>${kb}` : `${kb}>${ka}`;
+				let p = pieces.get(key);
+				if (!p) {
+					const [from, to] = forward ? [a, b] : [b, a];
+					const way = corners.path(from, to);
+					p = dedupe$1(way ? corners.pull(way) : [from, to]);
+					pieces.set(key, p);
+				}
+				if (!used.includes(key)) used.push(key);
+				return forward ? p : [...p].reverse();
+			};
+			const at = (p) => `${p.x},${p.y}`;
+			const routes = [];
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				const iu = indexOfNode.get(e.source.node);
+				const iv = indexOfNode.get(e.target.node);
+				if (!s || !t || iu === void 0 || iv === void 0) continue;
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				const lu = leafOf[iu];
+				const lv = leafOf[iv];
+				if (lu === lv) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
+				const a = up(lu);
+				const b = up(lv);
+				const common = new Set(b);
+				const lca = a.find((x) => common.has(x));
+				const keep = options.hubs ?? Infinity;
+				const side = (list) => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
+				const end = ways.out(pt);
+				const start = ways.out(ps);
+				const chain = forward([...side(a), ...side(b).reverse()], start, pt.point);
+				if (chain.length === 0) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
+				const out = [ps.point];
+				const append = (p) => {
+					for (const q of p) if (dist(q, out[out.length - 1]) > 1e-9) out.push(q);
+				};
+				const used = [];
+				append(piece(at(start), start, chain[0].id, hub(chain[0]), used));
+				for (let i = 1; i < chain.length; i++) append(piece(chain[i - 1].id, hub(chain[i - 1]), chain[i].id, hub(chain[i]), used));
+				append(piece(chain[chain.length - 1].id, hub(chain[chain.length - 1]), at(end), end, used));
+				append([pt.point]);
+				if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin || goesOutAndBack(out)) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
+				for (const key of used) {
+					const list = users.get(key);
+					if (list) list.push(e.id);
+					else users.set(key, [e.id]);
+				}
+				routes.push({
+					edge: e.id,
+					points: out
+				});
+			}
+			const routeOf = new Map(routes.map((r) => [r.edge, r]));
+			const runs = [];
+			for (const [key, p] of pieces) {
+				const list = users.get(key) ?? [];
+				if (list.length < 2 || p.length < 2) continue;
+				runs.push({
+					id: `r${runs.length}`,
+					key,
+					points: p,
+					edges: orderLanes(p, list.map((id) => routeOf.get(id)))
+				});
+			}
+			return {
+				routes,
+				runs,
+				levels: makeLevels(graph, root, routeOf, options)
+			};
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
 	};
 }
 /**
 * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
 * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
-* Its points are the part of the route of its first edge between the two items.
+* In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
+* In the last level, the points of a link are the route of its first edge.
 */
-function makeLevels(graph, root, routeOf, marks) {
+function makeLevels(graph, root, routeOf, options) {
 	const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
 	const levels = [];
 	const deepest = treeDepth(root);
@@ -1709,21 +2808,30 @@ function makeLevels(graph, root, routeOf, marks) {
 				link.count++;
 				continue;
 			}
-			const route = routeOf.get(e.id)?.points ?? [];
-			const mark = marks.get(e.id);
-			const from = typeof a === "number" ? 0 : mark?.get(a) ?? 0;
-			const to = typeof b === "number" ? route.length - 1 : mark?.get(b) ?? route.length - 1;
 			links.set(key, {
 				source: ida,
 				target: idb,
 				count: 1,
-				points: route.slice(from, to + 1)
+				edge: e.id
 			});
 		}
-		levels.push({
+		const pairs = [...links.values()].map(({ source, target, count }) => ({
+			source,
+			target,
+			count
+		}));
+		if (d > deepest) levels.push({
 			depth: d,
 			items,
-			links: [...links.values()]
+			links: [...links.values()].map(({ edge, ...l }) => ({
+				...l,
+				points: routeOf.get(edge)?.points ?? []
+			}))
+		});
+		else levels.push({
+			depth: d,
+			items,
+			links: levelLinks(items, pairs, options)
 		});
 	}
 	return levels;
@@ -2156,134 +3264,6 @@ const ROUTERS = [
 		maxNodes: 1e5
 	})
 ];
-// src/bench/properties.ts
-/** The tolerance of the hard rules, in units of the plane. */
-const TOLERANCE = .5;
-/**
-* 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 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.
-*/
-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;
-		}
-		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;
-			}
-		}
-	}
-	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;
-		}
-	}
-	return out;
-}
-/** 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/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -2526,7 +3506,9 @@ function benchOne(router, fixture, graph, repeat = 3) {
 		deterministic,
 		violations: all.length,
 		sample: all.slice(0, 5),
-		quality: measureQuality(graph, result)
+		quality: measureQuality(graph, result),
+		faults: measureRouteFaults(graph, result),
+		levelFaults: measureLevelFaults(result)
 	};
 }
 /** This function writes the rows as a Markdown table. */
@@ -2543,6 +3525,33 @@ function formatTable(rows) {
 		})
 	].join("\n");
 }
-export { CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, dist, fixedPortPoint, formatTable, frechet, groupEdges, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, measureQuality, 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, treeDepth, trunksRouter, turns };
+/**
+* This function writes the faults of the rows as a Markdown table: the routes first, then the sum of the levels with groups.
+* A router without such levels gets a dash in the columns of the levels.
+*/
+function formatFaults(rows) {
+	return [
+		"| router | fixture | through | out and back | worst detour | outside | level links | level overlaps | level through | level out and back | level worst detour | level outside |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			const cells = [
+				r.router,
+				r.fixture,
+				f.through,
+				f.backtrack,
+				f.worstDetour.toFixed(2),
+				f.outside
+			];
+			if (r.levelFaults.length === 0) cells.push("-", "-", "-", "-", "-", "-");
+			else {
+				const l = sumFaults(r.levelFaults);
+				cells.push(l.links, r.levelFaults.reduce((s, x) => s + x.overlaps, 0), l.through, l.backtrack, l.worstDetour.toFixed(2), l.outside);
+			}
+			return `| ${cells.join(" | ")} |`;
+		})
+	].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 };
 
 //# sourceMappingURL=index.js.map