@mark1russell7/highways 0.1.3 → 0.1.5

package/build/index.js

@@ -702,6 +702,32 @@ function manyGroupsBoard() {
 	for (let n = 0; n < groups.length * 3; n++) b.link(pick(groups[Math.floor(R() * groups.length)]), pick(groups[Math.floor(R() * groups.length)]));
 	return b.graph();
 }
+/**
+* This function makes the far view of a board after a host layout packs it.
+* The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+* The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+* The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+*
+* The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+*/
+function packedGridBoard() {
+	const R = rng(11);
+	const b = new Board();
+	const cols = 12;
+	const rows = 8;
+	const w = 140;
+	const h = 90;
+	const id = (r, c) => `p${r}-${c}`;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * w, r * h, w, h);
+	const step = () => Math.floor(R() * 5) - 2;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const rr = Math.max(0, Math.min(7, r + step()));
+		const cc = Math.max(0, Math.min(11, c + step()));
+		b.link(id(r, c), id(rr, cc));
+	}
+	for (let n = 0; n < 48; n++) b.link(id(Math.floor(R() * rows), Math.floor(R() * cols)), id(Math.floor(R() * rows), Math.floor(R() * cols)));
+	return b.graph();
+}
 /** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
 const CASES = [
 	{
@@ -888,6 +914,582 @@ function roundCorners(p, radius, steps = 4) {
 	out.push(p[p.length - 1]);
 	return out;
 }
+// src/curves/model.ts
+/** The curve types, in the order of the benchmark. */
+const CURVE_TYPES = [
+	"straight",
+	"rounded",
+	"spline",
+	"arc"
+];
+/** This function gives the points of a polyline without the points that are nearer than `eps` to the point before them. */
+function distinctPoints(points, eps = 1e-9) {
+	const out = [];
+	for (const p of points) {
+		const q = out[out.length - 1];
+		if (q === void 0 || Math.hypot(p.x - q.x, p.y - q.y) > eps) out.push(p);
+	}
+	return out;
+}
+// src/bench/properties.ts
+/** The tolerance of the hard rules, in units of the plane. */
+const TOLERANCE = .5;
+/**
+* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
+* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
+* Each link of a level starts on the box of its source and ends on the box of its target.
+*
+* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
+* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
+* The function gives at most `limit` violations.
+*/
+function checkProperties(graph, result, limit = 100) {
+	const out = [];
+	const add = (v) => {
+		out.push(v);
+		return out.length >= limit;
+	};
+	const byId = nodeIndex(graph);
+	const grid = new Grid(180);
+	for (const n of graph.nodes) grid.add(n, n.box);
+	const routes = /* @__PURE__ */ new Map();
+	for (const r of result.routes) routes.set(r.edge, r);
+	for (const e of graph.edges) {
+		const r = routes.get(e.id);
+		const s = byId.get(e.source.node);
+		const t = byId.get(e.target.node);
+		if (!s || !t) continue;
+		if (!r || r.points.length < 2) {
+			if (add({
+				rule: "complete",
+				edge: e.id,
+				detail: "no route"
+			})) return out;
+			continue;
+		}
+		const a = r.points[0];
+		const b = r.points[r.points.length - 1];
+		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
+			if (add({
+				rule: "ends-at-plugs",
+				edge: e.id,
+				detail: "an end of the route is away from its node"
+			})) return out;
+		}
+		const fs = fixedPortPoint(s, e.source);
+		const ft = fixedPortPoint(t, e.target);
+		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
+			if (add({
+				rule: "fixed-plugs",
+				edge: e.id,
+				detail: "the route does not start or end at its fixed plug"
+			})) return out;
+		}
+		for (let i = 1; i < r.points.length; i++) {
+			const p = r.points[i - 1];
+			const q = r.points[i];
+			let hit;
+			grid.querySegment(p, q, 0, (n) => {
+				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
+			});
+			if (hit) {
+				if (add({
+					rule: "no-pass-through",
+					edge: e.id,
+					detail: `segment ${i} goes through ${hit.id}`
+				})) return out;
+				break;
+			}
+		}
+	}
+	const bundled = /* @__PURE__ */ new Set();
+	for (const b of result.bundles ?? []) for (const id of b.edges) {
+		const r = routes.get(id);
+		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
+		if (bundled.has(id) || !shares) {
+			if (add({
+				rule: "bundle-trunk",
+				edge: id,
+				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
+			})) return out;
+		}
+		bundled.add(id);
+	}
+	for (const run of result.runs ?? []) {
+		if (run.edges.length < 2) {
+			if (add({
+				rule: "run-shared",
+				detail: `run ${run.id} has fewer than two edges`
+			})) return out;
+		}
+		for (const id of run.edges) {
+			const r = routes.get(id);
+			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
+				if (add({
+					rule: "run-shared",
+					edge: id,
+					detail: `run ${run.id}: the route does not hold the points of the run in a row`
+				})) return out;
+			}
+		}
+	}
+	for (const level of result.levels ?? []) {
+		const itemOf = /* @__PURE__ */ new Map();
+		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
+		if (itemOf.size !== graph.nodes.length) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
+			})) return out;
+		}
+		let between = 0;
+		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
+		const sum = level.links.reduce((s, l) => s + l.count, 0);
+		if (sum !== between) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
+			})) return out;
+		}
+		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
+		for (const l of level.links) {
+			const s = boxOf.get(l.source);
+			const t = boxOf.get(l.target);
+			const p = l.points;
+			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
+				if (add({
+					rule: "link-ends",
+					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
+				})) return out;
+			}
+		}
+	}
+	return out;
+}
+/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
+function onBoundary(p, b) {
+	const inner = inflate(b, -.5);
+	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+}
+/** This function tells if the polyline `p` holds the points of `part` in a row. */
+function holds(p, part) {
+	if (part.length === 0) return true;
+	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
+	return false;
+}
+// src/curves/sample.ts
+/** The largest number of points that `sampleCurve` gives for one segment. */
+const MAX_STEPS = 1024;
+/**
+* This function gives a polyline that follows the curve. The distance from each part of the curve to the polyline is `tolerance` or less.
+* The polyline starts at the point of the `move` and goes through the end of each segment.
+* Hit tests, measures and renderers that draw only lines use this polyline.
+*/
+function sampleCurve(segments, tolerance = .5) {
+	const tol = Math.max(1e-6, tolerance);
+	const out = [];
+	let at;
+	for (const s of segments) {
+		if (s.kind === "move" || at === void 0) {
+			out.push(s.to);
+			at = s.to;
+			continue;
+		}
+		if (s.kind === "cubic") {
+			const d = Math.max(Math.hypot(at.x - 2 * s.c1.x + s.c2.x, at.y - 2 * s.c1.y + s.c2.y), Math.hypot(s.c1.x - 2 * s.c2.x + s.to.x, s.c1.y - 2 * s.c2.y + s.to.y));
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.sqrt(3 * d / (4 * tol)))));
+			for (let k = 1; k < n; k++) out.push(cubicAt(at, s.c1, s.c2, s.to, k / n));
+		} else if (s.kind === "arc") {
+			const step = s.radius <= tol ? Math.PI : 2 * Math.acos(1 - tol / s.radius);
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.abs(s.sweep) / step)));
+			for (let k = 1; k < n; k++) {
+				const a = s.start + s.sweep * k / n;
+				out.push({
+					x: s.center.x + s.radius * Math.cos(a),
+					y: s.center.y + s.radius * Math.sin(a)
+				});
+			}
+		}
+		out.push(s.to);
+		at = s.to;
+	}
+	return out;
+}
+/** This function gives the point at the parameter `t` of the cubic Bezier curve with the control points `p0`, `p1`, `p2` and `p3`. */
+function cubicAt(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	const a = u * u * u;
+	const b = 3 * u * u * t;
+	const c = 3 * u * t * t;
+	const d = t * t * t;
+	return {
+		x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+		y: a * p0.y + b * p1.y + c * p2.y + d * p3.y
+	};
+}
+/**
+* This function writes the segments as the data of an SVG path: the commands `M`, `L`, `C` and `A`.
+* Each number has at most `digits` digits after the point.
+*/
+function toSvgPath(segments, digits = 2) {
+	const n = (v) => {
+		const s = String(Number(v.toFixed(digits)));
+		return s === "-0" ? "0" : s;
+	};
+	const p = (q) => `${n(q.x)} ${n(q.y)}`;
+	const parts = [];
+	for (const s of segments) if (s.kind === "move") parts.push(`M ${p(s.to)}`);
+	else if (s.kind === "line") parts.push(`L ${p(s.to)}`);
+	else if (s.kind === "cubic") parts.push(`C ${p(s.c1)} ${p(s.c2)} ${p(s.to)}`);
+	else parts.push(`A ${n(s.radius)} ${n(s.radius)} 0 ${Math.abs(s.sweep) > Math.PI ? 1 : 0} ${s.sweep > 0 ? 1 : 0} ${p(s.to)}`);
+	return parts.join(" ");
+}
+// src/curves/space.ts
+/**
+* This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
+* The curves sample each piece within `tolerance` of the curve for the test.
+*/
+function curveSpace(boxes, tolerance = .25) {
+	const inner = boxes.map((b) => inflate(b, -.5));
+	let size = 0;
+	for (const b of boxes) size += Math.max(b.w, b.h);
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.length)));
+	inner.forEach((b, i) => grid.add(i, b));
+	const hits = (p) => {
+		const out = /* @__PURE__ */ new Set();
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			grid.querySegment(a, b, 0, (id) => {
+				if (!out.has(id) && segmentHitsBox(a, b, inner[id], .5)) out.add(id);
+			});
+		}
+		return out;
+	};
+	return {
+		boxes,
+		tolerance,
+		addsHit(q, p) {
+			let before;
+			for (let i = 1; i < q.length; i++) {
+				const a = q[i - 1];
+				const b = q[i];
+				if (grid.someSegment(a, b, 0, (id) => {
+					if (!segmentHitsBox(a, b, inner[id], .5)) return false;
+					before ??= hits(p);
+					return !before.has(id);
+				})) return true;
+			}
+			return false;
+		}
+	};
+}
+/**
+* This function finds the largest size from `max` down to 0 that keeps a piece of a curve clear.
+* A clear piece goes through no box that its polyline avoids.
+*
+* The function `piece` gives the segments of the piece at a size. They start with a `move`.
+* The polyline `chord` is the part of the original polyline that the piece replaces.
+* The function tries `max` first, then it halves the interval `steps` times. The result is 0 when no size of the search is clear.
+*/
+function fitSize(space, max, chord, piece, steps = 8) {
+	if (space === void 0 || max <= 0) return Math.max(0, max);
+	const clear = (size) => !space.addsHit(sampleCurve(piece(size), space.tolerance), chord(size));
+	if (clear(max)) return max;
+	let lo = 0;
+	let hi = max;
+	for (let i = 0; i < steps; i++) {
+		const mid = (lo + hi) / 2;
+		if (clear(mid)) lo = mid;
+		else hi = mid;
+	}
+	return lo;
+}
+// src/curves/arc/index.ts
+/** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle stays sharp. */
+const FLAT = 1e-6;
+/**
+* This function puts a circular arc at each inner vertex of a polyline. The arc is tangent to the two legs of its corner.
+* The tangent points stay on the first half of each leg, so the ends of the polyline stay.
+* With `space`, the function makes the radius of a corner smaller until the arc goes through no box that the polyline avoids.
+* On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
+*/
+function arcCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ux = (v.x - a.x) / la;
+		const uy = (v.y - a.y) / la;
+		const wx = (b.x - v.x) / lb;
+		const wy = (b.y - v.y) / lb;
+		const turn = Math.atan2(ux * wy - uy * wx, ux * wx + uy * wy);
+		if (Math.abs(turn) < FLAT || Math.PI - Math.abs(turn) < FLAT) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const k = Math.tan(Math.abs(turn) / 2);
+		const side = Math.sign(turn);
+		const ends = (r) => [{
+			x: v.x - ux * r * k,
+			y: v.y - uy * r * k
+		}, {
+			x: v.x + wx * r * k,
+			y: v.y + wy * r * k
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			const center = {
+				x: p1.x - side * uy * r,
+				y: p1.y + side * ux * r
+			};
+			return [{
+				kind: "arc",
+				center,
+				radius: r,
+				start: Math.atan2(p1.y - center.y, p1.x - center.x),
+				sweep: turn,
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, Math.min(la, lb) / (2 * k)), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, out[out.length - 1].to) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+// src/curves/rounded/index.ts
+/**
+* This function rounds each inner vertex of a polyline with a quadratic Bezier curve, as `roundCorners` does.
+* The curve of a corner starts and ends at most `radius` from the vertex, and at most half of each leg. The ends of the polyline stay.
+* The function gives each quadratic curve as the same cubic curve. With `space`, it makes the radius of a corner smaller until the curve
+* goes through no box that the polyline avoids.
+*/
+function roundedCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ends = (r) => [{
+			x: v.x + (a.x - v.x) * r / la,
+			y: v.y + (a.y - v.y) * r / la
+		}, {
+			x: v.x + (b.x - v.x) * r / lb,
+			y: v.y + (b.y - v.y) * r / lb
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			return [{
+				kind: "cubic",
+				c1: {
+					x: p1.x + 2 * (v.x - p1.x) / 3,
+					y: p1.y + 2 * (v.y - p1.y) / 3
+				},
+				c2: {
+					x: p2.x + 2 * (v.x - p2.x) / 3,
+					y: p2.y + 2 * (v.y - p2.y) / 3
+				},
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, la / 2, lb / 2), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, at(out)) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+/** This function gives the end of the last segment. */
+function at(segments) {
+	return segments[segments.length - 1].to;
+}
+// src/curves/spline/index.ts
+/**
+* This function draws a centripetal Catmull-Rom spline through the points of a polyline (Yuksel, Schaefer and Keyser, 2011).
+* Each piece between two points is one cubic Bezier curve. The centripetal knots keep the curve free of cusps and loops in a piece.
+* The curve goes through each point. Its tangent at a point keeps one direction on the two sides of the point.
+*
+* With `space`, the function makes the tangents of a piece shorter until the piece goes through no box that its leg avoids.
+* A piece with no tangent is the straight leg.
+*/
+function splineCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	const n = p.length;
+	if (n === 1) return out;
+	const scale = 1 - Math.max(0, Math.min(1, options.tension ?? 0));
+	const dt = Array.from({ length: n - 1 }, (_, i) => Math.sqrt(dist(p[i], p[i + 1])));
+	const unit = (q) => {
+		const l = Math.hypot(q.x, q.y);
+		return l === 0 ? {
+			x: 0,
+			y: 0
+		} : {
+			x: q.x / l,
+			y: q.y / l
+		};
+	};
+	const m = p.map((v, i) => {
+		if (i === 0) {
+			const leg = {
+				x: p[1].x - v.x,
+				y: p[1].y - v.y
+			};
+			if (!options.startNormal) return {
+				x: leg.x / dt[0],
+				y: leg.y / dt[0]
+			};
+			const u = unit(options.startNormal);
+			return {
+				x: u.x * dt[0],
+				y: u.y * dt[0]
+			};
+		}
+		if (i === n - 1) {
+			const a = p[i - 1];
+			const leg = {
+				x: v.x - a.x,
+				y: v.y - a.y
+			};
+			if (!options.endNormal) return {
+				x: leg.x / dt[i - 1],
+				y: leg.y / dt[i - 1]
+			};
+			const u = unit(options.endNormal);
+			return {
+				x: -u.x * dt[i - 1],
+				y: -u.y * dt[i - 1]
+			};
+		}
+		const a = p[i - 1];
+		const b = p[i + 1];
+		const t0 = dt[i - 1];
+		const t1 = dt[i];
+		return {
+			x: (v.x - a.x) / t0 - (b.x - a.x) / (t0 + t1) + (b.x - v.x) / t1,
+			y: (v.y - a.y) / t0 - (b.y - a.y) / (t0 + t1) + (b.y - v.y) / t1
+		};
+	});
+	for (let i = 0; i + 1 < n; i++) {
+		const a = p[i];
+		const b = p[i + 1];
+		const h = dt[i] / 3;
+		const piece = (s) => [{
+			kind: "move",
+			to: a
+		}, {
+			kind: "cubic",
+			c1: {
+				x: a.x + m[i].x * h * s,
+				y: a.y + m[i].y * h * s
+			},
+			c2: {
+				x: b.x - m[i + 1].x * h * s,
+				y: b.y - m[i + 1].y * h * s
+			},
+			to: b
+		}];
+		const s = fitSize(options.space, scale, () => [a, b], piece);
+		out.push(s > 0 ? piece(s)[1] : {
+			kind: "line",
+			to: b
+		});
+	}
+	return out;
+}
+// src/curves/straight/index.ts
+/** This function gives the polyline as it is: one `move` to the first point and one `line` to each other point. */
+function straightCurve(points) {
+	return points.map((to, i) => i === 0 ? {
+		kind: "move",
+		to
+	} : {
+		kind: "line",
+		to
+	});
+}
+// src/curves/index.ts
+/**
+* This function gives the curve of a route: a polyline of a router, a lane of `laneRoutes` or a link of a zoom level.
+* The curve starts at the first point and ends at the last point of the polyline.
+* The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+*/
+function curveOf(points, options) {
+	switch (options.type) {
+		case "straight": return straightCurve(points);
+		case "rounded": return roundedCurve(points, options);
+		case "spline": return splineCurve(points, options);
+		case "arc": return arcCurve(points, options);
+	}
+}
 // src/visibility.ts
 /** The nodes as obstacles, with a grid for fast tests. */
 var Obstacles = class {
@@ -908,7 +1510,7 @@ var Obstacles = class {
 	hit(a, b, pad, skip) {
 		let found;
 		this.#grid.someSegment(a, b, pad, (n) => {
-			if (skip?.has(n) || !hits(a, b, n, pad)) return false;
+			if (skip?.has(n) || !hits$1(a, b, n, pad)) return false;
 			found = n;
 			return true;
 		});
@@ -941,7 +1543,7 @@ var Obstacles = class {
 	}
 };
 /** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
-function hits(a, b, n, pad) {
+function hits$1(a, b, n, pad) {
 	const x = n.box;
 	return segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad);
 }
@@ -1022,7 +1624,7 @@ var CornerGraph = class {
 			}
 		}
 		const links = this.points.map(() => /* @__PURE__ */ new Set());
-		for (let i = 0; i < this.points.length; i++) for (const j of this.nearestVisible(this.points[i], this.#k, i)) {
+		for (let i = 0; i < this.points.length; i++) for (const j of this.#nearestVisible(this.points[i], this.#k, i, this.#pad, options.cones ?? false)) {
 			links[i].add(j);
 			links[j].add(i);
 		}
@@ -1082,13 +1684,16 @@ var CornerGraph = class {
 	* within `r` that an earlier ring did not test, nearest first, and equal distances by index.
 	* The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
 	* A corner of these buckets beyond `r` waits for the next ring. So the method visits each bucket one time.
+	* With `cones`, the method also gives the nearest visible corner of each of four cones around the axes that the `k` nearest corners leave empty.
 	*/
-	#nearestVisible(p, k, self, pad) {
+	#nearestVisible(p, k, self, pad, cones = false) {
 		const out = [];
+		let full = 0;
 		if (this.#dist.length < this.points.length) this.#dist = new Float64Array(this.points.length);
 		const dd = this.#dist;
 		const points = this.points;
 		const cell = this.#cell;
+		const reach = CONE_CELLS * cell;
 		const blockers = [];
 		const now = this.#near;
 		let wait = [];
@@ -1097,6 +1702,7 @@ var CornerGraph = class {
 		let pj0 = 1;
 		let pj1 = 0;
 		for (let r = cell; r <= cell * 8; r *= 2) {
+			if (out.length >= k && r / 2 >= reach) return out;
 			const x0 = p.x - r;
 			const y0 = p.y - r;
 			const i0 = Math.floor(x0 / cell);
@@ -1126,14 +1732,20 @@ var CornerGraph = class {
 			while (now.size > 0) {
 				const j = now.pop();
 				const q = points[j];
+				const cone = cones ? coneOf(q.x - p.x, q.y - p.y) : 0;
+				if (out.length >= k) {
+					if (dd[j] > reach) return out;
+					if ((full & cone) !== 0) continue;
+				}
 				let blocked = false;
-				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
+				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits$1(p, q, blockers[b], pad);
 				if (blocked) continue;
 				const hit = this.#obstacles.hit(p, q, pad);
 				if (hit !== void 0) blockers.push(hit);
 				else {
 					out.push(j);
-					if (out.length >= k) return out;
+					full |= cone;
+					if (out.length >= k && (!cones || full === 15)) return out;
 				}
 			}
 			wait = later;
@@ -1321,6 +1933,10 @@ var CornerGraph = class {
 		return out;
 	}
 };
+/** A link of a cone is at most this number of cells long. A longer search costs time on a dense level and finds few new links. */
+const CONE_CELLS = 3;
+/** This function gives the bit of the cone of the offset (`dx`, `dy`): 1 is +x, 2 is +y, 4 is -x and 8 is -y. A diagonal offset is in a cone of the x axis. */
+const coneOf = (dx, dy) => Math.abs(dx) >= Math.abs(dy) ? dx > 0 ? 1 : 4 : dy > 0 ? 2 : 8;
 /** This function packs the two indices of a bucket into one number. Each index stays within ±2^20. */
 const bucketKey = (i, j) => (i + 1048576) * 2097152 + (j + 1048576);
 /**
@@ -1836,181 +2452,35 @@ function cornersRouter(options) {
 			return { routes };
 		}
 	};
-	return options.maxNodes === void 0 ? router : {
-		...router,
-		maxNodes: options.maxNodes
-	};
-}
-// src/routers/plugs.ts
-/**
-* Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
-* It goes to the target plug on the curve of the rule. This router measures the rule alone.
-*/
-const plugsRouter = {
-	name: "plugs",
-	route(graph) {
-		const byId = nodeIndex(graph);
-		const routes = [];
-		for (const e of graph.edges) {
-			const s = byId.get(e.source.node);
-			const t = byId.get(e.target.node);
-			if (!s || !t) continue;
-			const ps = placePlug(s, e.source, center(t.box));
-			const pt = placePlug(t, e.target, center(s.box));
-			routes.push({
-				edge: e.id,
-				points: inflectionCurve(ps.point, ps.normal, pt.point)
-			});
-		}
-		return { routes };
-	}
-};
-// src/bench/properties.ts
-/** The tolerance of the hard rules, in units of the plane. */
-const TOLERANCE = .5;
-/**
-* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
-* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
-* Each link of a level starts on the box of its source and ends on the box of its target.
-*
-* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
-* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
-* The function gives at most `limit` violations.
-*/
-function checkProperties(graph, result, limit = 100) {
-	const out = [];
-	const add = (v) => {
-		out.push(v);
-		return out.length >= limit;
-	};
-	const byId = nodeIndex(graph);
-	const grid = new Grid(180);
-	for (const n of graph.nodes) grid.add(n, n.box);
-	const routes = /* @__PURE__ */ new Map();
-	for (const r of result.routes) routes.set(r.edge, r);
-	for (const e of graph.edges) {
-		const r = routes.get(e.id);
-		const s = byId.get(e.source.node);
-		const t = byId.get(e.target.node);
-		if (!s || !t) continue;
-		if (!r || r.points.length < 2) {
-			if (add({
-				rule: "complete",
-				edge: e.id,
-				detail: "no route"
-			})) return out;
-			continue;
-		}
-		const a = r.points[0];
-		const b = r.points[r.points.length - 1];
-		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
-			if (add({
-				rule: "ends-at-plugs",
-				edge: e.id,
-				detail: "an end of the route is away from its node"
-			})) return out;
-		}
-		const fs = fixedPortPoint(s, e.source);
-		const ft = fixedPortPoint(t, e.target);
-		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
-			if (add({
-				rule: "fixed-plugs",
-				edge: e.id,
-				detail: "the route does not start or end at its fixed plug"
-			})) return out;
-		}
-		for (let i = 1; i < r.points.length; i++) {
-			const p = r.points[i - 1];
-			const q = r.points[i];
-			let hit;
-			grid.querySegment(p, q, 0, (n) => {
-				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
-			});
-			if (hit) {
-				if (add({
-					rule: "no-pass-through",
-					edge: e.id,
-					detail: `segment ${i} goes through ${hit.id}`
-				})) return out;
-				break;
-			}
-		}
-	}
-	const bundled = /* @__PURE__ */ new Set();
-	for (const b of result.bundles ?? []) for (const id of b.edges) {
-		const r = routes.get(id);
-		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
-		if (bundled.has(id) || !shares) {
-			if (add({
-				rule: "bundle-trunk",
-				edge: id,
-				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
-			})) return out;
-		}
-		bundled.add(id);
-	}
-	for (const run of result.runs ?? []) {
-		if (run.edges.length < 2) {
-			if (add({
-				rule: "run-shared",
-				detail: `run ${run.id} has fewer than two edges`
-			})) return out;
-		}
-		for (const id of run.edges) {
-			const r = routes.get(id);
-			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
-				if (add({
-					rule: "run-shared",
-					edge: id,
-					detail: `run ${run.id}: the route does not hold the points of the run in a row`
-				})) return out;
-			}
-		}
-	}
-	for (const level of result.levels ?? []) {
-		const itemOf = /* @__PURE__ */ new Map();
-		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
-		if (itemOf.size !== graph.nodes.length) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
-			})) return out;
-		}
-		let between = 0;
-		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
-		const sum = level.links.reduce((s, l) => s + l.count, 0);
-		if (sum !== between) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
-			})) return out;
-		}
-		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
-		for (const l of level.links) {
-			const s = boxOf.get(l.source);
-			const t = boxOf.get(l.target);
-			const p = l.points;
-			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
-				if (add({
-					rule: "link-ends",
-					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
-				})) return out;
-			}
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
+}
+// src/routers/plugs.ts
+/**
+* Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
+* It goes to the target plug on the curve of the rule. This router measures the rule alone.
+*/
+const plugsRouter = {
+	name: "plugs",
+	route(graph) {
+		const byId = nodeIndex(graph);
+		const routes = [];
+		for (const e of graph.edges) {
+			const s = byId.get(e.source.node);
+			const t = byId.get(e.target.node);
+			if (!s || !t) continue;
+			const ps = placePlug(s, e.source, center(t.box));
+			const pt = placePlug(t, e.target, center(s.box));
+			routes.push({
+				edge: e.id,
+				points: inflectionCurve(ps.point, ps.normal, pt.point)
+			});
 		}
+		return { routes };
 	}
-	return out;
-}
-/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
-function onBoundary(p, b) {
-	const inner = inflate(b, -.5);
-	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
-}
-/** This function tells if the polyline `p` holds the points of `part` in a row. */
-function holds(p, part) {
-	if (part.length === 0) return true;
-	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
-	return false;
-}
+};
 // src/bench/links.ts
 /** A link goes out and back when its distance to its target grows by more than this share of the distance between its ends. */
 const BACKTRACK_SHARE = .25;
