@mark1russell7/highways 0.9.3 → 0.9.4

package/build/index.js

@@ -5212,6 +5212,533 @@ function sideEnds(input, options = {}) {
 	}
 	return out;
 }
+// src/routers/gutter.ts
+/** The default cost of one bend of the gutter mode. */
+const GUTTER_BEND_COST = 16;
+const EPS$6 = 1e-6;
+/** The directions of a step: east, south, west and north, with the y axis down. */
+const DX = [
+	1,
+	0,
+	-1,
+	0
+];
+const DY = [
+	0,
+	1,
+	0,
+	-1
+];
+/**
+* This function gives the orthogonal route of each edge in the free room of a frame: the box `frame` minus the boxes of `nodes`.
+* Each route starts at the plug of the wall, and goes along the normal of the wall into the frame. It ends on a side of its end node.
+*
+* The route goes on a grid of lines. A line goes through the middle of each free band between the box edges, each plug and each entry.
+* A shortest path with a cost for each bend (`bendCost`) gives the route. Then the routes that share one gap get a lane each.
+* An edge without a path through the free room gets `undefined`.
+*/
+function gutterRoutes(frame, nodes, edges, options = {}) {
+	const bend = options.bendCost ?? 16;
+	const boxes = nodes.map((n) => n.box).filter((b) => b.w > EPS$6 && b.h > EPS$6);
+	const entries = edges.map(entriesOf);
+	const xs = /* @__PURE__ */ new Set();
+	const ys = /* @__PURE__ */ new Set();
+	for (const [lines, lo, size, key] of [[
+		xs,
+		frame.x,
+		frame.w,
+		"x"
+	], [
+		ys,
+		frame.y,
+		frame.h,
+		"y"
+	]]) {
+		const cuts = [lo, lo + size];
+		for (const b of boxes) for (const v of key === "x" ? [b.x, b.x + b.w] : [b.y, b.y + b.h]) if (v > lo && v < lo + size) cuts.push(v);
+		cuts.sort((a, b) => a - b);
+		for (let i = 1; i < cuts.length; i++) if (cuts[i] - cuts[i - 1] > EPS$6) lines.add((cuts[i] + cuts[i - 1]) / 2);
+	}
+	edges.forEach((e, i) => {
+		for (const { point, normal } of [{
+			point: e.plug.point,
+			normal: e.plug.normal
+		}, ...entries[i]]) (normal.x !== 0 ? ys : xs).add(normal.x !== 0 ? point.y : point.x);
+	});
+	const grid = new Grid$1(frame, boxes, [...xs].sort((a, b) => a - b), [...ys].sort((a, b) => a - b));
+	return lanes(frame, boxes, edges, entries, edges.map((e, i) => stubOnly(e, boxes) ?? grid.path(e.plug, e.end.box, entries[i], bend)), options.laneGap ?? 5);
+}
+/** This function gives the entries of the end node. They are its fixed plug, or the middles of its west and east sides and two points on each long side. */
+function entriesOf(e) {
+	if (e.port) return [{
+		point: e.port.point,
+		normal: e.port.normal,
+		fixed: true
+	}];
+	const b = e.end.box;
+	const cy = b.y + b.h / 2;
+	const d = Math.min(6, b.w / 4);
+	return [
+		["west", {
+			x: b.x,
+			y: cy
+		}],
+		["east", {
+			x: b.x + b.w,
+			y: cy
+		}],
+		["north", {
+			x: b.x + d,
+			y: b.y
+		}],
+		["north", {
+			x: b.x + b.w - d,
+			y: b.y
+		}],
+		["south", {
+			x: b.x + d,
+			y: b.y + b.h
+		}],
+		["south", {
+			x: b.x + b.w - d,
+			y: b.y + b.h
+		}]
+	].filter(([s]) => e.side === void 0 || s === e.side).map(([s, point]) => ({
+		point,
+		normal: SIDE_NORMAL[s],
+		fixed: false
+	}));
+}
+/**
+* This function gives the route of an edge whose plug is level with its end node. The way straight in from the plug must meet that node first.
+* The route is the stub only: from the plug to the side of the node. A node that touches the wall gives a stub of length 0.
+*/
+function stubOnly(e, boxes) {
+	if (e.port) return void 0;
+	const p = e.plug.point;
+	const b = e.end.box;
+	const n = e.plug.normal;
+	let q;
+	if (n.x !== 0) {
+		if (!(p.y > b.y + EPS$6 && p.y < b.y + b.h - EPS$6)) return void 0;
+		q = {
+			x: n.x > 0 ? b.x + b.w : b.x,
+			y: p.y
+		};
+		if ((q.x - p.x) * n.x > EPS$6) return void 0;
+	} else {
+		if (!(p.x > b.x + EPS$6 && p.x < b.x + b.w - EPS$6)) return void 0;
+		q = {
+			x: p.x,
+			y: n.y > 0 ? b.y + b.h : b.y
+		};
+		if ((q.y - p.y) * n.y > EPS$6) return void 0;
+	}
+	for (const o of boxes) if (o !== b && blocks(p, q, o)) return void 0;
+	return [p, q];
+}
+/** This function tells if the axis-parallel segment `ab` meets the closed box `o` along a part longer than a tiny length. A segment along a side meets the box. */
+function blocks(a, b, o) {
+	if (a.y === b.y) {
+		if (a.y < o.y - EPS$6 || a.y > o.y + o.h + EPS$6) return false;
+		return Math.min(Math.max(a.x, b.x), o.x + o.w) - Math.max(Math.min(a.x, b.x), o.x) > EPS$6;
+	}
+	if (a.x < o.x - EPS$6 || a.x > o.x + o.w + EPS$6) return false;
+	return Math.min(Math.max(a.y, b.y), o.y + o.h) - Math.max(Math.min(a.y, b.y), o.y) > EPS$6;
+}
+/** This function gives the direction index of a unit normal: 0 east, 1 south, 2 west, 3 north. */
+function dirOf(n) {
+	return n.x > 0 ? 0 : n.y > 0 ? 1 : n.x < 0 ? 2 : 3;
+}
+/** The grid of the free room: the crossings of the lines that are strictly in the frame and not in a closed box. */
+var Grid$1 = class {
+	#xs;
+	#ys;
+	#free;
+	#boxes;
+	constructor(frame, boxes, xs, ys) {
+		this.#xs = xs;
+		this.#ys = ys;
+		this.#boxes = boxes;
+		this.#free = new Uint8Array(xs.length * ys.length);
+		for (let i = 0; i < ys.length; i++) {
+			const y = ys[i];
+			if (y <= frame.y + EPS$6 || y >= frame.y + frame.h - EPS$6) continue;
+			for (let j = 0; j < xs.length; j++) {
+				const x = xs[j];
+				if (x <= frame.x + EPS$6 || x >= frame.x + frame.w - EPS$6) continue;
+				let free = true;
+				for (const b of boxes) if (x >= b.x - EPS$6 && x <= b.x + b.w + EPS$6 && y >= b.y - EPS$6 && y <= b.y + b.h + EPS$6) {
+					free = false;
+					break;
+				}
+				if (free) this.#free[i * xs.length + j] = 1;
+			}
+		}
+	}
+	#point(id) {
+		const nx = this.#xs.length;
+		return {
+			x: this.#xs[id % nx],
+			y: this.#ys[Math.floor(id / nx)]
+		};
+	}
+	/** This method gives the neighbour of the crossing `id` in the direction `d`, or -1. Two free crossings next to each other on a line have no box between them. */
+	#step(id, d) {
+		const nx = this.#xs.length;
+		const i = Math.floor(id / nx);
+		const j = id % nx;
+		const ni = i + DY[d];
+		const nj = j + DX[d];
+		if (ni < 0 || nj < 0 || ni >= this.#ys.length || nj >= nx) return -1;
+		const k = ni * nx + nj;
+		return this.#free[k] ? k : -1;
+	}
+	/** This method gives the first free crossing from the point `p` in the direction `d`. The way to that crossing must be clear. */
+	#enter(p, d, skip) {
+		const nx = this.#xs.length;
+		const along = d % 2 === 0;
+		const line = along ? this.#ys.indexOf(p.y) : this.#xs.indexOf(p.x);
+		if (line < 0) return -1;
+		const list = along ? this.#xs : this.#ys;
+		const v = along ? p.x : p.y;
+		const sign = d < 2 ? 1 : -1;
+		let k = -1;
+		if (sign > 0) {
+			for (let m = 0; m < list.length; m++) if (list[m] > v + EPS$6) {
+				k = m;
+				break;
+			}
+		} else for (let m = list.length - 1; m >= 0; m--) if (list[m] < v - EPS$6) {
+			k = m;
+			break;
+		}
+		if (k < 0) return -1;
+		const id = along ? line * nx + k : k * nx + line;
+		if (!this.#free[id]) return -1;
+		const q = this.#point(id);
+		for (const b of this.#boxes) if (b !== skip && blocks(p, q, b)) return -1;
+		return id;
+	}
+	/**
+	* This method gives the shortest path from the plug into the end box, with the cost `bend` for each bend, or `undefined`.
+	* The path leaves the plug along the inward normal, and it enters an entry along the inward normal of the side.
+	*/
+	path(plug, end, entries, bend) {
+		const n = this.#free.length;
+		const d0 = dirOf({
+			x: -plug.normal.x,
+			y: -plug.normal.y
+		});
+		const first = this.#enter(plug.point, d0);
+		if (first < 0) return void 0;
+		const goals = [];
+		for (const e of entries) {
+			const id = this.#enter(e.point, dirOf(e.normal), end);
+			if (id >= 0) goals.push({
+				id,
+				dir: (dirOf(e.normal) + 2) % 4,
+				point: e.point
+			});
+		}
+		if (goals.length === 0) return void 0;
+		const byNode = /* @__PURE__ */ new Map();
+		goals.forEach((g, k) => {
+			const list = byNode.get(g.id);
+			if (list) list.push(k);
+			else byNode.set(g.id, [k]);
+		});
+		const states = 4 * n + goals.length;
+		const cost = new Float64Array(states).fill(Infinity);
+		const prev = new Int32Array(states).fill(-1);
+		const heap = new Heap();
+		const s0 = first * 4 + d0;
+		cost[s0] = dist$1(plug.point, this.#point(first));
+		heap.push(cost[s0], s0);
+		let found = -1;
+		while (heap.size > 0) {
+			const [c, s] = heap.pop();
+			if (c > cost[s]) continue;
+			if (s >= 4 * n) {
+				found = s;
+				break;
+			}
+			const id = s >> 2;
+			const d = s & 3;
+			const here = this.#point(id);
+			for (const k of byNode.get(id) ?? []) {
+				const g = goals[k];
+				if (g.dir === (d + 2) % 4) continue;
+				const gs = 4 * n + k;
+				const gc = c + dist$1(here, g.point) + (g.dir === d ? 0 : bend);
+				if (gc < cost[gs]) {
+					cost[gs] = gc;
+					prev[gs] = s;
+					heap.push(gc, gs);
+				}
+			}
+			for (let nd = 0; nd < 4; nd++) {
+				if (nd === (d + 2) % 4) continue;
+				const next = this.#step(id, nd);
+				if (next < 0) continue;
+				const ns = next * 4 + nd;
+				const nc = c + dist$1(here, this.#point(next)) + (nd === d ? 0 : bend);
+				if (nc < cost[ns]) {
+					cost[ns] = nc;
+					prev[ns] = s;
+					heap.push(nc, ns);
+				}
+			}
+		}
+		if (found < 0) return void 0;
+		const pts = [goals[found - 4 * n].point];
+		for (let s = prev[found]; s >= 0; s = prev[s]) pts.push(this.#point(s >> 2));
+		pts.push(plug.point);
+		return simplify(pts.reverse());
+	}
+};
+function dist$1(a, b) {
+	return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+/** This function takes out each point between two collinear legs, and each repeated point. */
+function simplify(pts) {
+	const out = [];
+	for (const p of pts) {
+		const a = out[out.length - 1];
+		if (a && a.x === p.x && a.y === p.y) continue;
+		const b = out[out.length - 2];
+		if (a && b && (b.x === a.x && a.x === p.x || b.y === a.y && a.y === p.y)) out[out.length - 1] = p;
+		else out.push(p);
+	}
+	return out;
+}
+/** A binary min-heap of (cost, state) pairs. Equal costs come out by the state, so the order is deterministic. */
+var Heap = class {
+	#c = [];
+	#s = [];
+	get size() {
+		return this.#c.length;
+	}
+	#less(i, j) {
+		return this.#c[i] < this.#c[j] || this.#c[i] === this.#c[j] && this.#s[i] < this.#s[j];
+	}
+	#swap(i, j) {
+		[this.#c[i], this.#c[j]] = [this.#c[j], this.#c[i]];
+		[this.#s[i], this.#s[j]] = [this.#s[j], this.#s[i]];
+	}
+	push(c, s) {
+		this.#c.push(c);
+		this.#s.push(s);
+		for (let i = this.#c.length - 1; i > 0;) {
+			const p = i - 1 >> 1;
+			if (!this.#less(i, p)) break;
+			this.#swap(i, p);
+			i = p;
+		}
+	}
+	pop() {
+		const top = [this.#c[0], this.#s[0]];
+		const c = this.#c.pop();
+		const s = this.#s.pop();
+		if (this.#c.length > 0) {
+			this.#c[0] = c;
+			this.#s[0] = s;
+			for (let i = 0;;) {
+				const l = 2 * i + 1;
+				const r = l + 1;
+				let m = i;
+				if (l < this.#c.length && this.#less(l, m)) m = l;
+				if (r < this.#c.length && this.#less(r, m)) m = r;
+				if (m === i) break;
+				this.#swap(i, m);
+				i = m;
+			}
+		}
+		return top;
+	}
+};
+/**
+* This function gives each leg that shares a gap with legs of other routes its own lane. The lanes are evenly spaced in the gap,
+* at most `laneGap` apart, in an order that gives no crossing where it can. A leg from a plug of the wall and a leg into a fixed plug do not move.
+*/
+function lanes(frame, boxes, edges, entries, routes, laneGap) {
+	const legs = [];
+	routes.forEach((pts, r) => {
+		if (!pts || pts.length < 2) return;
+		const last = pts[pts.length - 1];
+		const entry = entries[r].find((e) => e.point.x === last.x && e.point.y === last.y);
+		for (let k = 0; k + 1 < pts.length; k++) {
+			const a = pts[k];
+			const b = pts[k + 1];
+			if (a.x === b.x && a.y === b.y) continue;
+			const horizontal = a.y === b.y;
+			const [al, ac] = horizontal ? ["x", "y"] : ["y", "x"];
+			const turn = (p) => p === void 0 ? 0 : Math.sign(p[ac] - a[ac]);
+			const ta = turn(pts[k - 1]);
+			const tb = turn(pts[k + 2]);
+			const forward = b[al] > a[al];
+			let [lo, hi] = free(frame, boxes, horizontal, a[ac], Math.min(a[al], b[al]), Math.max(a[al], b[al]));
+			const end = k + 2 === pts.length;
+			if (end && entry && !entry.fixed) {
+				const e = edges[r].end.box;
+				const [elo, size] = horizontal ? [e.y, e.h] : [e.x, e.w];
+				const q = Math.min(2, size / 4);
+				lo = Math.max(lo, elo + q);
+				hi = Math.min(hi, elo + size - q);
+			}
+			legs.push({
+				route: r,
+				index: k,
+				horizontal,
+				across: a[ac],
+				s0: Math.min(a[al], b[al]),
+				s1: Math.max(a[al], b[al]),
+				t0: forward ? ta : tb,
+				t1: forward ? tb : ta,
+				lo,
+				hi,
+				pinned: k === 0 || end && (entry === void 0 || entry.fixed)
+			});
+		}
+	});
+	const parent = legs.map((_, i) => i);
+	const root = (i) => parent[i] === i ? i : parent[i] = root(parent[i]);
+	for (let i = 0; i < legs.length; i++) for (let j = i + 1; j < legs.length; j++) {
+		const a = legs[i];
+		const b = legs[j];
+		if (a.route === b.route || a.horizontal !== b.horizontal) continue;
+		if (Math.min(a.s1, b.s1) - Math.max(a.s0, b.s0) <= -laneGap) continue;
+		if (a.across < b.lo - EPS$6 || a.across > b.hi + EPS$6 || b.across < a.lo - EPS$6 || b.across > a.hi + EPS$6) continue;
+		parent[root(i)] = root(j);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	legs.forEach((_, i) => {
+		const g = root(i);
+		const list = groups.get(g);
+		if (list) list.push(i);
+		else groups.set(g, [i]);
+	});
+	const out = routes.map((pts) => pts ? pts.map((p) => ({ ...p })) : void 0);
+	for (const members of groups.values()) {
+		if (members.length < 2) continue;
+		const group = members.map((i) => legs[i]);
+		const at = place(group, laneGap);
+		group.forEach((leg, m) => {
+			const pts = out[leg.route];
+			const key = leg.horizontal ? "y" : "x";
+			pts[leg.index][key] = at[m];
+			pts[leg.index + 1][key] = at[m];
+		});
+	}
+	return out;
+}
+/** This function gives the free range across a leg: the nearest box sides or walls on each side, over the span of the leg. */
+function free(frame, boxes, horizontal, across, s0, s1) {
+	let lo = horizontal ? frame.y : frame.x;
+	let hi = horizontal ? frame.y + frame.h : frame.x + frame.w;
+	for (const b of boxes) {
+		const [bs, bl, cs, cl] = horizontal ? [
+			b.x,
+			b.w,
+			b.y,
+			b.h
+		] : [
+			b.y,
+			b.h,
+			b.x,
+			b.w
+		];
+		if (Math.min(s1, bs + bl) - Math.max(s0, bs) <= EPS$6) continue;
+		if (cs + cl <= across + EPS$6) lo = Math.max(lo, cs + cl);
+		if (cs >= across - EPS$6) hi = Math.min(hi, cs);
+	}
+	return [lo, hi];
+}
+/** This function tells the side of the leg `b` for the leg `a`. It gives -1 for the smaller coordinate, +1 for the larger and 0 for no rule. */
+function want(a, b) {
+	const side = (sa, sb, ta, tb, inner) => {
+		if (inner(sa, sb)) return ta;
+		if (inner(sb, sa)) return -tb;
+		return ta === tb ? 0 : Math.sign(ta - tb);
+	};
+	const left = side(a.s0, b.s0, a.t0, b.t0, (x, y) => x > y + EPS$6);
+	const right = side(a.s1, b.s1, a.t1, b.t1, (x, y) => x < y - EPS$6);
+	if (left !== 0 && right !== 0 && left !== right) return left;
+	return left || right;
+}
+/**
+* This function gives the lane of each leg of a group. A pinned leg keeps its place, and the pinned legs keep their order.
+* The other legs go in the order of `want`, evenly spaced between the pinned legs and the ends of the free range.
+*/
+function place(group, laneGap) {
+	const n = group.length;
+	const soft = group.map(() => []);
+	const hard = group.map(() => []);
+	const softIn = new Array(n).fill(0);
+	const hardIn = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const a = group[i];
+		const b = group[j];
+		if (a.pinned && b.pinned) {
+			if (Math.abs(a.across - b.across) <= EPS$6) continue;
+			const [x, y] = a.across < b.across ? [i, j] : [j, i];
+			hard[x].push(y);
+			hardIn[y]++;
+			continue;
+		}
+		const w = want(a, b);
+		if (w === 0) continue;
+		const [x, y] = w < 0 ? [i, j] : [j, i];
+		soft[x].push(y);
+		softIn[y]++;
+	}
+	const order = [];
+	const done = new Array(n).fill(false);
+	while (order.length < n) {
+		let best = -1;
+		for (let i = 0; i < n; i++) {
+			if (done[i] || hardIn[i] > 0) continue;
+			if (best < 0 || softIn[i] < softIn[best] || softIn[i] === softIn[best] && group[i].across < group[best].across - EPS$6) best = i;
+		}
+		done[best] = true;
+		order.push(best);
+		for (const y of soft[best]) softIn[y]--;
+		for (const y of hard[best]) hardIn[y]--;
+	}
+	for (let k = 0; k < order.length; k++) {
+		const a = group[order[k]];
+		if (!a.pinned) continue;
+		let to = k + 1;
+		for (let m = k + 1; m < order.length; m++) {
+			const b = group[order[m]];
+			if (b.pinned && Math.abs(b.across - a.across) <= EPS$6) order.splice(to++, 0, ...order.splice(m, 1));
+		}
+		k = to - 1;
+	}
+	const at = new Array(n).fill(0);
+	let start = 0;
+	let from = -Infinity;
+	for (let k = 0; k <= n; k++) {
+		const i = order[k];
+		const pin = i !== void 0 && group[i].pinned;
+		if (k < n && !pin) continue;
+		const run = order.slice(start, k);
+		if (run.length > 0) {
+			const lo = Math.max(from, ...run.map((r) => group[r].lo));
+			const hi = Math.min(k < n ? group[i].across : Infinity, ...run.map((r) => group[r].hi));
+			const room = hi - lo;
+			const s = Math.min(laneGap, room / (run.length + 1));
+			const width = (run.length - 1) * s;
+			const mean = run.reduce((t, r) => t + group[r].across, 0) / run.length;
+			const first = Math.min(Math.max(mean - width / 2, lo + s), hi - s - width);
+			run.forEach((r, m) => at[r] = room > EPS$6 && s > 0 ? first + m * s : group[r].across);
+		}
+		if (k < n) at[i] = group[i].across;
+		start = k + 1;
+		if (k < n) from = group[i].across;
+	}
+	return at;
+}
 // src/routers/frames.ts
 /** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
 const EPS$5 = 1e-6;
@@ -5229,6 +5756,7 @@ function frameRoutes(graph, inner, options) {
 		if (list) list.push(n);
 		else children.set(n.parent, [n]);
 	}
+	if (options.inner === "gutter") return gutterFrameRoutes(inner, options, byId, children);
 	const margin = options.margin ?? 5;
 	const inset = options.frameInset ?? margin;
 	const rooms = /* @__PURE__ */ new Map();
@@ -5236,8 +5764,7 @@ function frameRoutes(graph, inner, options) {
 	for (const { edge, frame, plug } of inner) {
 		const f = byId.get(frame);
 		const [own, far] = plug === "source" ? [edge.source, edge.target] : [edge.target, edge.source];
-		const chain = [];
-		for (let p = byId.get(far.node).parent; p !== frame; p = byId.get(p).parent) chain.push(p);
+		const chain = chainOf(byId, frame, far.node);
 		const key = JSON.stringify([frame, ...chain]);
 		let room = rooms.get(key);
 		if (!room) rooms.set(key, room = makeRoom$1(f, chain, children, byId, inset, options));
@@ -5266,6 +5793,63 @@ function frameRoutes(graph, inner, options) {
 	}
 	return routes;
 }
+/** This function gives the nodes between the frame and the far end, the nearest first. Each of them holds the far end, so it is not an obstacle. */
+function chainOf(byId, frame, far) {
+	const chain = [];
+	for (let p = byId.get(far).parent; p !== frame; p = byId.get(p).parent) chain.push(p);
+	return chain;
+}
+/**
+* This function gives the inner routes of the mode `gutter`. The inner edges of one room route together, so that they share the gaps in lanes.
+* A route is orthogonal, in the free room of the frame box. An edge without a way through the free room gets no route.
+*/
+function gutterFrameRoutes(inner, options, byId, children) {
+	const rooms = /* @__PURE__ */ new Map();
+	const routes = inner.map(() => void 0);
+	inner.forEach(({ edge, frame, plug }, at) => {
+		const f = byId.get(frame);
+		const [own, far] = plug === "source" ? [edge.source, edge.target] : [edge.target, edge.source];
+		const chain = chainOf(byId, frame, far.node);
+		const key = JSON.stringify([frame, ...chain]);
+		let room = rooms.get(key);
+		if (!room) rooms.set(key, room = {
+			nodes: roomNodes(f, chain, children, byId, f.box, options),
+			items: [],
+			frame: f.box
+		});
+		const end = room.nodes.get(far.node);
+		if (!end) return;
+		const fp = placePlug(f, own, center(end.box));
+		const port = fixedPortPoint(end, far) === void 0 ? void 0 : placePlug(end, far, fp.point);
+		const side = far.port === void 0 ? void 0 : end.ports?.find((p) => p.id === far.port)?.side;
+		room.items.push({
+			at,
+			edge: {
+				plug: fp,
+				end,
+				...port ? { port } : {},
+				...side ? { side } : {}
+			}
+		});
+	});
+	for (const room of rooms.values()) {
+		const found = gutterRoutes(room.frame, [...room.nodes.values()], room.items.map((i) => i.edge), {
+			laneGap: options.margin ?? 5,
+			...options.bendCost === void 0 ? {} : { bendCost: options.bendCost }
+		});
+		room.items.forEach(({ at }, k) => {
+			const points = found[k];
+			if (!points) return;
+			const { edge, frame, plug } = inner[at];
+			routes[at] = {
+				edge: edge.id,
+				points: plug === "source" ? points : points.reverse(),
+				frame
+			};
+		});
+	}
+	return routes.filter((r) => r !== void 0);
+}
 /** This function puts the plug of the wall before a way that starts on the bounds. A first point on the line of the stub goes. */
 function stub(plug, way) {
 	const [a, b] = way;
@@ -5281,31 +5865,7 @@ function stub(plug, way) {
 function makeRoom$1(f, chain, children, byId, inset, options) {
 	const margin = options.margin ?? 5;
 	const bounds = shrink(f.box, inset);
-	const skip = new Set(chain);
-	const nodes = /* @__PURE__ */ new Map();
-	for (const holder of [f.id, ...chain]) for (const n of children.get(holder) ?? []) {
-		if (skip.has(n.id)) continue;
-		const box = byId.get(holder).box;
-		if (inside(n.box, box)) {
-			nodes.set(n.id, n);
-			continue;
-		}
-		const rule = options.outside ?? "throw";
-		if (rule === "throw") throw new RangeError(`The box of the node "${n.id}" is not inside the box of its frame "${holder}". The option outside can skip or clamp it.`);
-		if (rule === "skip") continue;
-		const cut = cutBox(n.box, bounds);
-		if (cut) nodes.set(n.id, {
-			...n,
-			box: cut,
-			...n.ports ? { ports: n.ports.map((p) => p.at ? {
-				...p,
-				at: {
-					x: p.at.x + n.box.x - cut.x,
-					y: p.at.y + n.box.y - cut.y
-				}
-			} : p) } : {}
-		});
-	}
+	const nodes = roomNodes(f, chain, children, byId, bounds, options);
 	const w = shrink(bounds, -(margin / 2 + EPS$5));
 	const t = 2 * margin + 1;
 	const walls = [
@@ -5342,6 +5902,38 @@ function makeRoom$1(f, chain, children, byId, inset, options) {
 		nodes
 	};
 }
+/**
+* This function gives the obstacles of a room by id. They are the children of the frame and of each node of the chain, but not the chain.
+* It applies the rule `outside` to each box outside the box of its holder. The rule `clamp` cuts such a box to `bounds`.
+*/
+function roomNodes(f, chain, children, byId, bounds, options) {
+	const skip = new Set(chain);
+	const nodes = /* @__PURE__ */ new Map();
+	for (const holder of [f.id, ...chain]) for (const n of children.get(holder) ?? []) {
+		if (skip.has(n.id)) continue;
+		const box = byId.get(holder).box;
+		if (inside(n.box, box)) {
+			nodes.set(n.id, n);
+			continue;
+		}
+		const rule = options.outside ?? "throw";
+		if (rule === "throw") throw new RangeError(`The box of the node "${n.id}" is not inside the box of its frame "${holder}". The option outside can skip or clamp it.`);
+		if (rule === "skip") continue;
+		const cut = cutBox(n.box, bounds);
+		if (cut) nodes.set(n.id, {
+			...n,
+			box: cut,
+			...n.ports ? { ports: n.ports.map((p) => p.at ? {
+				...p,
+				at: {
+					x: p.at.x + n.box.x - cut.x,
+					y: p.at.y + n.box.y - cut.y
+				}
+			} : p) } : {}
+		});
+	}
+	return nodes;
+}
 /** This function gives the box, smaller by `d` on each side. A negative `d` makes it larger. */
 function shrink(b, d) {
 	return {
@@ -7501,7 +8093,7 @@ function turn(from, base, to) {
 * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
 * The result gives each stretch as a run, with the order of its lanes.
 */
-function sharedRouter(options, negotiation) {
+function sharedRouter(options, negotiation, hooks) {
 	const discount = Math.min(1, Math.max(.05, options.discount ?? .5));
 	const flow = options.cost === "flow";
 	const alpha = Math.min(1, Math.max(.1, options.alpha ?? .6));
@@ -7552,7 +8144,20 @@ function sharedRouter(options, negotiation) {
 				});
 			}
 			const discounted = /* @__PURE__ */ new Map();
-			const order = orderWays(all, options.order ?? "span", graph);
+			const search = {
+				graph,
+				corners: corners.points.length,
+				link,
+				find: (w, cost, floor = 1) => {
+					const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
+					return way && {
+						seq: way,
+						ids: way.map((p, i) => i === 0 || i === way.length - 1 ? endId(p) : index.get(p))
+					};
+				}
+			};
+			const sorted = orderWays(all, options.order ?? "span", graph);
+			const order = hooks?.order ? hooks.order(sorted, search) : sorted;
 			const top = /* @__PURE__ */ new Map();
 			const widths = /* @__PURE__ */ new Map();
 			const widthOf = (i, j) => {
@@ -7676,6 +8281,7 @@ function sharedRouter(options, negotiation) {
 					route(w);
 				}
 			}
+			hooks?.refine?.(order, search);
 			if (options.merge === "snell") {
 				const pad = ways.margin / 2;
 				snellMerges(order, corners.points.length + ends.size, (a, b) => ways.obstacles.clear(a, b, pad), (f) => Math.min(.95, share(f)));
@@ -8009,72 +8615,503 @@ function asRouter(strategy, options) {
 function routersOf(registry) {
 	return listStrategies(registry, "router").map((s) => asRouter(s));
 }
-// src/routers/attraction/index.ts
-/** The default options of the router `attraction`. */
-const ATTRACTION_DEFAULTS = Object.freeze({
-	passes: 3,
-	attraction: .5,
-	capacityWeight: 1,
-	laneWidth: 4
+// src/routers/annealing/index.ts
+/** The default options of the router `annealing`. */
+const ANNEALING_DEFAULTS = Object.freeze({
+	candidates: 4,
+	crossing: 4,
+	temperature: 1,
+	cooling: .95,
+	budget: 50,
+	seed: 1
 });
-/** The declarations of the options of the router `attraction` (HWY-044). */
-const ATTRACTION_SCHEMA = {
-	passes: {
+/** The declarations of the options of the router `annealing` (RULE-021). */
+const ANNEALING_SCHEMA = {
+	candidates: {
 		type: "integer",
-		min: 1,
-		max: 10,
+		min: 3,
+		max: 8,
 		step: 1,
 		marks: [
-			2,
 			3,
-			5
+			4,
+			6
 		],
-		default: 3,
-		describe: "The number of passes. Each later pass routes each edge again from no ways."
+		default: 4,
+		describe: "The number of candidate ways of each edge."
 	},
-	attraction: {
+	crossing: {
 		type: "number",
 		min: 0,
-		max: 1,
-		step: .05,
+		max: 20,
+		step: .5,
 		marks: [
-			.25,
-			.5,
-			.75
+			1,
+			4,
+			10
 		],
-		default: .5,
-		describe: "The pull of the history of a link. A busy link of the passes before costs less."
+		default: 4,
+		describe: "The cost of one crossing, in units of the median box side."
 	},
-	capacityWeight: {
+	temperature: {
 		type: "number",
-		min: 0,
+		min: .1,
 		max: 10,
-		step: .5,
+		step: .1,
 		marks: [
-			0,
+			.5,
 			1,
 			4
 		],
 		default: 1,
-		describe: "The cost weight of each edge over the capacity of a link."
+		describe: "The start temperature, in units of the median box side."
 	},
-	laneWidth: {
+	cooling: {
 		type: "number",
-		min: 1,
-		max: 12,
-		step: 1,
-		marks: [4, 6],
-		default: 4,
-		describe: "The width of one lane. The capacity of a link is its free width divided by this width."
-	}
-};
-/**
-* This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
-* After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
-* In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
-* The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
-*/
-function attractionRouter(options) {
+		min: .9,
+		max: .99,
+		step: .01,
+		marks: [
+			.9,
+			.95,
+			.98
+		],
+		default: .95,
+		describe: "The factor of the temperature after each sweep of the edges."
+	},
+	budget: {
+		type: "integer",
+		min: 20,
+		max: 200,
+		step: 10,
+		marks: [
+			20,
+			50,
+			100
+		],
+		default: 50,
+		describe: "The budget: the number of changes for each edge."
+	},
+	seed: {
+		type: "integer",
+		min: 0,
+		max: 1e6,
+		step: 1,
+		marks: [
+			1,
+			2,
+			3
+		],
+		default: 1,
+		describe: "The seed of the random choices. The same seed gives the same routes."
+	}
+};
+/** The share of the cost of a link that the edges of one key use already, as in `shared` with its default discount. */
+const DISCOUNT = .5;
+/** The cost factor of the links of the earlier candidates in the search of the next candidate. */
+const PENALTY = 3;
+/** This function tells if the segments `a b` and `c d` cross at one inner point of each. A touch at an end or a common line is not a crossing. */
+function properCross(a, b, c, d) {
+	const o = (p, q, r) => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
+	const d1 = o(c, d, a);
+	const d2 = o(c, d, b);
+	const d3 = o(a, b, c);
+	const d4 = o(a, b, d);
+	return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+/** This function gives the median of the smaller side of the boxes, the unit of the costs. */
+function unitOf(graph) {
+	const sides = graph.nodes.map((n) => Math.min(n.box.w, n.box.h)).sort((a, b) => a - b);
+	const u = sides.length === 0 ? 1 : sides[Math.floor((sides.length - 1) / 2)];
+	return u > 0 ? u : 1;
+}
+/**
+* This function anneals the choice of one candidate way for each edge (RULE-021, after Davidson and Harel, 1996).
+* The candidates of an edge are its way in `shared` and its shortest way. Other candidates are the shortest ways when the links of earlier candidates cost 3 times more.
+* The energy is `(1 - 0.5) ink + 0.5 Σ L + crossing u X`: the cost of `shared` plus a cost for each crossing `X` between the ways of two edges.
+* A change takes one edge to another candidate. A worse change stays with the rational chance `1 / (1 + y + y^2 / 2)`, with `y = ΔE / T`.
+* The temperature falls by `cooling` after each sweep. The ways at the end are the ways of the lowest energy of the run.
+*/
+function annealWays(ways, search, o) {
+	const live = ways.filter((w) => w.found);
+	const m = live.length;
+	if (m < 2) return;
+	const unit = unitOf(search.graph);
+	const n = search.corners;
+	let maxId = 0;
+	for (const w of live) for (const i of w.ids) maxId = Math.max(maxId, i);
+	const N = maxId + 1;
+	const pairOf = (a, b) => a < b ? a * N + b : b * N + a;
+	const make = (seq, ids) => {
+		const links = [];
+		const lengths = [];
+		let length = 0;
+		for (let i = 1; i < ids.length; i++) {
+			const d = dist(seq[i - 1], seq[i]);
+			links.push(pairOf(ids[i - 1], ids[i]));
+			lengths.push(d);
+			length += d;
+		}
+		return {
+			seq,
+			ids,
+			links,
+			lengths,
+			length
+		};
+	};
+	const k = Math.min(8, Math.max(1, Math.floor(o.candidates)));
+	const cands = live.map((w) => {
+		const list = [make(w.seq, w.ids)];
+		const seen = /* @__PURE__ */ new Set([w.ids.join(",")]);
+		const hit = /* @__PURE__ */ new Set();
+		const mark = (c) => {
+			for (let i = 1; i < c.ids.length; i++) if (c.ids[i - 1] < n && c.ids[i] < n) hit.add(search.link(c.ids[i - 1], c.ids[i]));
+		};
+		const add = (found) => {
+			if (!found) return false;
+			const key = found.ids.join(",");
+			if (seen.has(key)) return false;
+			seen.add(key);
+			const c = make(found.seq, found.ids);
+			list.push(c);
+			mark(c);
+			return true;
+		};
+		mark(list[0]);
+		if (list.length < k) add(search.find(w));
+		for (let tries = 0; list.length < k && tries < k; tries++) if (!add(search.find(w, (i, j, d) => hit.has(search.link(i, j)) ? d * PENALTY : d, 1))) break;
+		return list;
+	});
+	const boundsOf = (seqs) => {
+		let x0 = Infinity;
+		let y0 = Infinity;
+		let x1 = -Infinity;
+		let y1 = -Infinity;
+		for (const seq of seqs) for (const p of seq) {
+			x0 = Math.min(x0, p.x);
+			y0 = Math.min(y0, p.y);
+			x1 = Math.max(x1, p.x);
+			y1 = Math.max(y1, p.y);
+		}
+		return {
+			x0,
+			y0,
+			x1,
+			y1
+		};
+	};
+	const apart = (A, B) => A.x1 < B.x0 || B.x1 < A.x0 || A.y1 < B.y0 || B.y1 < A.y0;
+	const own = cands.map((list) => list.map((c) => boundsOf([c.seq])));
+	const boxes = cands.map((list) => boundsOf(list.map((c) => c.seq)));
+	const near = live.map(() => []);
+	for (let e = 0; e < m; e++) for (let f = e + 1; f < m; f++) {
+		if (apart(boxes[e], boxes[f])) continue;
+		const ke = cands[e].length;
+		const kf = cands[f].length;
+		const table = new Int32Array(ke * kf);
+		let any = false;
+		for (let i = 0; i < ke; i++) {
+			const p = cands[e][i].seq;
+			for (let j = 0; j < kf; j++) {
+				if (apart(own[e][i], own[f][j])) continue;
+				const q = cands[f][j].seq;
+				let x = 0;
+				for (let s = 1; s < p.length; s++) for (let t = 1; t < q.length; t++) if (properCross(p[s - 1], p[s], q[t - 1], q[t])) x++;
+				table[i * kf + j] = x;
+				if (x > 0) any = true;
+			}
+		}
+		if (!any) continue;
+		near[e].push({
+			f,
+			table,
+			mine: true
+		});
+		near[f].push({
+			f: e,
+			table,
+			mine: false
+		});
+	}
+	const keys = live.map((w) => w.key);
+	const users = /* @__PURE__ */ new Map();
+	const use = (e, c, step) => {
+		let mine = users.get(keys[e]);
+		if (!mine) users.set(keys[e], mine = /* @__PURE__ */ new Map());
+		let ink = 0;
+		for (let i = 0; i < c.links.length; i++) {
+			const before = mine.get(c.links[i]) ?? 0;
+			const after = before + step;
+			if (after === 0) mine.delete(c.links[i]);
+			else mine.set(c.links[i], after);
+			if (before === 0 && after > 0) ink += c.lengths[i];
+			if (before > 0 && after === 0) ink -= c.lengths[i];
+		}
+		return ink;
+	};
+	const choice = new Int32Array(m);
+	for (let e = 0; e < m; e++) use(e, cands[e][0], 1);
+	const crossCost = Math.max(0, o.crossing) * unit;
+	const crossings = (e, i) => {
+		let x = 0;
+		for (const { f, table, mine } of near[e]) {
+			const kf = cands[f].length;
+			const ke = cands[e].length;
+			x += mine ? table[i * kf + choice[f]] : table[choice[f] * ke + i];
+		}
+		return x;
+	};
+	const random = rng(Math.max(0, Math.floor(o.seed)));
+	const cooling = Math.min(.99, Math.max(.9, o.cooling));
+	let temperature = Math.max(1e-6, o.temperature) * unit;
+	const moves = Math.max(1, Math.floor(o.budget)) * m;
+	let energy = 0;
+	let best = 0;
+	let bestChoice = choice.slice();
+	for (let s = 0; s < moves; s++) {
+		if (s > 0 && s % m === 0) temperature *= cooling;
+		const e = Math.floor(random() * m);
+		const list = cands[e];
+		if (list.length < 2) continue;
+		const from = choice[e];
+		const to = (from + 1 + Math.floor(random() * (list.length - 1))) % list.length;
+		const dInk = use(e, list[from], -1) + use(e, list[to], 1);
+		const dLength = list[to].length - list[from].length;
+		const dCross = crossings(e, to) - crossings(e, from);
+		const delta = .5 * dInk + DISCOUNT * dLength + crossCost * dCross;
+		const y = delta / temperature;
+		if (delta <= 0 || random() < 1 / (1 + y + y * y / 2)) {
+			choice[e] = to;
+			energy += delta;
+			if (energy < best - 1e-9) {
+				best = energy;
+				bestChoice = choice.slice();
+			}
+		} else {
+			use(e, list[to], -1);
+			use(e, list[from], 1);
+		}
+	}
+	live.forEach((w, e) => {
+		const c = cands[e][bestChoice[e]];
+		w.seq = c.seq;
+		w.ids = c.ids;
+	});
+}
+/**
+* This function makes the router `annealing` (RULE-021 with its rider WILD-028). It is the router `shared`, then the annealing of `annealWays`.
+* Each candidate is a way through the corner graph, as in `shared`, so each one keeps the hard rules.
+*/
+function annealingRouter(options) {
+	const o = {
+		...ANNEALING_DEFAULTS,
+		...options
+	};
+	return sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	}, void 0, { refine: (ways, search) => annealWays(ways, search, o) });
+}
+/**
+* The router strategy `annealing` (RULE-021), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+* A screen module or a consumer adds it to a registry.
+*/
+const annealingStrategy = defineStrategy({
+	step: "router",
+	name: "annealing",
+	describe: "Simulated annealing over candidate routes (RULE-021, with WILD-028). Each edge picks one of a few ways, for less ink and fewer crossings.",
+	defaults: { ...ANNEALING_DEFAULTS },
+	schema: ANNEALING_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => annealingRouter({
+		...o,
+		name: "annealing",
+		rule: byCollection
+	}).route(graph)
+});
+// src/routers/tight/index.ts
+/** The values of `TightFirst`. */
+const TIGHT_FIRSTS = Object.freeze(["tight", "loose"]);
+/** The values of `TightTies`. */
+const TIGHT_TIES = Object.freeze(["id", "length"]);
+/** The default options of the router `tight`. */
+const TIGHT_DEFAULTS = Object.freeze({
+	penalty: 3,
+	first: "tight",
+	ties: "length"
+});
+/** The declarations of the options of the router `tight` (WILD-023). */
+const TIGHT_SCHEMA = {
+	penalty: {
+		type: "number",
+		min: 2,
+		max: 10,
+		step: .5,
+		marks: [
+			2,
+			3,
+			5
+		],
+		default: 3,
+		describe: "The cost factor of the links of the first way in the search of the second way."
+	},
+	first: {
+		type: "enum",
+		values: ["tight", "loose"],
+		default: "tight",
+		describe: "The edges that go first: the edges with few good ways, or the edges with many good ways."
+	},
+	ties: {
+		type: "enum",
+		values: ["id", "length"],
+		default: "length",
+		describe: "The order of two edges with the same slack: by the edge id, or the longer edge first."
+	}
+};
+/**
+* This function gives the slack of each way (WILD-023): `L2 / L1 - 1`. `L1` is the length of the shortest way.
+* `L2` is the cost of the shortest way when each link of the first way costs `penalty` times its length.
+* A way with no second way has the slack `penalty - 1`. A way with a second way of near-equal length has a slack near 0.
+*/
+function waySlacks(ways, search, penalty) {
+	const out = /* @__PURE__ */ new Map();
+	const n = search.corners;
+	for (const w of ways) {
+		const first = search.find(w);
+		if (!first) {
+			out.set(w, 0);
+			continue;
+		}
+		const l1 = polylineLength(first.seq);
+		const own = /* @__PURE__ */ new Set();
+		for (let i = 1; i < first.ids.length; i++) {
+			const a = first.ids[i - 1];
+			const b = first.ids[i];
+			if (a < n && b < n) own.add(search.link(a, b));
+		}
+		const cost = (i, j, d) => own.has(search.link(i, j)) ? d * penalty : d;
+		const second = search.find(w, cost, 1);
+		let l2 = l1;
+		if (second) {
+			l2 = 0;
+			for (let i = 1; i < second.ids.length; i++) {
+				const a = second.ids[i - 1];
+				const b = second.ids[i];
+				const d = dist(second.seq[i - 1], second.seq[i]);
+				l2 += a < n && b < n ? cost(a, b, d) : d;
+			}
+		}
+		out.set(w, l1 > 1e-9 ? l2 / l1 - 1 : 0);
+	}
+	return out;
+}
+/**
+* This function makes the router `tight` (WILD-023). It is the router `shared` with another order of the edges of each key.
+* With `first: tight`, the edges with the largest slack value go first: their second way costs much more, so they have few good ways.
+* The edges with many ways of near-equal cost go last. The keys keep the order of `shared`.
+*/
+function tightRouter(options) {
+	const o = {
+		...TIGHT_DEFAULTS,
+		...options
+	};
+	const penalty = Math.min(10, Math.max(1, o.penalty));
+	const sign = o.first === "loose" ? 1 : -1;
+	return sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	}, void 0, { order: (ways, search) => {
+		const slack = waySlacks(ways, search, penalty);
+		const span = (w) => dist(w.ps.point, w.pt.point);
+		return [...ways].sort((p, q) => byText(p.key, q.key) || sign * (slack.get(p) - slack.get(q)) || (o.ties === "length" ? span(q) - span(p) : 0) || byText(p.edge.id, q.edge.id));
+	} });
+}
+/**
+* The router strategy `tight` (WILD-023), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+* A screen module or a consumer adds it to a registry.
+*/
+const tightStrategy = defineStrategy({
+	step: "router",
+	name: "tight",
+	describe: "Tight edges first (WILD-023). The router `shared` routes first the edges whose second way costs much more than their first way.",
+	defaults: { ...TIGHT_DEFAULTS },
+	schema: TIGHT_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => tightRouter({
+		...o,
+		name: "tight",
+		rule: byCollection
+	}).route(graph)
+});
+// src/routers/attraction/index.ts
+/** The default options of the router `attraction`. */
+const ATTRACTION_DEFAULTS = Object.freeze({
+	passes: 3,
+	attraction: .5,
+	capacityWeight: 1,
+	laneWidth: 4
+});
+/** The declarations of the options of the router `attraction` (HWY-044). */
+const ATTRACTION_SCHEMA = {
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 10,
+		step: 1,
+		marks: [
+			2,
+			3,
+			5
+		],
+		default: 3,
+		describe: "The number of passes. Each later pass routes each edge again from no ways."
+	},
+	attraction: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05,
+		marks: [
+			.25,
+			.5,
+			.75
+		],
+		default: .5,
+		describe: "The pull of the history of a link. A busy link of the passes before costs less."
+	},
+	capacityWeight: {
+		type: "number",
+		min: 0,
+		max: 10,
+		step: .5,
+		marks: [
+			0,
+			1,
+			4
+		],
+		default: 1,
+		describe: "The cost weight of each edge over the capacity of a link."
+	},
+	laneWidth: {
+		type: "number",
+		min: 1,
+		max: 12,
+		step: 1,
+		marks: [4, 6],
+		default: 4,
+		describe: "The width of one lane. The capacity of a link is its free width divided by this width."
+	}
+};
+/**
+* This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+* After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+* In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+* The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+*/
+function attractionRouter(options) {
 	const o = {
 		...ATTRACTION_DEFAULTS,
 		...options
@@ -16779,41 +17816,352 @@ function interchangePlan(input, o) {
 	});
 	return tidyPlan({ highways });
 }
-// src/bench/measures/bundles.ts
+// src/highways/knee/root.ts
 /**
-* This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
-* `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
+* This function gives the root of the tree of one source node (NAT-018, NAT-019): the start point nearest the center of the targets.
+* It also gives the lead of each edge, the way from its own start point to the root. A lead is `undefined` when the corner graph has no way.
 */
-function inkSaved(routes) {
-	let total = 0;
-	for (const r of routes) total += polylineLength(r.points);
-	if (total <= 0) return 0;
-	let ink = 0;
-	for (const [a, b] of drawnSegments(routes)) ink += dist(a, b);
-	return Math.max(0, 1 - ink / total);
+function rootOf(finder, starts, goals) {
+	const c = {
+		x: goals.reduce((s, p) => s + p.x, 0) / goals.length,
+		y: goals.reduce((s, p) => s + p.y, 0) / goals.length
+	};
+	let root = starts[0];
+	for (const s of starts) if (dist(s, c) < dist(root, c) - 1e-9) root = s;
+	const leads = starts.map((s) => {
+		if (dist(s, root) <= 1e-9) return [root];
+		if (finder.obstacles.clearPath([s, root], finder.margin / 2)) return [s, root];
+		const way = finder.corners.path(s, root);
+		return way ? finder.corners.pull(way) : void 0;
+	});
+	return {
+		root,
+		leads
+	};
+}
+// src/highways/knee/index.ts
+/** The values of `KneeRule`. */
+const KNEE_RULES = Object.freeze(["chord", "weights"]);
+/** The default options of the strategy `knee`. */
+const KNEE_DEFAULTS = Object.freeze({
+	sweep: 11,
+	rule: "chord",
+	ink: .5,
+	detour: 1.5,
+	minSize: 2
+});
+/** This function gives the ink of a fan: the sum of the lengths of its links. */
+function fanInk(fan) {
+	let sum = 0;
+	for (const p of fan.points) if (p.parent >= 0) sum += dist(p.point, fan.points[p.parent].point);
+	return sum;
 }
 /**
-* This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
-* `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
-* `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
+* This function adds a stub point at `stub` from the end of the last link of a way. The tree of NAT-017 joins a new branch only at an open point or on a link to one.
+* The last point of a way is not open, so without the stub no branch joins the last link.
 */
-function ambiguity(graph, routes, options = {}) {
-	const n = graph.nodes.length;
-	const index = new Map(graph.nodes.map((v, i) => [v.id, i]));
-	const ends = /* @__PURE__ */ new Map();
-	for (const e of graph.edges) {
-		const s = index.get(e.source.node);
-		const t = index.get(e.target.node);
-		if (s !== void 0 && t !== void 0) ends.set(e.id, [s, t]);
+function withStub(way, stub) {
+	if (way.length < 2) return way;
+	const a = way[way.length - 2];
+	const b = way[way.length - 1];
+	const d = dist(a, b);
+	if (d <= 2 * stub) return way;
+	return [
+		...way.slice(0, -1),
+		{
+			x: b.x + (a.x - b.x) * stub / d,
+			y: b.y + (a.y - b.y) * stub / d
+		},
+		b
+	];
+}
+/**
+* This function gives the index of the tree that the rule picks on the front of the trees (NAT-018).
+* The front holds the trees that no other tree beats on the ink and on the path lengths. The two values go to the range from 0 to 1.
+* With `chord`, the pick is the tree of the front farthest from the line between the two ends of the front.
+* With `weights`, the pick is the tree with the least `ink × L + (1 - ink) × S`. A tie goes to the earlier tree.
+*/
+function kneeOf(trees, rule, ink) {
+	if (trees.length === 0) return -1;
+	const front = trees.map((_, i) => i).filter((i) => !trees.some((q, j) => j !== i && q.ink <= trees[i].ink && q.paths <= trees[i].paths && (q.ink < trees[i].ink || q.paths < trees[i].paths)));
+	const lo = {
+		x: Math.min(...front.map((i) => trees[i].ink)),
+		y: Math.min(...front.map((i) => trees[i].paths))
+	};
+	const hi = {
+		x: Math.max(...front.map((i) => trees[i].ink)),
+		y: Math.max(...front.map((i) => trees[i].paths))
+	};
+	const norm = (i) => ({
+		x: hi.x - lo.x > 1e-9 ? (trees[i].ink - lo.x) / (hi.x - lo.x) : 0,
+		y: hi.y - lo.y > 1e-9 ? (trees[i].paths - lo.y) / (hi.y - lo.y) : 0
+	});
+	let best = front[0];
+	let score = rule === "chord" ? -Infinity : Infinity;
+	if (rule === "weights") {
+		const w = Math.min(1, Math.max(0, ink));
+		for (const i of front) {
+			const p = norm(i);
+			const s = w * p.x + (1 - w) * p.y;
+			if (s < score - 1e-12) [best, score] = [i, s];
+		}
+		return best;
 	}
-	const keyIds = /* @__PURE__ */ new Map();
-	const nodesOf = [];
-	const keysOf = /* @__PURE__ */ new Map();
-	for (const r of routes) {
-		const end = ends.get(r.edge);
-		if (!end) continue;
-		const own = [];
-		for (let i = 1; i < r.points.length; i++) {
+	const a = front.reduce((u, i) => trees[i].ink < trees[u].ink || trees[i].ink === trees[u].ink && trees[i].paths < trees[u].paths ? i : u);
+	const b = front.reduce((u, i) => trees[i].paths < trees[u].paths || trees[i].paths === trees[u].paths && trees[i].ink < trees[u].ink ? i : u);
+	const A = norm(a);
+	const B = norm(b);
+	const len = dist(A, B);
+	if (len <= 1e-12) return a;
+	for (const i of front) {
+		const p = norm(i);
+		const s = Math.abs((B.x - A.x) * (A.y - p.y) - (A.x - p.x) * (B.y - A.y)) / len;
+		if (s > score + 1e-12) [best, score] = [i, s];
+	}
+	return best;
+}
+/**
+* This function gives the highways of the knee trees (NAT-018). The edges from one source node get one tree. Its root is the out point of the plug nearest the center of the targets.
+* A sweep of the balancing factor of NAT-017 gives trees from the least ink to the most direct paths.
+* The tree at the knee of the front of ink and path lengths is the pick. Each edge takes its path in the tree, when that path is short enough.
+* The stretches of the tree that two edges or more share become highways.
+*/
+function kneePlan(input, o) {
+	const finder = new WayFinder(input.graph.nodes);
+	const first = firstRoutes(input);
+	const groups = /* @__PURE__ */ new Map();
+	for (const p of edgePlugs(input.graph)) {
+		const s = finder.out(p.ps);
+		const t = finder.out(p.pt);
+		const route = first.get(p.edge.id);
+		const group = p.edge.source.node;
+		const list = groups.get(group) ?? [];
+		list.push({
+			edge: p.edge.id,
+			key: p.edge.source.node,
+			s,
+			t,
+			base: route ? polylineLength(route) : dist(s, t)
+		});
+		groups.set(group, list);
+	}
+	const sweep = Math.min(21, Math.max(2, Math.floor(o.sweep)));
+	const ways = [];
+	for (const group of [...groups.keys()].sort()) {
+		const list = groups.get(group);
+		if (list.length < 2) continue;
+		const goals = list.map((e) => e.t);
+		const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+		const lost = /* @__PURE__ */ new Set();
+		const branch = (from, t) => {
+			const way = finder.corners.path(from, goals[t]);
+			if (way) return withStub(finder.corners.pull(way), finder.margin);
+			lost.add(t);
+			return [from, goals[t]];
+		};
+		const trees = [];
+		for (let k = 0; k < sweep; k++) {
+			const a = (k + 1) / sweep;
+			const bf = (1 - a) / a;
+			const fan = balancedFan(root, goals, bf, branch);
+			let paths = 0;
+			for (const leaf of fan.leaf) paths += fan.points[leaf].pl;
+			trees.push({
+				bf,
+				ink: fanInk(fan),
+				paths,
+				fan
+			});
+		}
+		const pick = trees[kneeOf(trees, o.rule, o.ink)];
+		list.forEach((e, t) => {
+			const lead = leads[t];
+			if (lost.has(t) || !lead) return;
+			const points = [...lead, ...fanPath(pick.fan, pick.fan.leaf[t]).slice(1)];
+			if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+			ways.push({
+				edge: e.edge,
+				key: e.key,
+				points
+			});
+		});
+	}
+	return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}
+// src/highways/bronchial/index.ts
+/** The values of `BronchialSplit`. */
+const BRONCHIAL_SPLITS = Object.freeze([
+	"count",
+	"weight",
+	"gap"
+]);
+/** The default options of the strategy `bronchial`. */
+const BRONCHIAL_DEFAULTS = Object.freeze({
+	split: "count",
+	share: .5,
+	smallest: 1,
+	detour: 1.5,
+	minSize: 2
+});
+/**
+* This function gives the diamond angle of the direction `(dx, dy)`: a value from 0 to 4 that grows with the angle, with no trigonometry.
+* The value 0 is the direction of the positive x axis.
+*/
+function diamondAngle(dx, dy) {
+	const s = Math.abs(dx) + Math.abs(dy);
+	if (s <= 1e-12) return 0;
+	if (dy >= 0) return dx >= 0 ? dy / s : 1 - dx / s;
+	return dx < 0 ? 2 - dy / s : 3 + dx / s;
+}
+/**
+* This function splits the targets of a tip in two halves (NAT-019). The targets go in the order of their angles around the tip.
+* The order starts after the widest gap of the angles, so each half is a sector. The rule of `split` then cuts the order in two.
+*/
+function splitTargets(tip, targets, ids, split) {
+	const sorted = [...ids].sort((a, b) => diamondAngle(targets[a].x - tip.x, targets[a].y - tip.y) - diamondAngle(targets[b].x - tip.x, targets[b].y - tip.y) || a - b);
+	const angle = (i) => diamondAngle(targets[sorted[i]].x - tip.x, targets[sorted[i]].y - tip.y);
+	const n = sorted.length;
+	const gaps = sorted.map((_, i) => i === n - 1 ? angle(0) + 4 - angle(i) : angle(i + 1) - angle(i));
+	let widest = 0;
+	for (let i = 1; i < n; i++) if (gaps[i] > gaps[widest] + 1e-12) widest = i;
+	const order = [...sorted.slice(widest + 1), ...sorted.slice(0, widest + 1)];
+	let cut = Math.floor(n / 2);
+	if (split === "weight") {
+		const w = order.map((i) => dist(tip, targets[i]));
+		const total = w.reduce((s, x) => s + x, 0);
+		let run = 0;
+		let best = Infinity;
+		for (let c = 1; c < n; c++) {
+			run += w[c - 1];
+			const off = Math.abs(2 * run - total);
+			if (off < best - 1e-9) [best, cut] = [off, c];
+		}
+	} else if (split === "gap") {
+		let best = -Infinity;
+		const at = (k) => diamondAngle(targets[order[k]].x - tip.x, targets[order[k]].y - tip.y);
+		for (let c = 1; c < n; c++) {
+			const g = (at(c) - at(c - 1) + 4) % 4;
+			if (g > best + 1e-12) [best, cut] = [g, c];
+		}
+	}
+	return [order.slice(0, cut), order.slice(cut)];
+}
+/**
+* This function gives the highways of the bronchial trees (NAT-019, after Kitaoka and others, 1999). The edges from one source node get one tree.
+* The root of a tree is the out point of the plug nearest the center of the targets.
+* From the tip, the tree grows a share of the way to the center of its targets. Then it splits the targets in two and grows a branch for each half.
+* A branch that hits a box grows half as far, or not at all. A small set of targets gets its own ways from the tip, through the corner graph.
+* Each edge takes its path in the tree when that path is short enough, and the stretches that two edges or more share become highways.
+*/
+function bronchialPlan(input, o) {
+	const finder = new WayFinder(input.graph.nodes);
+	const pad = finder.margin / 2;
+	const first = firstRoutes(input);
+	const groups = /* @__PURE__ */ new Map();
+	for (const p of edgePlugs(input.graph)) {
+		const s = finder.out(p.ps);
+		const t = finder.out(p.pt);
+		const route = first.get(p.edge.id);
+		const group = p.edge.source.node;
+		const list = groups.get(group) ?? [];
+		list.push({
+			edge: p.edge.id,
+			key: p.edge.source.node,
+			s,
+			t,
+			base: route ? polylineLength(route) : dist(s, t)
+		});
+		groups.set(group, list);
+	}
+	const share = Math.min(.7, Math.max(.3, o.share));
+	const smallest = Math.min(3, Math.max(1, Math.floor(o.smallest)));
+	const ways = [];
+	for (const group of [...groups.keys()].sort()) {
+		const list = groups.get(group);
+		if (list.length < 2) continue;
+		const goals = list.map((e) => e.t);
+		const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+		const paths = list.map(() => void 0);
+		const grow = (trunk, ids) => {
+			const tip = trunk[trunk.length - 1];
+			if (ids.length <= smallest) {
+				for (const i of ids) {
+					const way = finder.corners.path(tip, goals[i]);
+					if (way) paths[i] = [...trunk, ...finder.corners.pull(way).slice(1)];
+				}
+				return;
+			}
+			const c = {
+				x: ids.reduce((s, i) => s + goals[i].x, 0) / ids.length,
+				y: ids.reduce((s, i) => s + goals[i].y, 0) / ids.length
+			};
+			let next = trunk;
+			for (let f = share; f > share / 8; f /= 2) {
+				const p = {
+					x: tip.x + f * (c.x - tip.x),
+					y: tip.y + f * (c.y - tip.y)
+				};
+				if (dist(p, tip) <= 1e-6) break;
+				if (!finder.obstacles.inside(p, pad) && finder.obstacles.clearPath([tip, p], pad)) {
+					next = [...trunk, p];
+					break;
+				}
+			}
+			const [a, b] = splitTargets(next[next.length - 1], goals, ids, o.split);
+			grow(next, a);
+			grow(next, b);
+		};
+		grow([root], list.map((_, i) => i));
+		list.forEach((e, i) => {
+			const tail = paths[i];
+			const lead = leads[i];
+			if (!tail || !lead) return;
+			const points = [...lead, ...tail.slice(1)];
+			if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+			ways.push({
+				edge: e.edge,
+				key: e.key,
+				points
+			});
+		});
+	}
+	return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}
+// src/bench/measures/bundles.ts
+/**
+* This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
+* `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
+*/
+function inkSaved(routes) {
+	let total = 0;
+	for (const r of routes) total += polylineLength(r.points);
+	if (total <= 0) return 0;
+	let ink = 0;
+	for (const [a, b] of drawnSegments(routes)) ink += dist(a, b);
+	return Math.max(0, 1 - ink / total);
+}
+/**
+* This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
+* `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
+* `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
+*/
+function ambiguity(graph, routes, options = {}) {
+	const n = graph.nodes.length;
+	const index = new Map(graph.nodes.map((v, i) => [v.id, i]));
+	const ends = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const s = index.get(e.source.node);
+		const t = index.get(e.target.node);
+		if (s !== void 0 && t !== void 0) ends.set(e.id, [s, t]);
+	}
+	const keyIds = /* @__PURE__ */ new Map();
+	const nodesOf = [];
+	const keysOf = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const end = ends.get(r.edge);
+		if (!end) continue;
+		const own = [];
+		for (let i = 1; i < r.points.length; i++) {
 			const k = segmentKey(r.points[i - 1], r.points[i]);
 			if (k === void 0) continue;
 			let id = keyIds.get(k);
@@ -19641,6 +20989,243 @@ function zipperPlan(input, o) {
 	}
 	return tidyPlan(plan);
 }
+// src/levels/venation/index.ts
+/** The values of `VenationBackbone`. */
+const VENATION_BACKBONES = Object.freeze(["rng", "gabriel"]);
+/** The default options of the level strategy `venation`. */
+const VENATION_DEFAULTS = Object.freeze({
+	backbone: "rng",
+	discount: .4,
+	detour: 1.5,
+	maxItems: 400
+});
+/**
+* This function gives the links of the backbone of the points, as pairs of indices `i < j` (NAT-016).
+* With `rng`, the link `p q` exists when no third point `r` has `max(d(p, r), d(q, r)) < d(p, q)`.
+* With `gabriel`, the link exists when no third point is inside the circle with the diameter `p q`.
+*/
+function backboneLinks(points, backbone) {
+	const out = [];
+	const n = points.length;
+	const d2 = (a, b) => (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const pq = d2(points[i], points[j]);
+		let keep = true;
+		for (let r = 0; r < n && keep; r++) {
+			if (r === i || r === j) continue;
+			const pr = d2(points[i], points[r]);
+			const qr = d2(points[j], points[r]);
+			if (backbone === "rng" ? Math.max(pr, qr) < pq - 1e-9 : pr + qr < pq - 1e-9) keep = false;
+		}
+		if (keep) out.push([i, j]);
+	}
+	return out;
+}
+/**
+* This function gives a way around the box `b`, inflated by `m`, from the point `a` to the point `c` of its boundary.
+* The way goes along the shorter side of the inflated box. It holds the two points at `m` out from `a` and `c`, and the corners between them.
+*/
+function aroundBox(b, m, a, c) {
+	const x0 = b.x - m;
+	const y0 = b.y - m;
+	const x1 = b.x + b.w + m;
+	const y1 = b.y + b.h + m;
+	const w = x1 - x0;
+	const h = y1 - y0;
+	const per = 2 * (w + h);
+	const onBoundary = (p) => {
+		const cx = Math.min(x1, Math.max(x0, p.x));
+		const cy = Math.min(y1, Math.max(y0, p.y));
+		const dl = cx - x0;
+		const dr = x1 - cx;
+		const dt = cy - y0;
+		const db = y1 - cy;
+		const least = Math.min(dl, dr, dt, db);
+		if (least === dt) return {
+			p: {
+				x: cx,
+				y: y0
+			},
+			t: cx - x0
+		};
+		if (least === dr) return {
+			p: {
+				x: x1,
+				y: cy
+			},
+			t: w + (cy - y0)
+		};
+		if (least === db) return {
+			p: {
+				x: cx,
+				y: y1
+			},
+			t: w + h + (x1 - cx)
+		};
+		return {
+			p: {
+				x: x0,
+				y: cy
+			},
+			t: 2 * w + h + (y1 - cy)
+		};
+	};
+	const corners = [
+		{
+			p: {
+				x: x0,
+				y: y0
+			},
+			t: 0
+		},
+		{
+			p: {
+				x: x1,
+				y: y0
+			},
+			t: w
+		},
+		{
+			p: {
+				x: x1,
+				y: y1
+			},
+			t: w + h
+		},
+		{
+			p: {
+				x: x0,
+				y: y1
+			},
+			t: 2 * w + h
+		}
+	];
+	const A = onBoundary(a);
+	const C = onBoundary(c);
+	const ahead = (C.t - A.t + per) % per;
+	const out = [A.p];
+	if (ahead <= per / 2) {
+		const list = corners.map((k) => ({
+			...k,
+			s: (k.t - A.t + per) % per
+		})).filter((k) => k.s > 1e-9 && k.s < ahead - 1e-9);
+		for (const k of list.sort((p, q) => p.s - q.s)) out.push(k.p);
+	} else {
+		const back = per - ahead;
+		const list = corners.map((k) => ({
+			...k,
+			s: (A.t - k.t + per) % per
+		})).filter((k) => k.s > 1e-9 && k.s < back - 1e-9);
+		for (const k of list.sort((p, q) => p.s - q.s)) out.push(k.p);
+	}
+	out.push(C.p);
+	return out.filter((p, i) => i === 0 || dist(p, out[i - 1]) > 1e-9);
+}
+/**
+* This function gives the links of one level along a closed venation backbone (NAT-016, after Runions and others, 2005).
+* The backbone links the items by their relative neighbourhood graph or their Gabriel graph. Each backbone link goes around the other items.
+* The level links go in the order of their counts, the largest first. Each one takes the cheapest way on the backbone, with the cost `L (1 - discount)` for a used backbone link.
+* The way goes around each item between its two ends. A way longer than `detour` times the direct link, or a direct backbone link, keeps the direct link.
+*/
+function venationLinks(items, direct, o) {
+	if (direct.length < 2 || items.length < 3 || items.length > o.maxItems) return [...direct];
+	const index = new Map(items.map((it, i) => [it.id, i]));
+	const links = backboneLinks(items.map((it) => center(it.box)), o.backbone);
+	const routed = levelLinks(items, links.map(([i, j]) => ({
+		source: items[i].id,
+		target: items[j].id,
+		count: 1
+	})), o);
+	const n = items.length;
+	const next = Array.from({ length: n }, () => []);
+	const cost = routed.map((l) => polylineLength(l.points));
+	routed.forEach((l, k) => {
+		const i = index.get(l.source);
+		const j = index.get(l.target);
+		next[i].push({
+			to: j,
+			link: k
+		});
+		next[j].push({
+			to: i,
+			link: k
+		});
+	});
+	const direct2 = new Set(links.map(([i, j]) => `${i},${j}`));
+	const used = new Uint8Array(routed.length);
+	const share = 1 - Math.min(.8, Math.max(0, o.discount));
+	const order = direct.map((_, k) => k).sort((p, q) => direct[q].count - direct[p].count || direct[p].source.localeCompare(direct[q].source) || direct[p].target.localeCompare(direct[q].target));
+	const margin = o.margin ?? 5;
+	const out = [...direct];
+	for (const k of order) {
+		const l = direct[k];
+		const s = index.get(l.source);
+		const t = index.get(l.target);
+		if (s === void 0 || t === void 0) continue;
+		if (direct2.has(`${Math.min(s, t)},${Math.max(s, t)}`)) {
+			const at = next[s].find((x) => x.to === t);
+			if (at) used[at.link] = 1;
+			continue;
+		}
+		const best = new Float64Array(n).fill(Infinity);
+		const from = new Int32Array(n).fill(-1);
+		const via = new Int32Array(n).fill(-1);
+		const done = new Uint8Array(n);
+		best[s] = 0;
+		for (;;) {
+			let u = -1;
+			for (let i = 0; i < n; i++) if (!done[i] && best[i] < Infinity && (u < 0 || best[i] < best[u])) u = i;
+			if (u < 0 || u === t) break;
+			done[u] = 1;
+			for (const x of next[u]) {
+				const c = best[u] + cost[x.link] * (used[x.link] ? share : 1);
+				if (c < best[x.to] - 1e-9) {
+					best[x.to] = c;
+					from[x.to] = u;
+					via[x.to] = x.link;
+				}
+			}
+		}
+		if (from[t] < 0) continue;
+		const hops = [];
+		for (let v = t; v !== s; v = from[v]) hops.push({
+			link: via[v],
+			forward: routed[via[v]].target === items[v].id
+		});
+		hops.reverse();
+		const points = [];
+		hops.forEach((h, i) => {
+			const p = routed[h.link].points;
+			const seq = h.forward ? [...p] : [...p].reverse();
+			if (i > 0) {
+				const item = items[index.get(h.forward ? routed[h.link].source : routed[h.link].target)];
+				const around = aroundBox(item.box, margin, points[points.length - 1], seq[0]);
+				if (points.length > 1) points.pop();
+				points.push(...around);
+				seq.shift();
+			}
+			for (const q of seq) if (points.length === 0 || dist(q, points[points.length - 1]) > 1e-9) points.push(q);
+		});
+		if (points.length < 2 || polylineLength(points) > o.detour * polylineLength(l.points)) continue;
+		for (const h of hops) used[h.link] = 1;
+		out[k] = {
+			...l,
+			points
+		};
+	}
+	return out;
+}
+/**
+* This function gives the zoom levels of the level strategy `venation` (NAT-016). The levels and their items are the levels of `depths`.
+* In each level with groups, the links take their ways along a closed venation backbone (`venationLinks`). The last level stays as in `depths`.
+*/
+function venationLevels(input, options) {
+	const levels = depthLevels(input, options);
+	return levels.map((level, i) => i === levels.length - 1 ? level : {
+		...level,
+		links: venationLinks(level.items, level.links, options)
+	});
+}
 // src/strategies/options.ts
 /** The number of values of a sweep on a range when the call and the declaration give no number. */
 const SWEEP_COUNT = 5;
@@ -19906,77 +21491,347 @@ function runPipeline(graph, options) {
 		result: asRouter(options.router, routerOptions).route(board)
 	};
 }
-// src/strategies/schemas.ts
-/** The options of the way finder (`WayOptions`), for each router that goes around the nodes. */
-const WAY_SCHEMA = {
-	margin: {
-		type: "number",
-		min: 1,
-		max: 20,
-		step: 1,
-		default: 5,
-		describe: "The distance from a box to the corners of the graph."
-	},
-	k: {
-		type: "integer",
-		min: 2,
-		max: 16,
-		step: 1,
-		default: 8,
-		describe: "The number of visible neighbours of each corner."
-	},
-	smooth: {
-		type: "boolean",
-		default: false,
-		describe: "With `true`, a way in clear view uses the inflection rule, and the other ways get round corners."
-	}
-};
-/** The declarations of the options of the stretch order (LANE-STRETCH): the method and the passes of `sifting`. A generator can list each value. */
-const LANE_STRETCH_SCHEMA = {
-	method: {
-		type: "enum",
-		values: [
-			"none",
-			"consensus",
-			"periphery",
-			"sifting"
-		],
-		default: "sifting",
-		describe: "The order of each stretch: the order of each run alone, the order of the pair relation, the order of the largest run, or the order of the pair relation after sifting."
-	},
-	passes: {
-		type: "integer",
-		min: 1,
-		max: 4,
-		step: 1,
-		default: 2,
-		describe: "The number of passes of the method `sifting`. In each pass, each edge moves to its best place."
-	}
-};
-/**
-* The declaration of the grouping rule of the edges: a name of `GROUP_RULE_NAMES`. A new name of the list needs no change here.
-* The option also takes a rule of the caller (`custom`), so the old value form stays valid.
-* The `defaults` of a strategy keep the rule `byCollection`, and the declaration gives its name `collection` as its `default`.
-*/
-const EDGE_RULE = {
-	type: "enum",
-	values: GROUP_RULE_NAMES,
-	custom: "function",
-	describe: "The grouping rule."
-};
-/** The declaration of the lane order of the shared ways of the routers `trunks` and `shared`. */
-const LANE_ORDER = {
-	type: "enum",
-	values: ["bundle", "run"],
-	default: "bundle",
-	describe: "With `bundle`, two edges keep one lane order on each shared way of their common stretch. With `run`, each shared way gets its order alone."
-};
-/** The declaration of the lane order of the runs of the router `sections`. The default keeps the lane order of version 0.2.0. */
-const RUN_LANE_ORDER = {
-	...LANE_ORDER,
-	default: "run"
-};
-/** The declarations of the options of the routers `corners` and `corners-smooth`. */
+// src/bench/quality.ts
+/** The clearance stops at this distance. */
+const CLEARANCE_CAP = 40;
+const TIGHT = 4;
+const EXACT_CROSSINGS = 2e4;
+const SAMPLE = 2e3;
+const key = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
+/** This function measures the quality of a result. */
+function measureQuality(graph, result) {
+	const byId = nodeIndex(graph);
+	const nodes = new Grid(180);
+	for (const n of graph.nodes) nodes.add(n, n.box);
+	const segs = [];
+	const seen = /* @__PURE__ */ new Set();
+	let bends = 0;
+	let infl = 0;
+	let clear = 0;
+	let tight = 0;
+	let detour = 0;
+	let detourN = 0;
+	let angle = 0;
+	let angleN = 0;
+	for (const r of result.routes) {
+		const p = r.points;
+		for (let i = 1; i < p.length; i++) {
+			const ka = key(p[i - 1]);
+			const kb = key(p[i]);
+			if (ka === kb) continue;
+			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+			if (seen.has(k)) continue;
+			seen.add(k);
+			segs.push([p[i - 1], p[i]]);
+		}
+		bends += bendCount(p);
+		infl += inflectionCount(p);
+		const ends = endNodes(graph, byId, r.edge);
+		let c = 40;
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			nodes.querySegment(a, b, c, (n) => {
+				if (n !== ends.source && n !== ends.target) c = Math.min(c, segmentBoxDistance(a, b, n.box));
+			});
+		}
+		clear += c;
+		if (c < TIGHT) tight++;
+		if (p.length >= 2) {
+			const d = dist(p[0], p[p.length - 1]);
+			if (d > 1) {
+				detour += polylineLength(p) / d;
+				detourN++;
+			}
+			for (const [at, next, node] of [[
+				p[0],
+				p[1],
+				ends.source
+			], [
+				p[p.length - 1],
+				p[p.length - 2],
+				ends.target
+			]]) {
+				if (!node) continue;
+				const a = sideAngle(node.box, at, next);
+				if (a !== void 0) {
+					angle += a;
+					angleN++;
+				}
+			}
+		}
+	}
+	const n = Math.max(1, result.routes.length);
+	let ink = 0;
+	for (const [a, b] of segs) ink += dist(a, b);
+	const [crossings, crossingsEstimated] = countCrossings(segs);
+	return {
+		ink,
+		crossings,
+		crossingsEstimated,
+		bends: bends / n,
+		inflections: infl / n,
+		clearance: clear / n,
+		tight: tight / n,
+		detour: detourN ? detour / detourN : 1,
+		plugAngle: angleN ? angle / angleN : 0
+	};
+}
+function endNodes(graph, byId, edgeId) {
+	const e = edgeIndex(graph).get(edgeId);
+	return {
+		source: e && byId.get(e.source.node),
+		target: e && byId.get(e.target.node)
+	};
+}
+const edgeIndexes = /* @__PURE__ */ new WeakMap();
+function edgeIndex(graph) {
+	let m = edgeIndexes.get(graph);
+	if (!m) {
+		m = /* @__PURE__ */ new Map();
+		for (const e of graph.edges) m.set(e.id, e);
+		edgeIndexes.set(graph, m);
+	}
+	return m;
+}
+/**
+* This function gives an angle in degrees: the angle between the segment from `at` to `next` and the outward normal.
+* The normal is the normal of the side of the box nearest to `at`. A route that starts inside the box (an interior route) gives no angle.
+*/
+function sideAngle(box, at, next) {
+	const d = [
+		[
+			Math.abs(at.y - box.y),
+			0,
+			-1
+		],
+		[
+			Math.abs(at.x - (box.x + box.w)),
+			1,
+			0
+		],
+		[
+			Math.abs(at.y - (box.y + box.h)),
+			0,
+			1
+		],
+		[
+			Math.abs(at.x - box.x),
+			-1,
+			0
+		]
+	].sort((a, b) => a[0] - b[0])[0];
+	if (d[0] > 1) return void 0;
+	const vx = next.x - at.x;
+	const vy = next.y - at.y;
+	const l = Math.hypot(vx, vy);
+	if (l === 0) return void 0;
+	const cos = Math.max(-1, Math.min(1, (vx * d[1] + vy * d[2]) / l));
+	return Math.acos(cos) * 180 / Math.PI;
+}
+/**
+* This function counts the crossings of a set of segments with a grid of buckets.
+* Above 20 000 segments, it counts the crossings of a seeded sample of 2 000 segments and scales the count.
+*/
+function countCrossings(segs) {
+	if (segs.length < 2) return [0, false];
+	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
+	const grid = new Grid(Math.max(20, len));
+	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
+	const exact = segs.length <= EXACT_CROSSINGS;
+	const R = rng(segs.length);
+	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE }, () => Math.floor(R() * segs.length));
+	let count = 0;
+	for (const i of pick) {
+		const [a, b] = segs[i];
+		grid.querySegment(a, b, 0, (j) => {
+			if (exact && j <= i) return;
+			if (j === i) return;
+			const [c, d] = segs[j];
+			if (segmentsCross(a, b, c, d)) count++;
+		});
+	}
+	return exact ? [count, false] : [Math.round(count * segs.length / (2 * pick.length)), true];
+}
+/** This function measures how much the routes changed between two results. */
+function measureStability(before, after) {
+	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
+	let sum = 0;
+	let max = 0;
+	let moved = 0;
+	let n = 0;
+	for (const r of after.routes) {
+		const p = prev.get(r.edge);
+		if (!p) continue;
+		const f = frechet(p, r.points);
+		sum += f;
+		max = Math.max(max, f);
+		if (f > 1) moved++;
+		n++;
+	}
+	return {
+		mean: n ? sum / n : 0,
+		max,
+		moved: n ? moved / n : 0
+	};
+}
+// src/whole/portfolio/index.ts
+/** The clock in milliseconds. */
+const clock = () => globalThis.performance?.now() ?? Date.now();
+/** The default options of the strategy `board-portfolio`. */
+const BOARD_PORTFOLIO_DEFAULTS = Object.freeze({
+	settings: 4,
+	crossings: 1,
+	detour: 1,
+	ink: 1,
+	budget: 0
+});
+/** This function gives the rank of each value from 0 (the best) to 1 (the worst). Equal values get the mean of their ranks. One value gets 0. */
+function rankShares(values, lowerIsBetter) {
+	const n = values.length;
+	if (n < 2) return values.map(() => 0);
+	const order = values.map((_, i) => i).sort((a, b) => lowerIsBetter ? values[a] - values[b] : values[b] - values[a]);
+	const rank = new Array(n).fill(0);
+	for (let i = 0; i < n;) {
+		let j = i;
+		while (j + 1 < n && Math.abs(values[order[j + 1]] - values[order[i]]) <= 1e-9) j++;
+		for (let k = i; k <= j; k++) rank[order[k]] = (i + j) / 2 / (n - 1);
+		i = j + 1;
+	}
+	return rank;
+}
+/**
+* This function runs the portfolio for one board (WILD-045, after Rice, 1976). It reads only the board and the outputs of its own settings.
+* A setting whose router or highway strategy has a node limit below the size of the board does not run.
+* A setting with a break of a hard rule does not count. The score of a setting is `Σ w_i × the rank share of measure_i` over the settings.
+* The measures are the crossings (R1), the median detour (R5) and the ink saved (B1). The least score wins, and a tie goes to the earlier setting.
+*/
+function boardPortfolio(graph, list, o, now = clock) {
+	const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+	const t0 = now();
+	const entries = [];
+	let fallback;
+	for (const s of list.slice(0, count)) {
+		if (o.budget > 0 && fallback !== void 0 && now() - t0 > o.budget * 1e3) break;
+		const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+		if (limit !== void 0 && graph.nodes.length > limit) continue;
+		const output = runPipeline(graph, s.pipeline);
+		fallback ??= {
+			name: s.name,
+			output
+		};
+		if (checkProperties(output.graph, output.result, 1).length > 0) continue;
+		entries.push({
+			name: s.name,
+			output,
+			...measuresOf(output.graph, output.result)
+		});
+	}
+	if (entries.length === 0) {
+		const first = fallback ?? {
+			name: list[0].name,
+			output: runPipeline(graph, list[0].pipeline)
+		};
+		return {
+			output: first.output,
+			pick: first.name,
+			entries
+		};
+	}
+	const r1 = rankShares(entries.map((e) => e.crossings), true);
+	const r5 = rankShares(entries.map((e) => e.detour), true);
+	const b1 = rankShares(entries.map((e) => e.ink), false);
+	let best = 0;
+	let score = Infinity;
+	entries.forEach((_, i) => {
+		const s = o.crossings * r1[i] + o.detour * r5[i] + o.ink * b1[i];
+		if (s < score - 1e-9) [best, score] = [i, s];
+	});
+	return {
+		output: entries[best].output,
+		pick: entries[best].name,
+		entries
+	};
+}
+/** This function gives the three measures of the score of one output: the crossings, the median detour and the ink saved. */
+function measuresOf(graph, result) {
+	return {
+		crossings: measureQuality(graph, result).crossings,
+		detour: detourSpread(result.routes).median,
+		ink: inkSaved(result.routes)
+	};
+}
+// src/strategies/schemas.ts
+/** The options of the way finder (`WayOptions`), for each router that goes around the nodes. */
+const WAY_SCHEMA = {
+	margin: {
+		type: "number",
+		min: 1,
+		max: 20,
+		step: 1,
+		default: 5,
+		describe: "The distance from a box to the corners of the graph."
+	},
+	k: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 8,
+		describe: "The number of visible neighbours of each corner."
+	},
+	smooth: {
+		type: "boolean",
+		default: false,
+		describe: "With `true`, a way in clear view uses the inflection rule, and the other ways get round corners."
+	}
+};
+/** The declarations of the options of the stretch order (LANE-STRETCH): the method and the passes of `sifting`. A generator can list each value. */
+const LANE_STRETCH_SCHEMA = {
+	method: {
+		type: "enum",
+		values: [
+			"none",
+			"consensus",
+			"periphery",
+			"sifting"
+		],
+		default: "sifting",
+		describe: "The order of each stretch: the order of each run alone, the order of the pair relation, the order of the largest run, or the order of the pair relation after sifting."
+	},
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 4,
+		step: 1,
+		default: 2,
+		describe: "The number of passes of the method `sifting`. In each pass, each edge moves to its best place."
+	}
+};
+/**
+* The declaration of the grouping rule of the edges: a name of `GROUP_RULE_NAMES`. A new name of the list needs no change here.
+* The option also takes a rule of the caller (`custom`), so the old value form stays valid.
+* The `defaults` of a strategy keep the rule `byCollection`, and the declaration gives its name `collection` as its `default`.
+*/
+const EDGE_RULE = {
+	type: "enum",
+	values: GROUP_RULE_NAMES,
+	custom: "function",
+	describe: "The grouping rule."
+};
+/** The declaration of the lane order of the shared ways of the routers `trunks` and `shared`. */
+const LANE_ORDER = {
+	type: "enum",
+	values: ["bundle", "run"],
+	default: "bundle",
+	describe: "With `bundle`, two edges keep one lane order on each shared way of their common stretch. With `run`, each shared way gets its order alone."
+};
+/** The declaration of the lane order of the runs of the router `sections`. The default keeps the lane order of version 0.2.0. */
+const RUN_LANE_ORDER = {
+	...LANE_ORDER,
+	default: "run"
+};
+/** The declarations of the options of the routers `corners` and `corners-smooth`. */
 const CORNERS_SCHEMA = {
 	...WAY_SCHEMA,
 	plugs: {
@@ -20018,6 +21873,20 @@ const CORNERS_SCHEMA = {
 		max: 20,
 		step: 1,
 		describe: "The distance from the walls of a frame to the bounds of its inner routes. Without a value, the inset is the margin."
+	},
+	inner: {
+		type: "enum",
+		values: ["corners", "gutter"],
+		default: "corners",
+		describe: "The mode of the inner routes. With `gutter`, each inner route is orthogonal in the gaps between the nodes of the frame, with a lane in each shared gap."
+	},
+	bendCost: {
+		type: "number",
+		min: 0,
+		max: 100,
+		step: 1,
+		default: 16,
+		describe: "The cost of one bend of an inner route of the mode `gutter`, in units of length. A larger cost gives fewer bends."
 	}
 };
 /** The declarations of the options of the router `trunks`. */
@@ -23235,6 +25104,235 @@ const INTERCHANGE_SCHEMA = {
 		describe: "An edge rides the network only when its way is this many times its first route or less."
 	}
 };
+/** The declarations of the options of the highway strategy `knee` (NAT-018). */
+const KNEE_SCHEMA = {
+	sweep: {
+		type: "integer",
+		min: 5,
+		max: 21,
+		step: 1,
+		marks: [
+			5,
+			11,
+			21
+		],
+		default: 11,
+		describe: "The number of points of the sweep of the balancing factor."
+	},
+	rule: {
+		type: "enum",
+		values: ["chord", "weights"],
+		default: "chord",
+		describe: "The rule that picks one tree: the knee of the chord, or the least weighted sum."
+	},
+	ink: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05,
+		marks: [
+			.25,
+			.5,
+			.75
+		],
+		default: .5,
+		describe: "The weight of the ink in the rule `weights`. The rest of the weight goes to the path length."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "An edge rides the tree only when its path in the tree is this many times its first route or less."
+	},
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 2,
+		describe: "A stretch of a tree with fewer edges than this number is not a highway."
+	}
+};
+/** The declarations of the options of the highway strategy `bronchial` (NAT-019). */
+const BRONCHIAL_SCHEMA = {
+	split: {
+		type: "enum",
+		values: [
+			"count",
+			"weight",
+			"gap"
+		],
+		default: "count",
+		describe: "The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap."
+	},
+	share: {
+		type: "number",
+		min: .3,
+		max: .7,
+		step: .05,
+		marks: [
+			.3,
+			.5,
+			.7
+		],
+		default: .5,
+		describe: "The share of the distance to the center of the targets that a branch grows."
+	},
+	smallest: {
+		type: "integer",
+		min: 1,
+		max: 3,
+		step: 1,
+		default: 1,
+		describe: "A set with this number of targets or fewer stops the splits."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "An edge rides the tree only when its path in the tree is this many times its first route or less."
+	},
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 2,
+		describe: "A stretch of a tree with fewer edges than this number is not a highway."
+	}
+};
+/** The declarations of the options of the level strategy `venation` (NAT-016): the options of `depths`, and the options of the backbone. */
+const VENATION_SCHEMA = {
+	...DEPTHS_SCHEMA,
+	backbone: {
+		type: "enum",
+		values: ["rng", "gabriel"],
+		default: "rng",
+		describe: "The graph of the backbone: the relative neighbourhood graph, or the Gabriel graph."
+	},
+	discount: {
+		type: "number",
+		min: 0,
+		max: .8,
+		step: .05,
+		marks: [
+			0,
+			.4,
+			.8
+		],
+		default: .4,
+		describe: "The share of the cost of a backbone link that a later level link saves when an earlier link uses it."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "A level link takes its way on the backbone only when that way is this many times its direct link or less."
+	},
+	maxItems: {
+		type: "integer",
+		min: 10,
+		max: 2e3,
+		step: 10,
+		marks: [
+			100,
+			400,
+			1e3
+		],
+		default: 400,
+		describe: "A level with more items than this number keeps the links of `depths`."
+	}
+};
+/** The declarations of the options of the whole strategy `board-portfolio` (WILD-045). */
+const BOARD_PORTFOLIO_SCHEMA = {
+	settings: {
+		type: "integer",
+		min: 3,
+		max: 12,
+		step: 1,
+		marks: [
+			3,
+			4,
+			8,
+			12
+		],
+		default: 4,
+		describe: "The number of settings that the portfolio tries, from the start of its list."
+	},
+	crossings: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The weight of the crossings (R1) in the score."
+	},
+	detour: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The weight of the median detour (R5) in the score."
+	},
+	ink: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The weight of the ink saved (B1) in the score."
+	},
+	budget: {
+		type: "number",
+		min: 0,
+		max: 10,
+		step: .1,
+		marks: [
+			0,
+			1,
+			10
+		],
+		default: 0,
+		describe: "The time budget in seconds. The value 0 sets no budget."
+	}
+};
 // src/strategies/builtins.ts
 /** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
 function routerStrategy(name, describe, maxNodes, defaults, make, schema) {
@@ -23968,6 +26066,24 @@ const highwayStrategies = Object.freeze({
 		maxNodes: 1e4,
 		run: (input, o) => interchangePlan(input, o)
 	}),
+	knee: defineStrategy({
+		step: "highway",
+		name: "knee",
+		describe: "The knee of the plant front (NAT-018). A sweep of the balancing factor of NAT-017 gives trees, and the tree at the knee of ink against path length wins.",
+		defaults: { ...KNEE_DEFAULTS },
+		schema: KNEE_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => kneePlan(input, o)
+	}),
+	bronchial: defineStrategy({
+		step: "highway",
+		name: "bronchial",
+		describe: "Bronchial splits that fill the space (NAT-019). The tree grows toward the center of its targets, then splits the targets in two halves, again and again.",
+		defaults: { ...BRONCHIAL_DEFAULTS },
+		schema: BRONCHIAL_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => bronchialPlan(input, o)
+	}),
 	"corridors+breakeven": gateStrategy(corridors, breakEvenGate),
 	"corridors+stretch": gateStrategy(corridors, stretchGate),
 	"corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -24014,26 +26130,74 @@ const plugStrategies = Object.freeze({
 	})
 });
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
-const levelStrategies = Object.freeze({ depths: defineStrategy({
-	step: "levels",
-	name: "depths",
-	describe: "One zoom level for each depth of the tree, and a last level with each node alone. A link of a level goes around the other items. It is the default of the router `sections`.",
-	defaults: {},
-	schema: DEPTHS_SCHEMA,
-	run: (input, o) => depthLevels(input, o)
-}) });
+const levelStrategies = Object.freeze({
+	depths: defineStrategy({
+		step: "levels",
+		name: "depths",
+		describe: "One zoom level for each depth of the tree, and a last level with each node alone. A link of a level goes around the other items. It is the default of the router `sections`.",
+		defaults: {},
+		schema: DEPTHS_SCHEMA,
+		run: (input, o) => depthLevels(input, o)
+	}),
+	venation: defineStrategy({
+		step: "levels",
+		name: "venation",
+		describe: "A closed venation backbone (NAT-016). The links of each level with groups take their ways along the relative neighbourhood graph of the items.",
+		defaults: { ...VENATION_DEFAULTS },
+		schema: VENATION_SCHEMA,
+		run: (input, o) => venationLevels(input, o)
+	})
+});
+/**
+* The fixed list of settings of the whole strategy `board-portfolio` (WILD-045), in order. The option `settings` takes the first ones.
+* The list holds routers and highway strategies with their defaults. It comes from the catalog of the strategies, not from a fit to the screen.
+*/
+const BOARD_PORTFOLIO_SETTINGS = Object.freeze([...[
+	"shared",
+	"corners",
+	"trunks",
+	"sections",
+	"sections-tree",
+	"corners-smooth"
+].map((name) => ({
+	name,
+	pipeline: { router: routerStrategies[name] }
+})), ...[
+	"corridors",
+	"shared-ways",
+	"road-classes",
+	"steiner",
+	"knee",
+	"bronchial"
+].map((name) => ({
+	name: `highway:${name}`,
+	pipeline: {
+		router: routerStrategies.corners,
+		highway: highwayStrategies[name]
+	}
+}))].map((s) => Object.freeze(s)));
 /**
 * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
 * Without options, it routes the graph with the router `corners`.
 */
-const wholeStrategies = Object.freeze({ pipeline: defineStrategy({
-	step: "whole",
-	name: "pipeline",
-	describe: "One setting of the steps. The room opens the board, then the router or the highway plan routes it with the rules that the router reads.",
-	defaults: { router: routerStrategies.corners },
-	schema: PIPELINE_SCHEMA,
-	run: (graph, o) => runPipeline(graph, o)
-}) });
+const wholeStrategies = Object.freeze({
+	pipeline: defineStrategy({
+		step: "whole",
+		name: "pipeline",
+		describe: "One setting of the steps. The room opens the board, then the router or the highway plan routes it with the rules that the router reads.",
+		defaults: { router: routerStrategies.corners },
+		schema: PIPELINE_SCHEMA,
+		run: (graph, o) => runPipeline(graph, o)
+	}),
+	"board-portfolio": defineStrategy({
+		step: "whole",
+		name: "board-portfolio",
+		describe: "A portfolio for each board (WILD-045). The pipeline tries a fixed list of settings, and the least weighted rank of crossings, detour and ink wins.",
+		defaults: { ...BOARD_PORTFOLIO_DEFAULTS },
+		schema: BOARD_PORTFOLIO_SCHEMA,
+		run: (graph, o) => boardPortfolio(graph, BOARD_PORTFOLIO_SETTINGS, o).output
+	})
+});
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 const BUILT_IN_STRATEGIES = Object.freeze([
 	...Object.values(groupStrategies),
@@ -24091,252 +26255,68 @@ function fixPorts(graph, rule, options = {}) {
 	const added = /* @__PURE__ */ new Map();
 	const taken = /* @__PURE__ */ new Map();
 	const portsOf = (node) => {
-		let m = fixed.get(node.id);
-		if (!m) fixed.set(node.id, m = /* @__PURE__ */ new Map());
-		return m;
-	};
-	const fix = (node, plug, base) => ({
-		...base,
-		side: sideOf(plug, node),
-		at: {
-			x: plug.point.x - node.box.x,
-			y: plug.point.y - node.box.y
-		}
-	});
-	const outerEdges = new Set(outer.edges);
-	const edges = graph.edges.map((e) => {
-		if (!outerEdges.has(e)) return e;
-		const pair = byEdge.get(e.id)?.shift();
-		if (!pair) return e;
-		const end = (which, plug) => {
-			const own = e[which];
-			const node = byId.get(own.node);
-			if (!node) return own;
-			if (own.port === void 0) {
-				if (!options.newPorts) return own;
-				let ids = taken.get(node.id);
-				if (!ids) taken.set(node.id, ids = new Set((node.ports ?? []).map((p) => p.id)));
-				const id = freeId(ids, `${e.id}:${which}`);
-				const list = added.get(node.id) ?? [];
-				list.push(fix(node, plug, { id }));
-				added.set(node.id, list);
-				return {
-					...own,
-					port: id
-				};
-			}
-			const port = node.ports?.find((p) => p.id === own.port);
-			if (!port || portOffset(node.box, port) !== void 0) return own;
-			const m = portsOf(node);
-			if (!m.has(port.id)) m.set(port.id, fix(node, plug, port));
-			return own;
-		};
-		const source = end("source", pair.source);
-		const target = end("target", pair.target);
-		return source === e.source && target === e.target ? e : {
-			...e,
-			source,
-			target
-		};
-	});
-	const nodes = graph.nodes.map((n) => {
-		const m = fixed.get(n.id);
-		const more = added.get(n.id);
-		if (!m && !more) return n;
-		const ports = (n.ports ?? []).map((p) => m?.get(p.id) ?? p);
-		return {
-			...n,
-			ports: more ? [...ports, ...more] : ports
-		};
-	});
-	return {
-		...graph,
-		nodes,
-		edges
-	};
-}
-// src/bench/quality.ts
-/** The clearance stops at this distance. */
-const CLEARANCE_CAP = 40;
-const TIGHT = 4;
-const EXACT_CROSSINGS = 2e4;
-const SAMPLE = 2e3;
-const key = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
-/** This function measures the quality of a result. */
-function measureQuality(graph, result) {
-	const byId = nodeIndex(graph);
-	const nodes = new Grid(180);
-	for (const n of graph.nodes) nodes.add(n, n.box);
-	const segs = [];
-	const seen = /* @__PURE__ */ new Set();
-	let bends = 0;
-	let infl = 0;
-	let clear = 0;
-	let tight = 0;
-	let detour = 0;
-	let detourN = 0;
-	let angle = 0;
-	let angleN = 0;
-	for (const r of result.routes) {
-		const p = r.points;
-		for (let i = 1; i < p.length; i++) {
-			const ka = key(p[i - 1]);
-			const kb = key(p[i]);
-			if (ka === kb) continue;
-			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
-			if (seen.has(k)) continue;
-			seen.add(k);
-			segs.push([p[i - 1], p[i]]);
-		}
-		bends += bendCount(p);
-		infl += inflectionCount(p);
-		const ends = endNodes(graph, byId, r.edge);
-		let c = 40;
-		for (let i = 1; i < p.length; i++) {
-			const a = p[i - 1];
-			const b = p[i];
-			nodes.querySegment(a, b, c, (n) => {
-				if (n !== ends.source && n !== ends.target) c = Math.min(c, segmentBoxDistance(a, b, n.box));
-			});
-		}
-		clear += c;
-		if (c < TIGHT) tight++;
-		if (p.length >= 2) {
-			const d = dist(p[0], p[p.length - 1]);
-			if (d > 1) {
-				detour += polylineLength(p) / d;
-				detourN++;
-			}
-			for (const [at, next, node] of [[
-				p[0],
-				p[1],
-				ends.source
-			], [
-				p[p.length - 1],
-				p[p.length - 2],
-				ends.target
-			]]) {
-				if (!node) continue;
-				const a = sideAngle(node.box, at, next);
-				if (a !== void 0) {
-					angle += a;
-					angleN++;
-				}
-			}
-		}
-	}
-	const n = Math.max(1, result.routes.length);
-	let ink = 0;
-	for (const [a, b] of segs) ink += dist(a, b);
-	const [crossings, crossingsEstimated] = countCrossings(segs);
-	return {
-		ink,
-		crossings,
-		crossingsEstimated,
-		bends: bends / n,
-		inflections: infl / n,
-		clearance: clear / n,
-		tight: tight / n,
-		detour: detourN ? detour / detourN : 1,
-		plugAngle: angleN ? angle / angleN : 0
-	};
-}
-function endNodes(graph, byId, edgeId) {
-	const e = edgeIndex(graph).get(edgeId);
-	return {
-		source: e && byId.get(e.source.node),
-		target: e && byId.get(e.target.node)
-	};
-}
-const edgeIndexes = /* @__PURE__ */ new WeakMap();
-function edgeIndex(graph) {
-	let m = edgeIndexes.get(graph);
-	if (!m) {
-		m = /* @__PURE__ */ new Map();
-		for (const e of graph.edges) m.set(e.id, e);
-		edgeIndexes.set(graph, m);
-	}
-	return m;
-}
-/**
-* This function gives an angle in degrees: the angle between the segment from `at` to `next` and the outward normal.
-* The normal is the normal of the side of the box nearest to `at`. A route that starts inside the box (an interior route) gives no angle.
-*/
-function sideAngle(box, at, next) {
-	const d = [
-		[
-			Math.abs(at.y - box.y),
-			0,
-			-1
-		],
-		[
-			Math.abs(at.x - (box.x + box.w)),
-			1,
-			0
-		],
-		[
-			Math.abs(at.y - (box.y + box.h)),
-			0,
-			1
-		],
-		[
-			Math.abs(at.x - box.x),
-			-1,
-			0
-		]
-	].sort((a, b) => a[0] - b[0])[0];
-	if (d[0] > 1) return void 0;
-	const vx = next.x - at.x;
-	const vy = next.y - at.y;
-	const l = Math.hypot(vx, vy);
-	if (l === 0) return void 0;
-	const cos = Math.max(-1, Math.min(1, (vx * d[1] + vy * d[2]) / l));
-	return Math.acos(cos) * 180 / Math.PI;
-}
-/**
-* This function counts the crossings of a set of segments with a grid of buckets.
-* Above 20 000 segments, it counts the crossings of a seeded sample of 2 000 segments and scales the count.
-*/
-function countCrossings(segs) {
-	if (segs.length < 2) return [0, false];
-	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
-	const grid = new Grid(Math.max(20, len));
-	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
-	const exact = segs.length <= EXACT_CROSSINGS;
-	const R = rng(segs.length);
-	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE }, () => Math.floor(R() * segs.length));
-	let count = 0;
-	for (const i of pick) {
-		const [a, b] = segs[i];
-		grid.querySegment(a, b, 0, (j) => {
-			if (exact && j <= i) return;
-			if (j === i) return;
-			const [c, d] = segs[j];
-			if (segmentsCross(a, b, c, d)) count++;
-		});
-	}
-	return exact ? [count, false] : [Math.round(count * segs.length / (2 * pick.length)), true];
-}
-/** This function measures how much the routes changed between two results. */
-function measureStability(before, after) {
-	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
-	let sum = 0;
-	let max = 0;
-	let moved = 0;
-	let n = 0;
-	for (const r of after.routes) {
-		const p = prev.get(r.edge);
-		if (!p) continue;
-		const f = frechet(p, r.points);
-		sum += f;
-		max = Math.max(max, f);
-		if (f > 1) moved++;
-		n++;
-	}
+		let m = fixed.get(node.id);
+		if (!m) fixed.set(node.id, m = /* @__PURE__ */ new Map());
+		return m;
+	};
+	const fix = (node, plug, base) => ({
+		...base,
+		side: sideOf(plug, node),
+		at: {
+			x: plug.point.x - node.box.x,
+			y: plug.point.y - node.box.y
+		}
+	});
+	const outerEdges = new Set(outer.edges);
+	const edges = graph.edges.map((e) => {
+		if (!outerEdges.has(e)) return e;
+		const pair = byEdge.get(e.id)?.shift();
+		if (!pair) return e;
+		const end = (which, plug) => {
+			const own = e[which];
+			const node = byId.get(own.node);
+			if (!node) return own;
+			if (own.port === void 0) {
+				if (!options.newPorts) return own;
+				let ids = taken.get(node.id);
+				if (!ids) taken.set(node.id, ids = new Set((node.ports ?? []).map((p) => p.id)));
+				const id = freeId(ids, `${e.id}:${which}`);
+				const list = added.get(node.id) ?? [];
+				list.push(fix(node, plug, { id }));
+				added.set(node.id, list);
+				return {
+					...own,
+					port: id
+				};
+			}
+			const port = node.ports?.find((p) => p.id === own.port);
+			if (!port || portOffset(node.box, port) !== void 0) return own;
+			const m = portsOf(node);
+			if (!m.has(port.id)) m.set(port.id, fix(node, plug, port));
+			return own;
+		};
+		const source = end("source", pair.source);
+		const target = end("target", pair.target);
+		return source === e.source && target === e.target ? e : {
+			...e,
+			source,
+			target
+		};
+	});
+	const nodes = graph.nodes.map((n) => {
+		const m = fixed.get(n.id);
+		const more = added.get(n.id);
+		if (!m && !more) return n;
+		const ports = (n.ports ?? []).map((p) => m?.get(p.id) ?? p);
+		return {
+			...n,
+			ports: more ? [...ports, ...more] : ports
+		};
+	});
 	return {
-		mean: n ? sum / n : 0,
-		max,
-		moved: n ? moved / n : 0
+		...graph,
+		nodes,
+		edges
 	};
 }
 // src/bench/run.ts
@@ -29659,10 +31639,12 @@ const count = (name, min, max, value, meaning) => numberDimension({
 	default: value,
 	meaning
 });
-/** This function gives the numbers of the full dimension values, by name. */
+/** This function gives the numbers of the full dimension values, by name. A dimension that is not `int` or `real` is not in them. */
 function numbers(dimensions, dims) {
-	return Object.fromEntries(dimensions.map((d) => [d.name, numberOf(dims, d.name)]));
+	return Object.fromEntries(dimensions.filter((d) => d.kind === "int" || d.kind === "real").map((d) => [d.name, numberOf(dims, d.name)]));
 }
+/** The default rule of the random numbers of a case family. */
+const CASE_SEEDING = "mulberry32 of the input seed. The fixed part of the board takes no number. Then one stream gives the random links.";
 /** This function gives a case family. Its stream is mulberry32 of the input seed, and it uses only the stream, `Math.floor` and `Math.ceil`. */
 function caseFamily(fields) {
 	const { name, meaning, dimensions } = fields;
@@ -29673,11 +31655,11 @@ function caseFamily(fields) {
 		owner: "highways",
 		meaning,
 		dimensions,
-		seeding: "mulberry32 of the input seed. The fixed part of the board takes no number. Then one stream gives the random links.",
+		seeding: fields.seeding ?? CASE_SEEDING,
 		crossEngine: "exact",
 		generate(seed, dims, context) {
 			return {
-				graph: fields.make(numbers(dimensions, dims), seed, context.random),
+				graph: fields.make(numbers(dimensions, dims), seed, context.random, dims),
 				generator: {
 					name: fields.generator,
 					version: 1,
@@ -29759,6 +31741,508 @@ const PACKED_GRID = caseFamily({
 		reach: v["reach"]
 	}, random)
 });
+// src/families/coverage.ts
+/** A board while it grows. It adds no loop, and no second edge between the same two ends. */
+var Builder = class {
+	nodes = [];
+	edges = [];
+	#keys = /* @__PURE__ */ new Set();
+	node(id, x, y, w, h, extra = {}) {
+		this.nodes.push({
+			id,
+			box: {
+				x,
+				y,
+				w,
+				h
+			},
+			...extra.parent !== void 0 ? { parent: extra.parent } : {},
+			...extra.ports ? { ports: extra.ports } : {}
+		});
+		return id;
+	}
+	/** This method adds an edge. The key of an end is its node and its plug. It adds nothing for a loop or a second edge between the same two ends. */
+	link(source, target) {
+		if (source.node === target.node) return;
+		const a = `${source.node}:${source.port ?? ""}`;
+		const b = `${target.node}:${target.port ?? ""}`;
+		const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (this.#keys.has(key)) return;
+		this.#keys.add(key);
+		this.edges.push({
+			id: `e${this.edges.length}`,
+			source,
+			target
+		});
+	}
+	graph() {
+		return {
+			nodes: this.nodes,
+			edges: this.edges
+		};
+	}
+};
+/** This function gives a whole number from `lo` to `hi`, both included. */
+const int = (random, lo, hi) => lo + Math.floor(random() * (hi - lo + 1));
+/** This function gives the least whole number `s` with `s × s` equal to `v` or more. It uses no square root, so each engine gives the same value. */
+function ceilSqrt(v) {
+	let lo = 0;
+	let hi = Math.max(1, v);
+	while (lo < hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (mid * mid >= v) hi = mid;
+		else lo = mid + 1;
+	}
+	return lo;
+}
+/** This function gives `k` of the indices 0 to `n - 1` at random, in increasing order. It uses a part of the shuffle of Fisher and Yates. */
+function choose(random, n, k) {
+	const list = Array.from({ length: n }, (_, i) => i);
+	const take = Math.min(k, n);
+	for (let i = 0; i < take; i++) {
+		const j = int(random, i, n - 1);
+		[list[i], list[j]] = [list[j], list[i]];
+	}
+	return list.slice(0, take).sort((a, b) => a - b);
+}
+/** This function gives the indices 0 to `n - 1` in a random order, with the shuffle of Fisher and Yates. */
+function shuffle(random, n) {
+	const list = Array.from({ length: n }, (_, i) => i);
+	for (let i = n - 1; i > 0; i--) {
+		const j = int(random, 0, i);
+		[list[i], list[j]] = [list[j], list[i]];
+	}
+	return list;
+}
+/** The rule of the random numbers of each family of this file. */
+const SEEDING = "mulberry32 of the input seed. One stream gives the sizes and the places of the boxes, then the edges, in a fixed order.";
+/**
+* The family `frame-rows`: cards with full-width rows, as INTERIOR-ROUTE takes them. Each row has a fixed plug on the east wall and on the west wall of its card.
+* The links join a plug of a card to a plug of another card. An inner edge joins a row to a plug of its own card. The default has no inner edge.
+*/
+const FRAME_ROWS = caseFamily({
+	name: "frame-rows",
+	meaning: "Cards with full-width rows and fixed plugs on their walls, as tables of a schema diagram.",
+	dimensions: Object.freeze([
+		count("cards", 1, 24, 9, "The number of cards. Each card is a frame."),
+		count("rows", 1, 12, 5, "The number of full-width rows in each card."),
+		count("links", 0, 8, 4, "The number of tries for a link from a wall plug of a card to a wall plug of another card, for each card."),
+		count("inner", 0, 12, 0, "The number of tries for an inner edge from a row to a wall plug of its card, for each card."),
+		count("gap", 24, 240, 96, "The free space between two cards, in units.")
+	]),
+	generator: "family.frame-rows",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const cards = v["cards"];
+		const rows = v["rows"];
+		const gap = v["gap"];
+		const cols = ceilSqrt(cards);
+		const w = 220;
+		const header = 28;
+		const pitch = 30;
+		const h = header + rows * pitch + 4;
+		const ports = [];
+		for (let j = 0; j < rows; j++) {
+			const along = (header + j * pitch + 12) / h;
+			ports.push({
+				id: `e${j}`,
+				side: "east",
+				along
+			}, {
+				id: `w${j}`,
+				side: "west",
+				along
+			});
+		}
+		const colOf = (i) => i % cols;
+		for (let i = 0; i < cards; i++) {
+			const x = colOf(i) * (w + gap);
+			const y = Math.floor(i / cols) * (h + gap);
+			const card = b.node(`f${i}`, x, y, w, h, { ports });
+			for (let j = 0; j < rows; j++) b.node(`f${i}r${j}`, x + 10, y + header + j * pitch, 200, 24, { parent: card });
+		}
+		for (let n = 0; n < cards * v["links"]; n++) {
+			const a = int(random, 0, cards - 1);
+			const c = int(random, 0, cards - 1);
+			const ra = int(random, 0, rows - 1);
+			const rc = int(random, 0, rows - 1);
+			const east = colOf(a) <= colOf(c);
+			b.link({
+				node: `f${a}`,
+				port: `${east ? "e" : "w"}${ra}`
+			}, {
+				node: `f${c}`,
+				port: `${east ? "w" : "e"}${rc}`
+			});
+		}
+		for (let i = 0; i < cards; i++) for (let t = 0; t < v["inner"]; t++) {
+			const row = int(random, 0, rows - 1);
+			const side = random() < .5 ? "e" : "w";
+			b.link({ node: `f${i}r${row}` }, {
+				node: `f${i}`,
+				port: `${side}${int(random, 0, rows - 1)}`
+			});
+		}
+		return b.graph();
+	}
+});
+/** The family `pipeline`: a long chain of stages in rows that turn at each end, with some links that skip stages. */
+const PIPELINE = caseFamily({
+	name: "pipeline",
+	meaning: "A long chain of stages in rows that turn at each end, with a few links that skip stages.",
+	dimensions: Object.freeze([
+		count("stages", 4, 240, 72, "The number of stages of the chain."),
+		count("perRow", 2, 40, 12, "The number of stages in each row. The chain turns at the end of each row."),
+		count("skips", 0, 80, 8, "The number of tries for a link that skips 1 to 3 stages."),
+		count("gap", 16, 160, 56, "The free space between two stages, in units.")
+	]),
+	generator: "family.pipeline",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const stages = v["stages"];
+		const perRow = v["perRow"];
+		const gap = v["gap"];
+		const cell = 120;
+		for (let i = 0; i < stages; i++) {
+			const r = Math.floor(i / perRow);
+			const p = i % perRow;
+			const col = r % 2 === 0 ? p : perRow - 1 - p;
+			const w = int(random, 72, cell);
+			b.node(`s${i}`, col * (cell + gap) + Math.floor((cell - w) / 2), r * (40 + gap), w, 40);
+		}
+		for (let i = 0; i + 1 < stages; i++) b.link({ node: `s${i}` }, { node: `s${i + 1}` });
+		for (let n = 0; n < v["skips"]; n++) {
+			const s = int(random, 0, stages - 1);
+			const d = int(random, 2, 4);
+			if (s + d < stages) b.link({ node: `s${s}` }, { node: `s${s + d}` });
+		}
+		return b.graph();
+	}
+});
+/** This function gives the cells of the square ring `r` around the cell (0, 0), in a fixed order. */
+function ring(r) {
+	const out = [];
+	for (let dy = -r; dy <= r; dy++) for (let dx = -r; dx <= r; dx++) if (Math.max(Math.abs(dx), Math.abs(dy)) === r) out.push([dx, dy]);
+	return out;
+}
+/** The family `fan-out`: one large hub in the middle, with a link to each leaf on the square rings around it. */
+const FAN_OUT = caseFamily({
+	name: "fan-out",
+	meaning: "A wide fan-out: one hub in the middle links to each leaf on the rings around it.",
+	dimensions: Object.freeze([
+		count("leaves", 4, 240, 96, "The number of leaves. The hub links to each leaf."),
+		count("cross", 0, 120, 8, "The number of tries for a link between two leaves."),
+		count("gap", 8, 120, 36, "The free space between two leaves, in units.")
+	]),
+	generator: "family.fan-out",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const leaves = v["leaves"];
+		const gap = v["gap"];
+		const cw = 80 + gap;
+		const ch = 32 + gap;
+		const cells = [];
+		let r = 2;
+		while (cells.length < leaves + Math.floor(leaves / 4)) cells.push(...ring(r++));
+		const reach = r - 1;
+		const at = (dx, dy) => [(dx + reach) * cw, (dy + reach) * ch];
+		const [hx, hy] = at(-1, -1);
+		const hub = b.node("hub", hx, hy, 2 * cw + 80, 2 * ch + 32);
+		const ids = [];
+		for (const i of choose(random, cells.length, leaves)) {
+			const [x, y] = at(...cells[i]);
+			const w = int(random, 48, 80);
+			const h = int(random, 20, 32);
+			ids.push(b.node(`l${ids.length}`, x, y, w, h));
+		}
+		for (const id of ids) b.link({ node: hub }, { node: id });
+		for (let n = 0; n < v["cross"]; n++) b.link({ node: ids[int(random, 0, ids.length - 1)] }, { node: ids[int(random, 0, ids.length - 1)] });
+		return b.graph();
+	}
+});
+/** The family `two-hubs`: two tall hubs with many nodes between them. Each such node has a link from each hub. A few nodes of one hub are on its far side. */
+const TWO_HUBS = caseFamily({
+	name: "two-hubs",
+	meaning: "Two hubs that share many targets between them: two fans that overlap.",
+	dimensions: Object.freeze([
+		count("shared", 0, 160, 48, "The number of nodes between the hubs. Each of them has a link from each hub."),
+		count("own", 0, 80, 12, "The number of nodes on the far side of each hub, with a link from that hub only."),
+		count("span", 1, 12, 5, "The number of columns of nodes between the two hubs."),
+		count("gap", 8, 120, 36, "The free space between two nodes, in units.")
+	]),
+	generator: "family.two-hubs",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const shared = v["shared"];
+		const own = v["own"];
+		const span = v["span"];
+		const gap = v["gap"];
+		const cw = 64 + gap;
+		const ch = 28 + gap;
+		const ceilDiv = (a, d) => Math.floor((a + d - 1) / d);
+		const rows = Math.max(1, ceilDiv(shared + Math.floor(shared / 4), span), ceilDiv(own + Math.floor(own / 4), 2));
+		const hubH = rows * ch - gap;
+		const a = b.node("A", 2 * cw, 0, 64, hubH);
+		const z = b.node("B", (span + 3) * cw, 0, 64, hubH);
+		const place = (prefix, first, cols, n) => choose(random, cols * rows, n).map((c, i) => b.node(`${prefix}${i}`, (first + c % cols) * cw, Math.floor(c / cols) * ch, 64, 28));
+		const mid = place("m", 3, span, shared);
+		const left = place("a", 0, 2, own);
+		const right = place("b", span + 4, 2, own);
+		for (const id of mid) {
+			b.link({ node: a }, { node: id });
+			b.link({ node: z }, { node: id });
+		}
+		for (const id of left) b.link({ node: a }, { node: id });
+		for (const id of right) b.link({ node: z }, { node: id });
+		b.link({ node: a }, { node: z });
+		return b.graph();
+	}
+});
+/** The family `uneven-sizes`: a few large boxes and many small boxes in shelves, in a random order. Many edges end on a large box. */
+const UNEVEN_SIZES = caseFamily({
+	name: "uneven-sizes",
+	meaning: "Very uneven box sizes: a few large boxes among many small boxes.",
+	dimensions: Object.freeze([
+		count("small", 4, 300, 90, "The number of small boxes."),
+		count("large", 1, 16, 4, "The number of large boxes."),
+		count("ratio", 2, 10, 5, "The size of a large box, divided by the size of a small box."),
+		numberDimension({
+			name: "edgesPerNode",
+			kind: "real",
+			min: .5,
+			max: 4,
+			default: 1.5,
+			meaning: "The number of tries for an edge, divided by the number of boxes."
+		}),
+		numberDimension({
+			name: "toLarge",
+			kind: "real",
+			min: 0,
+			max: 1,
+			default: .5,
+			meaning: "The share of the edges with a large box at one end."
+		}),
+		count("gap", 8, 120, 30, "The free space between two boxes, in units.")
+	]),
+	generator: "family.uneven-sizes",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const ratio = v["ratio"];
+		const gap = v["gap"];
+		const boxes = [];
+		for (let i = 0; i < v["large"]; i++) boxes.push({
+			id: `L${i}`,
+			w: ratio * int(random, 48, 72),
+			h: ratio * int(random, 24, 36)
+		});
+		for (let i = 0; i < v["small"]; i++) boxes.push({
+			id: `s${i}`,
+			w: int(random, 40, 80),
+			h: int(random, 20, 40)
+		});
+		const order = shuffle(random, boxes.length);
+		const area = boxes.reduce((s, x) => s + (x.w + gap) * (x.h + gap), 0);
+		const width = Math.max(...boxes.map((x) => x.w), Math.floor(3 * ceilSqrt(area) / 2));
+		const places = /* @__PURE__ */ new Map();
+		let x = 0;
+		let y = 0;
+		let shelf = 0;
+		for (const i of order) {
+			const box = boxes[i];
+			if (x > 0 && x + box.w > width) {
+				x = 0;
+				y += shelf + gap;
+				shelf = 0;
+			}
+			places.set(box.id, [x, y]);
+			x += box.w + gap + int(random, 0, gap);
+			shelf = Math.max(shelf, box.h);
+		}
+		for (const box of boxes) {
+			const [px, py] = places.get(box.id);
+			b.node(box.id, px, py, box.w, box.h);
+		}
+		const ids = boxes.map((x) => x.id);
+		const large = ids.slice(0, v["large"]);
+		const tries = Math.round(v["edgesPerNode"] * ids.length);
+		for (let n = 0; n < tries; n++) {
+			const s = ids[int(random, 0, ids.length - 1)];
+			const t = random() < v["toLarge"] ? large[int(random, 0, large.length - 1)] : ids[int(random, 0, ids.length - 1)];
+			b.link({ node: s }, { node: t });
+		}
+		return b.graph();
+	}
+});
+/** The family `thin-bars`: long thin bars in lanes, as a timeline or the rows of a table. The links join bars of lanes near each other. */
+const THIN_BARS = caseFamily({
+	name: "thin-bars",
+	meaning: "Long thin boxes in lanes, as a timeline or the rows of a table.",
+	dimensions: Object.freeze([
+		count("lanes", 2, 40, 16, "The number of lanes. Each lane is a row of a timeline."),
+		count("bars", 1, 12, 5, "The number of bars in each lane."),
+		count("links", 0, 240, 64, "The number of tries for a link between two bars of lanes near each other."),
+		count("thick", 4, 32, 12, "The height of each bar, in units."),
+		count("gap", 4, 80, 16, "The free space between two lanes, in units.")
+	]),
+	generator: "family.thin-bars",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const lanes = v["lanes"];
+		const bars = v["bars"];
+		const thick = v["thick"];
+		for (let i = 0; i < lanes; i++) {
+			let x = int(random, 0, 80);
+			for (let j = 0; j < bars; j++) {
+				const w = int(random, 120, 420);
+				b.node(`t${i}-${j}`, x, i * (thick + v["gap"]), w, thick);
+				x += w + int(random, 24, 120);
+			}
+		}
+		for (let n = 0; n < v["links"]; n++) {
+			const a = int(random, 0, lanes - 1);
+			const c = Math.max(0, Math.min(lanes - 1, a + int(random, -3, 3)));
+			b.link({ node: `t${a}-${int(random, 0, bars - 1)}` }, { node: `t${c}-${int(random, 0, bars - 1)}` });
+		}
+		return b.graph();
+	}
+});
+/** The family `sparse-long`: few nodes far apart on a large board, and edges that go to far targets. */
+const SPARSE_LONG = caseFamily({
+	name: "sparse-long",
+	meaning: "A sparse board: few nodes far apart, with long edges across the board.",
+	dimensions: Object.freeze([
+		count("nodes", 4, 120, 36, "The number of nodes."),
+		count("edges", 0, 160, 36, "The number of tries for a long edge."),
+		count("spacing", 200, 1200, 480, "The size of the square cell of each node, in units."),
+		count("far", 1, 8, 4, "The number of random targets of an edge. The edge takes the target farthest from its source.")
+	]),
+	generator: "family.sparse-long",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const n = v["nodes"];
+		const spacing = v["spacing"];
+		const cols = ceilSqrt(n);
+		for (let i = 0; i < n; i++) {
+			const w = int(random, 80, 120);
+			const h = int(random, 32, 56);
+			b.node(`n${i}`, i % cols * spacing + int(random, 0, spacing - w - 40), Math.floor(i / cols) * spacing + int(random, 0, spacing - h - 40), w, h);
+		}
+		const dist = (i, j) => Math.abs(i % cols - j % cols) + Math.abs(Math.floor(i / cols) - Math.floor(j / cols));
+		for (let e = 0; e < v["edges"]; e++) {
+			const s = int(random, 0, n - 1);
+			let best = -1;
+			let far = -1;
+			for (let f = 0; f < v["far"]; f++) {
+				const t = int(random, 0, n - 1);
+				if (t !== s && dist(s, t) > far) {
+					best = t;
+					far = dist(s, t);
+				}
+			}
+			if (best >= 0) b.link({ node: `n${s}` }, { node: `n${best}` });
+		}
+		return b.graph();
+	}
+});
+/** The family `local-mesh`: a grid of small nodes with many short edges, each to a node of the 8 nodes around it. */
+const LOCAL_MESH = caseFamily({
+	name: "local-mesh",
+	meaning: "Many short local edges: each node links to nodes next to it in a grid.",
+	dimensions: Object.freeze([
+		count("cols", 2, 40, 12, "The number of columns of nodes."),
+		count("rows", 2, 30, 9, "The number of rows of nodes."),
+		count("degree", 1, 6, 3, "The number of tries for an edge to one of the 8 nodes around a node, for each node."),
+		count("gap", 8, 80, 20, "The free space between two nodes, in units."),
+		count("jitter", 0, 40, 8, "The largest random move of a node in its cell, in units. The move stays 8 units or more below the gap.")
+	]),
+	generator: "family.local-mesh",
+	seeding: SEEDING,
+	make: (v, _seed, random) => {
+		const b = new Builder();
+		const cols = v["cols"];
+		const rows = v["rows"];
+		const gap = v["gap"];
+		const move = Math.min(v["jitter"], gap - 8);
+		const id = (r, c) => `m${r}-${c}`;
+		for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * (48 + gap) + int(random, 0, move), r * (28 + gap) + int(random, 0, move), 48, 28);
+		for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) for (let t = 0; t < v["degree"]; t++) {
+			const rr = r + int(random, -1, 1);
+			const cc = c + int(random, -1, 1);
+			if (rr >= 0 && rr < rows && cc >= 0 && cc < cols) b.link({ node: id(r, c) }, { node: id(rr, cc) });
+		}
+		return b.graph();
+	}
+});
+/** The values of the dimension `layout` of `bipartite`. */
+const BIPARTITE_LAYOUTS = Object.freeze(["rows", "mixed"]);
+/**
+* The family `bipartite`: a complete bipartite part, with dense crossings that no plan can remove, and other nodes with random links.
+* At 3 nodes or more on each side, the part has no drawing without crossings.
+*/
+const BIPARTITE = caseFamily({
+	name: "bipartite",
+	meaning: "An adversarial board: a complete bipartite part whose crossings no plan can remove.",
+	dimensions: Object.freeze([
+		count("left", 2, 16, 6, "The number of nodes of the first side of the complete bipartite part."),
+		count("right", 2, 16, 6, "The number of nodes of the second side. Each node of the first side links to each node of the second side."),
+		count("noise", 0, 120, 24, "The number of other nodes, in a band below the bipartite part."),
+		count("extra", 0, 160, 24, "The number of tries for a random link between two nodes of the board."),
+		enumDimension("layout", BIPARTITE_LAYOUTS, "rows", "The places of the bipartite part. `rows`: each side in one row, one row above the other. `mixed`: all the nodes at random cells of one grid."),
+		count("gap", 16, 160, 64, "The free space between two nodes, in units.")
+	]),
+	generator: "family.bipartite",
+	seeding: SEEDING,
+	make: (v, _seed, random, dims) => {
+		const b = new Builder();
+		const left = v["left"];
+		const right = v["right"];
+		const noise = v["noise"];
+		const gap = v["gap"];
+		const cw = 80 + gap;
+		const ch = 36 + gap;
+		const ids = [
+			...Array.from({ length: left }, (_, i) => `a${i}`),
+			...Array.from({ length: right }, (_, j) => `b${j}`),
+			...Array.from({ length: noise }, (_, k) => `n${k}`)
+		];
+		if (dims["layout"] === "mixed") {
+			const cols = ceilSqrt(ids.length + Math.floor(ids.length / 4));
+			const cells = choose(random, cols * cols, ids.length);
+			const order = shuffle(random, ids.length);
+			ids.forEach((id, i) => {
+				const c = cells[order[i]];
+				b.node(id, c % cols * cw, Math.floor(c / cols) * ch, 80, 36);
+			});
+		} else {
+			const cols = Math.max(left, right, ceilSqrt(noise));
+			for (let i = 0; i < left; i++) b.node(`a${i}`, (i + Math.floor((cols - left) / 2)) * cw, 0, 80, 36);
+			for (let j = 0; j < right; j++) b.node(`b${j}`, (j + Math.floor((cols - right) / 2)) * cw, 3 * ch, 80, 36);
+			choose(random, cols * Math.max(1, Math.floor((noise + Math.floor(noise / 4) + cols - 1) / cols)), noise).forEach((c, k) => b.node(`n${k}`, c % cols * cw, (5 + Math.floor(c / cols)) * ch, 80, 36));
+		}
+		for (let i = 0; i < left; i++) for (let j = 0; j < right; j++) b.link({ node: `a${i}` }, { node: `b${j}` });
+		for (let n = 0; n < v["extra"]; n++) b.link({ node: ids[int(random, 0, ids.length - 1)] }, { node: ids[int(random, 0, ids.length - 1)] });
+		return b.graph();
+	}
+});
+/** The 9 families of CORPUS-FAMILIES, in the order of `screen-v3`. */
+const COVERAGE_FAMILIES = Object.freeze([
+	FRAME_ROWS,
+	PIPELINE,
+	FAN_OUT,
+	TWO_HUBS,
+	UNEVEN_SIZES,
+	THIN_BARS,
+	SPARSE_LONG,
+	LOCAL_MESH,
+	BIPARTITE
+]);
 // src/families/fixtures.ts
 /** The values of the dimension `layout`: each `FixtureKind`. */
 const FIXTURE_LAYOUTS = Object.freeze([
@@ -29885,6 +32369,7 @@ const DENSE_GROUPS = fixtureFamily("dense-groups", "Dense clusters whose groups
 // src/families/index.ts
 /**
 * The corpus families of highways, in the order of the screen sets. Each family at its defaults makes the board of its screen family.
+* The first 6 families are the families of `screen-v1` and `screen-v2`. The 9 families of `COVERAGE_FAMILIES` follow them (CORPUS-FAMILIES).
 * An import registers nothing. A host makes a registry with `createFamilyRegistry(HIGHWAYS_FAMILIES)`, or with the lists of other engines too.
 */
 const HIGHWAYS_FAMILIES = Object.freeze([
@@ -29893,7 +32378,8 @@ const HIGHWAYS_FAMILIES = Object.freeze([
 	DENSE_GROUPS,
 	HUB_CHAIN,
 	MANY_GROUPS,
-	PACKED_GRID
+	PACKED_GRID,
+	...COVERAGE_FAMILIES
 ]);
 /** This function gives a new registry of `HIGHWAYS_FAMILIES`. */
 function highwaysRegistry() {
@@ -30159,13 +32645,130 @@ const SCREEN_V2 = {
 	} },
 	heldOut: SCREEN_V2_HELD_OUT
 };
+/** This function gives the 9 families of CORPUS-FAMILIES, each with `seeds` members. Their base seeds are the primes from 13 to 43. */
+function coverageFamilies(seeds) {
+	return [
+		registryFamily("frame-rows", 13, "Cards with full-width rows and fixed plugs on their walls.", seeds, {
+			...BASE,
+			count: "100",
+			edgeDensity: "sparse",
+			edgeShape: "random",
+			groups: "nested",
+			ports: "fixed"
+		}),
+		registryFamily("pipeline", 17, "A long chain of stages in rows that turn.", seeds, {
+			...BASE,
+			count: "100",
+			edgeDensity: "sparse",
+			edgeShape: "tree",
+			ports: "free"
+		}),
+		registryFamily("fan-out", 19, "A wide fan-out from one hub to the rings around it.", seeds, {
+			...BASE,
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "bundled",
+			ports: "free"
+		}),
+		registryFamily("two-hubs", 23, "Two hubs with many shared targets.", seeds, {
+			...BASE,
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "bundled",
+			ports: "free"
+		}),
+		registryFamily("uneven-sizes", 29, "A few large boxes among many small boxes.", seeds, {
+			...BASE,
+			sizes: "bimodal",
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "random",
+			ports: "free"
+		}),
+		registryFamily("thin-bars", 31, "Long thin bars in lanes, as a timeline.", seeds, {
+			...BASE,
+			sizes: "extremeAspect",
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "random",
+			ports: "free"
+		}),
+		registryFamily("sparse-long", 37, "Few nodes far apart, with long edges.", seeds, {
+			...BASE,
+			count: "10",
+			edgeDensity: "sparse",
+			edgeShape: "longRange",
+			ports: "free"
+		}),
+		registryFamily("local-mesh", 41, "Many short edges between nodes next to each other.", seeds, {
+			...BASE,
+			count: "100",
+			edgeDensity: "dense",
+			edgeShape: "clustered",
+			ports: "free"
+		}),
+		registryFamily("bipartite", 43, "A complete bipartite part: crossings that no plan removes.", seeds, {
+			...BASE,
+			count: "10",
+			edgeDensity: "dense",
+			edgeShape: "random",
+			ports: "free"
+		})
+	];
+}
+/** The member seeds of each family of `screen-v3` that the split `default` holds out. */
+const SCREEN_V3_HELD_OUT = [
+	7,
+	8,
+	9
+];
+const V3_FAMILIES = [...screenFamilies(10, 10), ...coverageFamilies(10)];
+/**
+* The screen set `screen-v3` (CORPUS-FAMILIES): the 15 families of `HIGHWAYS_FAMILIES`, each with the 10 members 0 to 9, thus 150 boards.
+* The first 6 families are the families of `screen-v2` with their seeds. Thus their boards are the boards of `screen-v2`, under the ids of `screen-v3`.
+* The 9 new families cover frames with rows, a long chain, a wide fan-out and two hubs.
+* They also cover uneven sizes, thin bars, long edges, short edges and a complete bipartite part.
+*
+* The manifest declares 10 inputs for each family. The split `default` holds out the members 7 to 9 of each family.
+* This set does not change. A new family goes into a new set. The tests compare it with the files in `corpus/screen-v3`.
+*/
+const SCREEN_V3 = {
+	id: "screen-v3",
+	families: V3_FAMILIES,
+	claims: { declared: {
+		minCount: 10,
+		thin: [],
+		counts: Object.fromEntries(V3_FAMILIES.map((f) => [f.name, f.seeds])),
+		familyBy: SCREEN_FAMILY_BY,
+		familyMin: 10
+	} },
+	heldOut: SCREEN_V3_HELD_OUT
+};
+/**
+* This function gives the power of the sign test over `families` families at the level `level`.
+* The power is the least count of families on one side that passes.
+* A family set without ties and with that count or more on one side passes the two-sided exact sign test, with the p below `level`.
+* The function gives `undefined` when no count passes, for example for 5 families or fewer at the level 0.05.
+*/
+function signTestPower(families, level = .05) {
+	for (let k = Math.ceil(families / 2); k <= families; k++) {
+		let tail = 0;
+		let c = 1;
+		for (let i = 0; i <= families - k; i++) {
+			tail += c;
+			c = c * (families - i) / (i + 1);
+		}
+		if (Math.min(1, 2 * tail / 2 ** families) < level) return k;
+	}
+}
 /**
-* The screen sets by id. `screen-v1` and its larger version `screen-v2` (CORPUS-SEEDS) have the boards of the screen.
+* The screen sets by id. `screen-v1`, its larger version `screen-v2` (CORPUS-SEEDS) and `screen-v3` with 15 families (CORPUS-FAMILIES) have the boards of the screen.
 * `exact-v1` has small boards with a known optimum (MEAS2). `exact-v1-bounds` has larger boards with bounds (EXACT-BOUNDS).
 */
 const SCREEN_SETS = {
 	[SCREEN_V1.id]: SCREEN_V1,
 	[SCREEN_V2.id]: SCREEN_V2,
+	[SCREEN_V3.id]: SCREEN_V3,
 	[EXACT_V1.id]: EXACT_V1,
 	[EXACT_V1_BOUNDS.id]: EXACT_V1_BOUNDS
 };
@@ -30979,7 +33582,9 @@ const MOVE_NAMES = Object.freeze({
 	gaps: "gap",
 	streets: "street",
 	search: "searched",
-	interchanges: "networkRoad"
+	interchanges: "networkRoad",
+	knee: "tree",
+	bronchial: "tree"
 });
 /**
 * The highway strategies that change the plan of another strategy (`from`). Their own move is a change of that plan, so they count no move.
@@ -33194,6 +35799,6 @@ const sharedStretchStrategy = defineStrategy({
 		name: "shared-stretch"
 	}).route(graph)
 });
-export { AMBIGUITY_GUARD_DEFAULTS, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BUILT_IN_STRATEGIES, BoundaryWalk, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, arcCurve, areaPlan, asRouter, attractionRouter, attractionStrategy, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, firstLines, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, makeFixture, makeRoom, manifestHash, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, silhouette, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, spreadEnds, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
+export { AMBIGUITY_GUARD_DEFAULTS, ANNEALING_DEFAULTS, ANNEALING_SCHEMA, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BIPARTITE, BIPARTITE_LAYOUTS, BOARD_PORTFOLIO_DEFAULTS, BOARD_PORTFOLIO_SETTINGS, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, BUILT_IN_STRATEGIES, BoundaryWalk, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, COVERAGE_FAMILIES, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FAN_OUT, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRAME_ROWS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, GUTTER_BEND_COST, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, KNEE_DEFAULTS, KNEE_RULES, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, LOCAL_MESH, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PIPELINE, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_V3, SCREEN_V3_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPARSE_LONG, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, THIN_BARS, TIGHT_DEFAULTS, TIGHT_FIRSTS, TIGHT_SCHEMA, TIGHT_TIES, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, TWO_HUBS, UNEVEN_SIZES, VENATION_BACKBONES, VENATION_DEFAULTS, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, annealWays, annealingRouter, annealingStrategy, arcCurve, areaPlan, aroundBox, asRouter, attractionRouter, attractionStrategy, backboneLinks, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardPortfolio, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, bronchialPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diamondAngle, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, firstLines, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, gutterRoutes, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, kneeOf, kneePlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, makeFixture, makeRoom, manifestHash, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rankShares, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, signTestPower, silhouette, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, splitTargets, spreadEnds, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, tightRouter, tightStrategy, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, venationLevels, venationLinks, waySlacks, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
 
 //# sourceMappingURL=index.js.map