@mark1russell7/highways 0.1.2 → 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`. */
@@ -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,9 +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;
@@ -841,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. */
@@ -880,28 +1077,70 @@ var CornerGraph = class {
 	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], 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;
 	}
@@ -913,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);
@@ -921,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.#ends(to)) 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.#ends(from)) 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;
@@ -952,28 +1243,67 @@ 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 the corners that an end of a path can see. An end near a box sees no corner with the clearance.
+	* 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) {
+	#ends(p, count) {
+		const cache = count === this.#k * 2 ? this.#endCache : this.#fewCache;
 		const key = `${p.x},${p.y}`;
-		let out = this.#endCache.get(key);
+		let out = cache.get(key);
 		if (!out) {
-			out = this.nearestVisible(p, this.#k * 2);
-			if (out.length === 0) out = this.#nearestVisible(p, this.#k * 2, -1, 0);
-			this.#endCache.set(key, out);
+			out = this.nearestVisible(p, count);
+			if (out.length === 0) out = this.#nearestVisible(p, count, -1, 0);
+			cache.set(key, out);
 		}
 		return out;
 	}
@@ -991,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
 /**
@@ -1511,7 +1865,296 @@ const plugsRouter = {
 		return { routes };
 	}
 };
+// 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 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 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,
@@ -1554,7 +2197,7 @@ function levelLinks(items, pairs, options = {}) {
 		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 ??= squareWay(ways, ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box))));
+		points ??= sideWay(ways, s, t, inset);
 		out.push({
 			source: p.source,
 			target: p.target,
@@ -1565,25 +2208,49 @@ function levelLinks(items, pairs, options = {}) {
 	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: new CornerGraph(nodes, obstacles, {
-			margin,
-			k: options.k ?? 8
-		}),
+		corners,
 		margin,
-		out: (p) => ({
-			x: p.point.x + p.normal.x * margin,
-			y: p.point.y + p.normal.y * margin
-		})
+		out,
+		tight: tightGraph,
+		free: /* @__PURE__ */ new Map()
 	};
 }
 /**
@@ -1657,13 +2324,139 @@ function sidePlug(ways, node, toward) {
 	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) {
-	let ra = reach(ways, s, ps);
-	let rb = reach(ways, 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;
@@ -1709,17 +2502,15 @@ function quickWay(ways, e) {
 	]);
 }
 /**
-* This function gives a way from plug to plug through the corner graph. 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.
+* 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 squareWay(ways, e) {
-	const quick = quickWay(ways, e);
-	if (quick) return quick;
-	const legs = squarePull(ways.corners.path(e.a, e.b) ?? [e.a, e.b], ways.obstacles, ways.margin / 2, axisOf(e.ps.normal), axisOf(e.pt.normal));
+function pulled(ways, ps, path, pt) {
+	const legs = squarePull(path, ways.obstacles, ways.margin / 2, axisOf(ps.normal), axisOf(pt.normal));
 	return tidy([
-		e.ps.point,
+		ps.point,
 		...legs,
-		e.pt.point
+		pt.point
 	]);
 }
 const axisOf = (n) => Math.abs(n.x) > Math.abs(n.y) ? "x" : "y";
@@ -1779,11 +2570,18 @@ function square(a, b, obstacles, pad, from, to) {
 // 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.
 */
@@ -1824,6 +2622,19 @@ function sectionsRouter(options) {
 				}
 				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);
@@ -1869,19 +2680,26 @@ function sectionsRouter(options) {
 				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 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 = [];
-				const start = ways.out(ps);
 				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));
-				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) {
+				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]))
@@ -2446,152 +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 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 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/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -2834,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. */
@@ -2851,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