@@ -2155,7 +2625,7 @@ function sumFaults(list) {
 // src/levels.ts
 /** The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through. */
 const TIGHT_MARGIN = 1;
-const EPS = 1e-6;
+const EPS$1 = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
 * and the points where the way turns back on itself.
@@ -2163,15 +2633,15 @@ const EPS = 1e-6;
 function tidy(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		while (out.length >= 2) {
 			const a = out[out.length - 2];
 			const b = out[out.length - 1];
 			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-			if (Math.abs(cross) > EPS * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$1 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		out.push(q);
 	}
 	return out;
@@ -2224,6 +2694,7 @@ function sideWay(ways, s, t, inset) {
 /**
 * This function makes the obstacles and the corner graph of the items of a level.
 * The buckets of the obstacles grow with the items, so a long link visits few buckets.
+* The corner graphs use `cones`, so a link goes along the corridors between the groups, not around the outer edge of the board.
 */
 function levelWays(nodes, options) {
 	const margin = options.margin ?? 5;
@@ -2233,7 +2704,8 @@ function levelWays(nodes, options) {
 	const obstacles = new Obstacles(nodes, Math.max(180, 2 * size / Math.max(1, nodes.length)));
 	const corners = new CornerGraph(nodes, obstacles, {
 		margin,
-		k
+		k,
+		cones: true
 	});
 	const out = (p) => ({
 		x: p.point.x + p.normal.x * margin,
@@ -2242,7 +2714,8 @@ function levelWays(nodes, options) {
 	let tight;
 	const tightGraph = () => tight ??= new CornerGraph(nodes, obstacles, {
 		margin: Math.min(margin, TIGHT_MARGIN),
-		k
+		k,
+		cones: true
 	});
 	return {
 		obstacles,
@@ -2408,7 +2881,7 @@ function freeSpans(lo, hi, covered) {
 		if (x >= hi) break;
 	}
 	if (x < hi) out.push([x, hi]);
-	return out.filter(([a, b]) => b - a > EPS);
+	return out.filter(([a, b]) => b - a > EPS$1);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -2540,7 +3013,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 		out.push(...step.legs);
 		const end = out[out.length - 1];
 		const before = out[out.length - 2];
-		axis = Math.abs(end.y - before.y) < EPS ? "x" : Math.abs(end.x - before.x) < EPS ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$1 ? "x" : Math.abs(end.x - before.x) < EPS$1 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -2550,7 +3023,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
 */
 function square(a, b, obstacles, pad, from, to) {
-	if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$1 || Math.abs(a.y - b.y) < EPS$1) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -3227,7 +3700,7 @@ function trunksRouter(options) {
 	};
 }
 // src/routers/index.ts
-/** The routers that the benchmark races. */
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 const ROUTERS = [
 	straightRouter,
 	plugsRouter,
@@ -3264,6 +3737,439 @@ const ROUTERS = [
 		maxNodes: 1e5
 	})
 ];
+// src/room/index.ts
+const DEFAULT_GUTTER = 8;
+const DEFAULT_SPACING = 4;
+const DEFAULT_SNAP = .5;
+const lo = (b, a) => a === "x" ? b.x : b.y;
+const len = (b, a) => a === "x" ? b.w : b.h;
+const other = (a) => a === "x" ? "y" : "x";
+/**
+* This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+* Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
+*/
+function boardGaps(items, snap = DEFAULT_SNAP) {
+	return [...axisGaps(items, "x", snap), ...axisGaps(items, "y", snap)];
+}
+function axisGaps(items, axis, snap) {
+	const starts = [...new Set(items.map((i) => lo(i.box, axis)))].sort((u, v) => u - v);
+	const bounds = [];
+	for (const s of starts) if (bounds.length === 0 || s - bounds[bounds.length - 1] > snap) bounds.push(s);
+	const after = bounds.map(() => []);
+	for (const i of items) after[lastAtOrBefore(bounds, lo(i.box, axis) + snap)].push(i.id);
+	const ends = items.map((i) => ({
+		id: i.id,
+		end: lo(i.box, axis) + len(i.box, axis)
+	})).sort((u, v) => u.end - v.end);
+	const gaps = [];
+	let k = 0;
+	for (let n = 1; n < bounds.length; n++) {
+		const at = bounds[n];
+		while (k < ends.length && ends[k].end <= at + snap) k++;
+		const near = k > 0 ? ends[k - 1].end : at;
+		const before = [];
+		for (let j = k - 1; j >= 0 && ends[j].end >= near - snap; j--) before.push(ends[j].id);
+		gaps.push({
+			axis,
+			index: n - 1,
+			at,
+			before: before.reverse(),
+			after: after[n],
+			width: Math.max(0, at - near),
+			lanes: 0,
+			need: Math.max(0, at - near)
+		});
+	}
+	return gaps;
+}
+/** This function gives the index of the last value of the sorted list `v` that is at or before `x`, or 0. */
+function lastAtOrBefore(v, x) {
+	let a = 0;
+	let b = v.length - 1;
+	while (a < b) {
+		const m = a + b + 1 >> 1;
+		if (v[m] <= x) a = m;
+		else b = m - 1;
+	}
+	return a;
+}
+/**
+* This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+* A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+* The function moves no box nearer to another box, so it makes no overlap.
+*/
+function openGaps(items, gaps, snap = DEFAULT_SNAP) {
+	const shift = (axis) => {
+		const list = gaps.filter((g) => g.axis === axis).sort((u, v) => u.at - v.at);
+		const at = list.map((g) => g.at);
+		const sum = [];
+		let s = 0;
+		for (const g of list) sum.push(s += Math.max(0, g.need - g.width));
+		return (v) => list.length === 0 || at[0] > v + snap ? 0 : sum[lastAtOrBefore(at, v + snap)];
+	};
+	const sx = shift("x");
+	const sy = shift("y");
+	return items.map((i) => ({
+		...i,
+		box: {
+			...i.box,
+			x: i.box.x + sx(i.box.x),
+			y: i.box.y + sy(i.box.y)
+		}
+	}));
+}
+/**
+* This function gives the room that the links need in each gap of the board.
+* The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+*/
+function roomDemand(items, links, options = {}) {
+	const gutter = options.gutter ?? DEFAULT_GUTTER;
+	const snap = options.snap ?? DEFAULT_SNAP;
+	const passes = Math.max(1, Math.floor(options.passes ?? 1));
+	let total = demandOnce(items, links, options);
+	for (let p = 1; p < passes; p++) {
+		const next = demandOnce(openGaps(items, total, snap), links, options);
+		if (next.length !== total.length || next.some((g, i) => g.axis !== total[i].axis)) break;
+		total = total.map((g, i) => ({
+			...g,
+			lanes: Math.max(g.lanes, next[i].lanes),
+			need: g.need + Math.max(0, next[i].need - next[i].width)
+		}));
+	}
+	return capGrowth(items, total, gutter, options.maxGrowth ?? Infinity);
+}
+/** This function gives the demand of one pass, without the limit `maxGrowth`. */
+function demandOnce(items, links, options) {
+	const gutter = options.gutter ?? DEFAULT_GUTTER;
+	const spacing = options.spacing ?? DEFAULT_SPACING;
+	const snap = options.snap ?? DEFAULT_SNAP;
+	const weight = (l) => options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1;
+	const gaps = boardGaps(items, snap);
+	const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
+	return gaps.map((g, i) => ({
+		...g,
+		lanes: lanes[i],
+		need: Math.max(g.width, gutter + lanes[i] * spacing)
+	}));
+}
+/** This function gives the demand of the board and the board with each gap open to its need. */
+function makeRoom(items, links, options = {}) {
+	const gaps = roomDemand(items, links, options);
+	return {
+		gaps,
+		items: openGaps(items, gaps, options.snap ?? DEFAULT_SNAP)
+	};
+}
+/** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
+function roomLinks(graph) {
+	const byPair = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const [s, t] = [e.source.node, e.target.node];
+		if (s === t) continue;
+		const key = s < t ? `${s}\u0000${t}` : `${t}\u0000${s}`;
+		const known = byPair.get(key);
+		if (known) known.count++;
+		else byPair.set(key, {
+			source: s,
+			target: t,
+			count: 1
+		});
+	}
+	return [...byPair.values()];
+}
+/** This function counts, for each gap, the straight lines between the centers of the boxes of a link that cross the gap. */
+function lineLanes(items, links, gaps, weight) {
+	const byId = new Map(items.map((i) => [i.id, center(i.box)]));
+	return gaps.map((g) => {
+		let n = 0;
+		for (const l of links) {
+			const a = byId.get(l.source);
+			const b = byId.get(l.target);
+			if (a && b && Math.min(a[g.axis], b[g.axis]) < g.at && Math.max(a[g.axis], b[g.axis]) > g.at) n += weight(l);
+		}
+		return n;
+	});
+}
+/**
+* This function routes the links one time on the board with each gap open to the gutter.
+* The lanes of a gap are the largest number of routes that run along the gap at one place.
+* A piece of a route goes along a gap when it is in the channel of the gap.
+* It must also go farther along the gap than across it.
+*/
+function routeLanes(items, links, gaps, gutter, snap, weight, router) {
+	const probeGaps = gaps.map((g) => ({
+		...g,
+		need: Math.max(g.width, gutter)
+	}));
+	const ways = probeWays(openGaps(items, probeGaps, snap), links, gutter, router);
+	return probeGaps.map((g) => {
+		let grow = 0;
+		for (const h of probeGaps) if (h.axis === g.axis && h.at <= g.at + snap) grow += h.need - h.width;
+		const hi = g.at + grow;
+		const lo = hi - g.need;
+		const spans = [];
+		ways.forEach((points, i) => {
+			const along = alongSpans(points, g.axis, lo, hi);
+			for (const [from, to] of merge(along)) spans.push({
+				from,
+				to,
+				w: weight(links[i])
+			});
+		});
+		return density(spans);
+	});
+}
+/** This function gives the points of the way of each link on the probe board, in the order of the links. */
+function probeWays(items, links, gutter, router) {
+	if (router) {
+		const edges = links.map((l, i) => ({
+			id: `l${i}`,
+			source: { node: l.source },
+			target: { node: l.target }
+		}));
+		const routes = new Map(router.route({
+			nodes: items,
+			edges
+		}).routes.map((r) => [r.edge, r.points]));
+		return edges.map((e) => routes.get(e.id) ?? []);
+	}
+	const out = levelLinks(items.map((i) => ({
+		id: i.id,
+		box: i.box,
+		nodes: [i.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})), { margin: Math.max(1, gutter / 2) });
+	const byPair = new Map(out.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+	return links.map((l) => byPair.get(`${l.source}\u0000${l.target}`) ?? []);
+}
+/**
+* This function gives the spans along the axis of a gap where the polyline goes along the channel from `lo` to `hi`.
+* The axis `x` gap is a vertical channel, so its spans are on the y axis.
+*/
+function alongSpans(p, axis, lo, hi) {
+	const across = axis;
+	const along = other(axis);
+	const out = [];
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		const da = b[across] - a[across];
+		let t0 = 0;
+		let t1 = 1;
+		if (Math.abs(da) < 1e-9) {
+			if (a[across] < lo - 1e-6 || a[across] > hi + 1e-6) continue;
+		} else {
+			const u = (lo - a[across]) / da;
+			const v = (hi - a[across]) / da;
+			t0 = Math.max(0, Math.min(u, v));
+			t1 = Math.min(1, Math.max(u, v));
+			if (t1 <= t0) continue;
+		}
+		const s = a[along] + (b[along] - a[along]) * t0;
+		const e = a[along] + (b[along] - a[along]) * t1;
+		const run = Math.abs(e - s);
+		if (run > Math.abs(da) * (t1 - t0) && run > 1e-6) out.push([Math.min(s, e), Math.max(s, e)]);
+	}
+	return out;
+}
+/** This function joins the spans that overlap, so that one link counts one time at each place. */
+function merge(spans) {
+	spans.sort((u, v) => u[0] - v[0]);
+	const out = [];
+	for (const s of spans) {
+		const last = out[out.length - 1];
+		if (last && s[0] <= last[1]) last[1] = Math.max(last[1], s[1]);
+		else out.push([s[0], s[1]]);
+	}
+	return out;
+}
+/** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
+function density(spans) {
+	const events = [];
+	for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
+	events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
+	let n = 0;
+	let best = 0;
+	for (const [, w] of events) {
+		n += w;
+		best = Math.max(best, n);
+	}
+	return best;
+}
+/**
+* This function keeps the growth of the board on each axis at most `maxGrowth` times its size.
+* Each gap keeps its gutter. The lanes of all gaps of the axis share the rest of the growth in proportion.
+*/
+function capGrowth(items, gaps, gutter, maxGrowth) {
+	if (!Number.isFinite(maxGrowth)) return gaps;
+	const out = [...gaps];
+	for (const axis of ["x", "y"]) {
+		let x0 = Infinity;
+		let x1 = -Infinity;
+		for (const i of items) {
+			x0 = Math.min(x0, lo(i.box, axis));
+			x1 = Math.max(x1, lo(i.box, axis) + len(i.box, axis));
+		}
+		const budget = Math.max(0, maxGrowth) * Math.max(0, x1 - x0);
+		let base = 0;
+		let spare = 0;
+		for (const g of gaps) {
+			if (g.axis !== axis) continue;
+			const b = Math.max(0, gutter - g.width);
+			base += b;
+			spare += Math.max(0, g.need - g.width - b);
+		}
+		if (base + spare <= budget || spare === 0) continue;
+		const f = Math.max(0, (budget - base) / spare);
+		gaps.forEach((g, i) => {
+			if (g.axis !== axis) return;
+			const b = Math.max(0, gutter - g.width);
+			out[i] = {
+				...g,
+				need: g.width + b + f * Math.max(0, g.need - g.width - b)
+			};
+		});
+	}
+	return out;
+}
+// src/room/lanes.ts
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+const LANE_ORDERS = [
+	"links",
+	"ends",
+	"crossings"
+];
+const EPS = 1e-6;
+const ROUNDS = 8;
+/**
+* This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+* A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+* When a move puts a link through more boxes than before, the link keeps its points.
+*/
+function gapLanes(items, links, options = {}) {
+	const spacing = Math.max(0, options.spacing ?? 4);
+	const order = options.order ?? "crossings";
+	const moved = links.map((l) => l.points.map((p) => ({
+		x: p.x,
+		y: p.y
+	})));
+	for (const g of boardGaps(items, options.snap)) {
+		if (g.width <= EPS) continue;
+		const across = g.axis;
+		const along = g.axis === "x" ? "y" : "x";
+		const lo = g.at - g.width;
+		const hi = g.at;
+		const pieces = [];
+		links.forEach((l, li) => {
+			const p = l.points;
+			for (let i = 2; i <= p.length - 2; i++) {
+				const a = p[i - 1];
+				const b = p[i];
+				if (Math.abs(a[across] - b[across]) > EPS || a[across] <= lo + EPS || a[across] >= hi - EPS) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS) continue;
+				const side = (q, r) => Math.sign(r[across] - q[across]);
+				pieces.push({
+					link: li,
+					seg: i,
+					lo: Math.min(a[along], b[along]),
+					hi: Math.max(a[along], b[along]),
+					turns: [[a[along], side(a, p[i - 2])], [b[along], side(b, p[i + 1])]]
+				});
+			}
+		});
+		if (pieces.length === 0) continue;
+		const list = orderPieces(pieces, order);
+		const lane = [];
+		let n = 0;
+		list.forEach((P, i) => {
+			let k = 0;
+			for (let j = 0; j < i; j++) if (overlaps(list[j], P)) k = Math.max(k, lane[j] + 1);
+			lane.push(k);
+			n = Math.max(n, k + 1);
+		});
+		const step = Math.min(spacing, g.width / (n + 1));
+		const mid = (lo + hi) / 2;
+		list.forEach((P, i) => {
+			const v = mid + (lane[i] - (n - 1) / 2) * step;
+			moved[P.link][P.seg - 1][across] = v;
+			moved[P.link][P.seg][across] = v;
+		});
+	}
+	const boxes = new Grid(Math.max(20, meanSide(items)));
+	for (const i of items) boxes.add(i.box, i.box);
+	return links.map((l, i) => hits(boxes, moved[i]) > hits(boxes, l.points) ? l : {
+		...l,
+		points: moved[i]
+	});
+}
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;
+/**
+* This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
+* A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
+*/
+function cost(P, Q) {
+	let c = 0;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS && y < Q.hi - EPS) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS && y < P.hi - EPS) c++;
+	return c;
+}
+/** This function gives the pieces of one gap in lane order, from the near side to the far side. */
+function orderPieces(pieces, order) {
+	if (order === "links") return [...pieces];
+	const sum = (P) => P.turns.reduce((s, [, side]) => s + side, 0);
+	const list = [...pieces].sort((P, Q) => sum(P) - sum(Q) || P.link - Q.link || P.seg - Q.seg);
+	if (order === "ends") return list;
+	const n = list.length;
+	const index = new Map(list.map((P, i) => [P, i]));
+	const c = list.map((P) => list.map((Q) => P !== Q && overlaps(P, Q) ? cost(P, Q) : 0));
+	const at = (P, Q) => c[index.get(P)][index.get(Q)];
+	for (let round = 0; round < ROUNDS; round++) {
+		let better = false;
+		for (let i = 0; i < n; i++) {
+			const x = list[i];
+			let best = 0;
+			let to = i;
+			let d = 0;
+			for (let k = i - 1; k >= 0; k--) {
+				d += at(x, list[k]) - at(list[k], x);
+				if (d < best) [best, to] = [d, k];
+			}
+			d = 0;
+			for (let k = i + 1; k < n; k++) {
+				d += at(list[k], x) - at(x, list[k]);
+				if (d < best) [best, to] = [d, k];
+			}
+			if (to !== i) {
+				list.splice(i, 1);
+				list.splice(to, 0, x);
+				better = true;
+			}
+		}
+		if (!better) break;
+	}
+	return list;
+}
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items) {
+	let s = 0;
+	for (const i of items) s += Math.max(i.box.w, i.box.h);
+	return items.length ? s / items.length : 1;
+}
+/** This function counts the legs of a polyline that go through a box, for each box. */
+function hits(boxes, p) {
+	let n = 0;
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		boxes.querySegment(a, b, 0, (box) => {
+			if (segmentHitsBox(a, b, box)) n++;
+		});
+	}
+	return n;
+}
 // src/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -3449,7 +4355,7 @@ function measureStability(before, after) {
 	};
 }
 // src/bench/run.ts
-const now = () => globalThis.performance?.now() ?? Date.now();
+const now$2 = () => globalThis.performance?.now() ?? Date.now();
 /** This function routes each fixture with each router, checks the hard rules and measures the quality. */
 function runBenchmark(routers, fixtures, options = {}) {
 	const rows = [];
@@ -3488,9 +4394,9 @@ function benchOne(router, fixture, graph, repeat = 3) {
 	let first;
 	let deterministic = true;
 	for (let i = 0; i < Math.max(2, repeat); i++) {
-		const t0 = now();
+		const t0 = now$2();
 		const r = router.route(graph);
-		times.push(now() - t0);
+		times.push(now$2() - t0);
 		if (!first) first = r;
 		else if (i === 1 && !sameData(r, first)) deterministic = false;
 	}
@@ -3552,6 +4458,482 @@ function formatFaults(rows) {
 		})
 	].join("\n");
 }
-export { BACKTRACK_MIN, BACKTRACK_SHARE, CASES, CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, backtrackOf, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, denseGroupsBoard, dist, fixedPortPoint, formatFaults, formatTable, frechet, goesOutAndBack, groupEdges, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, manyGroupsBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, orderLanes, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roundCorners, runBenchmark, runKey, sameData, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splitPoint, straightRouter, sumFaults, treeDepth, trunksRouter, turns };
+// src/strategies/model.ts
+/** The steps that have strategies, in the order of the pipeline. */
+const STEPS = [
+	"router",
+	"curve",
+	"room"
+];
+/**
+* This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+* When the caller gives no option, the definition gets the `defaults` object itself.
+*/
+function defineStrategy(definition) {
+	const { step, name, describe, defaults, maxNodes } = definition;
+	if (name.length === 0) throw new Error(`A strategy of the step "${step}" has no name.`);
+	const strategy = {
+		step,
+		name,
+		describe,
+		defaults: Object.freeze({ ...defaults }),
+		...maxNodes === void 0 ? {} : { maxNodes },
+		run(input, options) {
+			const all = options === void 0 || Object.keys(options).length === 0 ? strategy.defaults : {
+				...strategy.defaults,
+				...options
+			};
+			return definition.run(input, all);
+		}
+	};
+	return Object.freeze(strategy);
+}
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+function createRegistry(strategies) {
+	const out = {
+		router: [],
+		curve: [],
+		room: []
+	};
+	for (const s of strategies) {
+		const list = out[s.step];
+		if (!list) throw new Error(`There is no step "${String(s.step)}". The steps are ${STEPS.join(", ")}.`);
+		if (list.some((t) => t.name === s.name)) throw new Error(`The step "${s.step}" has two strategies with the name "${s.name}".`);
+		list.push(s);
+	}
+	return Object.freeze({
+		router: Object.freeze(out.router),
+		curve: Object.freeze(out.curve),
+		room: Object.freeze(out.room)
+	});
+}
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+function register(registry, ...strategies) {
+	return createRegistry([
+		...registry.router,
+		...registry.curve,
+		...registry.room,
+		...strategies
+	]);
+}
+/** This function gives the strategies of one step of a registry, in order. */
+function listStrategies(registry, step) {
+	return registry[step];
+}
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+function findStrategy(registry, step, name) {
+	return listStrategies(registry, step).find((s) => s.name === name);
+}
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+function getStrategy(registry, step, name) {
+	const s = findStrategy(registry, step, name);
+	if (!s) throw new Error(`There is no ${step} "${name}". The registry has ${listStrategies(registry, step).map((t) => t.name).join(", ")}.`);
+	return s;
+}
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+function asRouter(strategy, options) {
+	return {
+		name: strategy.name,
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		route: (graph) => strategy.run(graph, options)
+	};
+}
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+function routersOf(registry) {
+	return listStrategies(registry, "router").map((s) => asRouter(s));
+}
+// 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) {
+	return defineStrategy({
+		step: "router",
+		name,
+		describe,
+		defaults,
+		maxNodes,
+		run: (graph, options) => make({
+			...options,
+			name
+		}).route(graph)
+	});
+}
+/** This function makes a router strategy for a router without options. */
+function fixedRouter(router, describe) {
+	return defineStrategy({
+		step: "router",
+		name: router.name,
+		describe,
+		defaults: {},
+		run: (graph) => router.route(graph)
+	});
+}
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+const routerStrategies = Object.freeze({
+	straight: fixedRouter(straightRouter, "The control. Each edge is one straight line between its plugs."),
+	plugs: fixedRouter(plugsRouter, "Each edge leaves its plug along the normal of the side and follows the curve of the inflection rule. It does not go around the nodes."),
+	corners: routerStrategy("corners", "Each edge goes around the nodes on a shortest path (A*) through a sparse visibility graph of the box corners.", 1e4, {}, cornersRouter),
+	"corners-smooth": routerStrategy("corners-smooth", "The same paths as `corners`. A route in clear view follows the inflection rule, and the other routes get round corners.", 1e4, { smooth: true }, cornersRouter),
+	trunks: routerStrategy("trunks", "A rule puts edges in groups. The edges of a group leave one plug of one node on one trunk. At a split point, each edge goes on to its target.", 1e4, { rule: byCollection }, trunksRouter),
+	shared: routerStrategy("shared", "The edges of one collection share their ways through the corner graph. A link that the group uses already costs half.", 1e4, { rule: byCollection }, sharedRouter),
+	"shared-all": routerStrategy("shared-all", "The same as `shared`, but all edges share their ways.", 1e4, {}, sharedRouter),
+	sections: routerStrategy("sections", "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.", 1e5, {}, sectionsRouter),
+	"sections-tree": routerStrategy("sections-tree", "The same as `sections`, but without the limit of the stretch.", 1e5, { stretch: Infinity }, sectionsRouter)
+});
+/** The context of a curve input, without the keys that have no value. */
+const contextOf = (input) => ({
+	...input.startNormal ? { startNormal: input.startNormal } : {},
+	...input.endNormal ? { endNormal: input.endNormal } : {},
+	...input.space ? { space: input.space } : {}
+});
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+const curveStrategies = Object.freeze({
+	straight: defineStrategy({
+		step: "curve",
+		name: "straight",
+		describe: "The polyline as it is.",
+		defaults: {},
+		run: (input) => straightCurve(input.points)
+	}),
+	rounded: defineStrategy({
+		step: "curve",
+		name: "rounded",
+		describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => roundedCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	}),
+	spline: defineStrategy({
+		step: "curve",
+		name: "spline",
+		describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
+		defaults: { tension: 0 },
+		run: (input, o) => splineCurve(input.points, {
+			...contextOf(input),
+			tension: o.tension
+		})
+	}),
+	arc: defineStrategy({
+		step: "curve",
+		name: "arc",
+		describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => arcCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	})
+});
+const roomStrategy = (method, describe) => defineStrategy({
+	step: "room",
+	name: method,
+	describe,
+	defaults: {},
+	run: (input, o) => roomDemand(input.items, input.links, {
+		...o,
+		method
+	})
+});
+/** The built-in room strategies: the methods of `roomDemand`. */
+const roomStrategies = Object.freeze({
+	routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
+	lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap.")
+});
+/** 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(routerStrategies),
+	...Object.values(curveStrategies),
+	...Object.values(roomStrategies)
+]);
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+const STRATEGIES = createRegistry(BUILT_IN_STRATEGIES);
+// src/bench/curves.ts
+const now$1 = () => globalThis.performance?.now() ?? Date.now();
+/**
+* This function routes a graph with a router and makes each curve type of each route.
+* It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+* The type `spline` leaves each plug along the normal of the nearest side of its node.
+*/
+function benchCurves(router, fixture, graph, options = {}) {
+	return benchCurveStrategies(router, fixture, graph, CURVE_TYPES.map((t) => curveStrategies[t]), options);
+}
+/**
+* This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+* The option `radius` goes to each strategy. A strategy without such an option does not read it.
+*/
+function benchCurveStrategies(router, fixture, graph, curves, options = {}) {
+	const tolerance = options.tolerance ?? .25;
+	const result = router.route(graph);
+	const byId = nodeIndex(graph);
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	const space = curveSpace(graph.nodes.map((n) => n.box), tolerance);
+	const routes = result.routes.flatMap((r) => {
+		const e = edges.get(r.edge);
+		const s = e && byId.get(e.source.node);
+		const t = e && byId.get(e.target.node);
+		if (!e || !s || !t || r.points.length < 2) return [];
+		const first = r.points[0];
+		const last = r.points[r.points.length - 1];
+		return [{
+			source: s.id,
+			target: t.id,
+			points: r.points,
+			startNormal: SIDE_NORMAL[nearestSide(s.box, first)],
+			endNormal: SIDE_NORMAL[nearestSide(t.box, last)]
+		}];
+	});
+	const base = measureLinks(boxes, routes);
+	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
+	const radius = { radius: options.radius ?? 12 };
+	return curves.map((curve) => {
+		const make = (withSpace) => routes.map((r) => ({
+			source: r.source,
+			target: r.target,
+			points: sampleCurve(curve.run({
+				points: r.points,
+				startNormal: r.startNormal,
+				endNormal: r.endNormal,
+				...withSpace ? { space } : {}
+			}, radius), tolerance)
+		}));
+		const free = measureLinks(boxes, make(false));
+		const t0 = now$1();
+		const clamped = make(true);
+		const ms = now$1() - t0;
+		const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
+		return {
+			router: router.name,
+			fixture,
+			type: curve.name,
+			links: routes.length,
+			through: base.through,
+			free: free.through,
+			clamped: measureLinks(boxes, clamped).through,
+			length: ink > 0 ? length / ink : 1,
+			ms
+		};
+	});
+}
+/** This function writes the rows of `benchCurves` as a Markdown table. */
+function formatCurves(rows) {
+	return [
+		"| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |",
+		"|---|---|---|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`)
+	].join("\n");
+}
+// src/bench/room.ts
+const now = () => globalThis.performance?.now() ?? Date.now();
+/** This function gives the area of the bounding box of the nodes. */
+function areaOf(nodes) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of nodes) {
+		x0 = Math.min(x0, n.box.x);
+		y0 = Math.min(y0, n.box.y);
+		x1 = Math.max(x1, n.box.x + n.box.w);
+		y1 = Math.max(y1, n.box.y + n.box.h);
+	}
+	return nodes.length ? (x1 - x0) * (y1 - y0) : 0;
+}
+/**
+* This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
+* With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+* Without it, the links of a gap share the lines of the level links.
+* The function also measures the lane routes of the router `sections` at the lane width `spacing`.
+*/
+function measureBoard(graph, spacing, order) {
+	const links = roomLinks(graph);
+	const level = levelLinks(graph.nodes.map((n) => ({
+		id: n.id,
+		box: n.box,
+		nodes: [n.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})));
+	const drawn = order ? gapLanes(graph.nodes, level, {
+		spacing,
+		order
+	}) : level;
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edgeOf = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const key = `${e.source.node}\u0000${e.target.node}`;
+		if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+	}
+	const q = measureQuality(graph, { routes: drawn.map((l) => ({
+		edge: edgeOf.get(`${l.source}\u0000${l.target}`),
+		points: l.points
+	})) });
+	const segments = segmentsOf(sectionsRouter({ name: "sections" }).route(graph));
+	const lanes = laneRoutes(segments, new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges))), spacing);
+	return {
+		faults: measureLinks(boxes, drawn),
+		crossings: q.crossings,
+		ink: q.ink,
+		detour: q.detour,
+		laneThrough: measureRouteFaults(graph, { routes: lanes }).through
+	};
+}
+/**
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+* The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
+*/
+function benchRoom(fixture, graph, options = {}, methods = [roomStrategies.routes, roomStrategies.lines]) {
+	const spacing = options.spacing ?? 4;
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing)
+	});
+	const rows = [row("packed", graph.nodes, 0)];
+	const t0 = now();
+	const gutter = makeRoom(graph.nodes, links, {
+		...options,
+		spacing: 0,
+		method: "routes"
+	});
+	rows.push(row("gutter", gutter.items, now() - t0));
+	const { method: _method, ...preset } = options;
+	for (const s of methods) {
+		const t1 = now();
+		const gaps = s.run({
+			items: graph.nodes,
+			links
+		}, preset);
+		const nodes = openGaps(graph.nodes, gaps, options.snap);
+		rows.push(row(s.name, nodes, now() - t1));
+	}
+	return rows;
+}
+/**
+* This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+* The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
+*/
+function sweepRoom(fixture, graph, settings, baseline = {
+	gutter: 8,
+	spacing: 4
+}) {
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms, spacing, lanes) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing, lanes)
+	});
+	const rows = [row("gutter", makeRoom(graph.nodes, links, {
+		...baseline,
+		spacing: 0,
+		method: "routes",
+		maxGrowth: Infinity,
+		passes: 1
+	}).items, 0, baseline.spacing ?? 4)];
+	for (const s of settings) {
+		const t0 = now();
+		const open = makeRoom(graph.nodes, links, {
+			...s.options,
+			method: "routes"
+		});
+		rows.push(row(s.name, open.items, now() - t0, s.options.spacing ?? 4, s.lanes));
+	}
+	return rows;
+}
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+const GROWTH_SWEEP = [
+	0,
+	.06,
+	.09,
+	.12,
+	.15,
+	.18,
+	.21,
+	.25,
+	.3,
+	.35,
+	.5,
+	Infinity
+];
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+function growthSettings(values = GROWTH_SWEEP) {
+	return values.map((m) => ({
+		name: `maxGrowth ${m}`,
+		options: {
+			gutter: 8,
+			spacing: 4,
+			maxGrowth: m
+		}
+	}));
+}
+/**
+* This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+* The order `shared` is the far view without lanes, as before ROOM-C.
+*/
+function laneSettings(spacings = [
+	2,
+	4,
+	6,
+	8
+], orders = LANE_ORDERS) {
+	return spacings.flatMap((spacing) => [{
+		name: `shared spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		}
+	}, ...orders.map((lanes) => ({
+		name: `${lanes} spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		},
+		lanes
+	}))]);
+}
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+function passSettings(gutters = [
+	4,
+	8,
+	12,
+	16
+], passes = [1, 2]) {
+	return gutters.flatMap((gutter) => passes.map((p) => ({
+		name: `gutter ${gutter} passes ${p}`,
+		options: {
+			gutter,
+			spacing: 4,
+			passes: p
+		}
+	})));
+}
+/** This function writes the rows of `benchRoom` as a Markdown table. */
+function formatRoom(rows) {
+	return [
+		"| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			return `| ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${f.links} | ${f.through} | ${f.outside} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${r.crossings} | ${Math.round(r.ink)} | ${r.detour.toFixed(3)} | ${r.laneThrough} | ${r.ms.toFixed(1)} |`;
+		})
+	].join("\n");
+}
+export { BACKTRACK_MIN, BACKTRACK_SHARE, BUILT_IN_STRATEGIES, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, GROWTH_SWEEP, Grid, LANE_ORDERS, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, STEPS, STRATEGIES, TOLERANCE, WayFinder, allSections, arcCurve, asRouter, backtrackOf, benchCurveStrategies, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, createRegistry, cubicAt, curveOf, curveSpace, curveStrategies, defineStrategy, denseGroupsBoard, dist, distinctPoints, findStrategy, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatTable, frechet, gapLanes, getStrategy, goesOutAndBack, groupEdges, growthSettings, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, laneSettings, listStrategies, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, passSettings, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, register, rng, roomDemand, roomLinks, roomStrategies, roundCorners, roundedCurve, routerStrategies, routersOf, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splineCurve, splitPoint, straightCurve, straightRouter, sumFaults, sweepRoom, toSvgPath, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map