@mark1russell7/highways 0.3.0 → 0.4.0

package/build/index.js

@@ -1049,7 +1049,7 @@ function checkProperties(graph, result, limit = 100) {
 		}
 		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 (!r || !(holds$1(r.points, run.points) || holds$1(r.points, [...run.points].reverse()))) {
 				if (add({
 					rule: "run-shared",
 					edge: id,
@@ -1112,7 +1112,7 @@ function onBoundary(p, b) {
 	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) {
+function holds$1(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;
@@ -1684,7 +1684,7 @@ function clothoidPoint(s, a2) {
 /** The fits of the clothoids of recent corners, by the turn and the spiral share. Each fit comes when a corner first needs it. The cache empties when it gets large. */
 const fits = /* @__PURE__ */ new Map();
 /** The number of points of the dense polyline that measures the error of a fit. */
-const DENSE = 256;
+const DENSE$1 = 256;
 /** This function gives the distance from the point `q` to the part of the polyline `p` from the index `from` to the index `to`. */
 function distanceTo(q, p, from, to) {
 	let best = Infinity;
@@ -1725,13 +1725,13 @@ function clothoidFits(theta) {
 		};
 	};
 	const dense = [];
-	for (let i = 0; i <= DENSE; i++) dense.push(clothoidPoint(i / DENSE * length, a2));
+	for (let i = 0; i <= DENSE$1; i++) dense.push(clothoidPoint(i / DENSE$1 * length, a2));
 	const done = [];
 	return (n) => {
 		const known = done[n];
 		if (known) return known;
 		const pieces = fitPieces(at, n);
-		const window = Math.ceil(DENSE / n / 2) + 8;
+		const window = Math.ceil(DENSE$1 / n / 2) + 8;
 		let error = 0;
 		let from = {
 			x: 0,
@@ -1739,7 +1739,7 @@ function clothoidFits(theta) {
 		};
 		pieces.forEach((q, k) => {
 			for (let i = 1; i < 16; i++) {
-				const mid = Math.round((k + i / 16) / n * DENSE);
+				const mid = Math.round((k + i / 16) / n * DENSE$1);
 				error = Math.max(error, distanceTo(cubicAt(from, q.c1, q.c2, q.to, i / 16), dense, mid - window, mid + window));
 			}
 			from = q.to;
@@ -2043,12 +2043,12 @@ function straightCurve(points) {
 	});
 }
 // src/segments.ts
-const SAME$2 = 1e-6;
+const SAME$3 = 1e-6;
 /** This function gives the index where `p` holds the points of `part` in a row, from `from` on, or -1. */
 function indexOf(p, part, from) {
 	for (let i = from; i + part.length <= p.length; i++) {
 		let ok = true;
-		for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j], part[j]) <= SAME$2;
+		for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j], part[j]) <= SAME$3;
 		if (ok) return i;
 	}
 	return -1;
@@ -2151,7 +2151,7 @@ function pathPoints(graph, path) {
 		const s = byId.get(ref.segment);
 		if (!s) continue;
 		const pts = ref.reverse ? [...s.points].reverse() : s.points;
-		for (const q of pts) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME$2) out.push(q);
+		for (const q of pts) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME$3) out.push(q);
 	}
 	return out;
 }
@@ -2231,7 +2231,7 @@ function lanePaths(graph, spacingOf) {
 			if (!s) continue;
 			const spacing = spacingOf(s);
 			const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
-			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME$2) out.push(q);
+			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME$3) out.push(q);
 		}
 		if (out.length >= 2 && ends.length >= 2) {
 			out[0] = ends[0];
@@ -2258,7 +2258,7 @@ function partAfter(P, Q) {
 		const a = P.p[P.e + j];
 		const b = Q.p[Q.e + j];
 		if (a === void 0 || b === void 0) return void 0;
-		if (dist(a, b) > SAME$2) {
+		if (dist(a, b) > SAME$3) {
 			const from = P.p[P.e + j - 2];
 			const at = P.p[P.e + j - 1];
 			const side = turn$1(from, at, a) - turn$1(from, at, b);
@@ -2275,7 +2275,7 @@ function partBefore(P, Q) {
 		const a = P.p[P.s - j];
 		const b = Q.p[Q.s - j];
 		if (a === void 0 || b === void 0) return void 0;
-		if (dist(a, b) > SAME$2) {
+		if (dist(a, b) > SAME$3) {
 			const from = P.p[P.s - j + 2];
 			const at = P.p[P.s - j + 1];
 			const side = turn$1(from, at, b) - turn$1(from, at, a);
@@ -2288,7 +2288,7 @@ function partBefore(P, Q) {
 }
 const byEdge = (P, Q) => P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
 /** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
-const firstPoint = (a, b) => a.x < b.x - SAME$2 || Math.abs(a.x - b.x) <= SAME$2 && a.y < b.y;
+const firstPoint = (a, b) => a.x < b.x - SAME$3 || Math.abs(a.x - b.x) <= SAME$3 && a.y < b.y;
 /**
 * This function gives the lane order of the edges on a shared way `run` (metro-line order).
 * The routes are polylines that hold the points of the run in a row, in either direction. A route that does not hold the run goes last.
@@ -2338,7 +2338,7 @@ function orderLanes(run, routes, order = "run") {
 // src/curves/highway/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$1 = 1e-6;
-const SAME$1 = 1e-6;
+const SAME$2 = 1e-6;
 /** A turn nearer to a half turn than this angle, in radians, is a spike: the route goes back on itself. */
 const SPIKE$1 = .01;
 /** A miter point farther from its vertex than this multiple of the offset gives two corners in place of one. */
@@ -2377,7 +2377,7 @@ function miter(v, nA, nB, o) {
 */
 function jogShape(r, shift, style = "biarc") {
 	const d = Math.abs(shift);
-	if (d < SAME$1) return {
+	if (d < SAME$2) return {
 		length: 0,
 		angle: 0
 	};
@@ -2419,7 +2419,7 @@ function filletPolyline(vertices, trace) {
 	const v = [];
 	for (const q of vertices) {
 		const last = v[v.length - 1];
-		if (last && Math.hypot(q.p.x - last.p.x, q.p.y - last.p.y) <= SAME$1) {
+		if (last && Math.hypot(q.p.x - last.p.x, q.p.y - last.p.y) <= SAME$2) {
 			const jog = q.jog?.part === "start" ? q.jog : last.jog ?? q.jog;
 			v[v.length - 1] = jog ? {
 				...last,
@@ -2546,7 +2546,7 @@ function jogSegments(from, to, u, style, pieces) {
 	const D = sub(to, from);
 	const l = dot(D, u);
 	const d = cross(u, D);
-	if (l <= SAME$1) return [{
+	if (l <= SAME$2) return [{
 		kind: "line",
 		to
 	}];
@@ -2654,7 +2654,7 @@ function tracedHighwayCurves(source, open, laneWidth, options = {}) {
 	const centerOf = (s) => {
 		let c = centers.get(s.id);
 		if (!c) {
-			c = distinctPoints(s.points, SAME$1);
+			c = distinctPoints(s.points, SAME$2);
 			centers.set(s.id, c);
 		}
 		return c;
@@ -2675,7 +2675,7 @@ function tracedHighwayCurves(source, open, laneWidth, options = {}) {
 				const a = c[from];
 				const b = c[to];
 				const len = Math.hypot(b.x - a.x, b.y - a.y);
-				if (len <= SAME$1) continue;
+				if (len <= SAME$2) continue;
 				const u = {
 					x: (b.x - a.x) / len,
 					y: (b.y - a.y) / len
@@ -2818,13 +2818,13 @@ function withoutSpikes(input) {
 		}
 		const rest = A.len - B.len;
 		const keep = [];
-		if (rest > SAME$1) keep.push({
+		if (rest > SAME$2) keep.push({
 			...A,
 			b: B.b,
 			len: rest,
 			to: -1
 		});
-		else if (-rest > SAME$1) keep.push({
+		else if (-rest > SAME$2) keep.push({
 			...B,
 			a: A.a,
 			len: -rest,
@@ -2843,11 +2843,11 @@ function laneCurve(plan, bends, polyline, { radius, minRadius, space, style: wan
 	const endJog = new Array(L).fill(void 0);
 	for (let j = 0; j < L; j++) {
 		const leg = legs[j];
-		if (Math.abs(at[j] - leg.off) > SAME$1) startJog[j] = {
+		if (Math.abs(at[j] - leg.off) > SAME$2) startJog[j] = {
 			from: at[j],
 			to: leg.off
 		};
-		if (Math.abs(at[j + 1] - leg.off) > SAME$1) endJog[j] = {
+		if (Math.abs(at[j + 1] - leg.off) > SAME$2) endJog[j] = {
 			from: leg.off,
 			to: at[j + 1]
 		};
@@ -5388,7 +5388,7 @@ const SECTIONS_DEFAULTS = Object.freeze({
 	stretchPad: 4,
 	hubSlack: 80
 });
-const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+const dedupe$2 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
 /**
 * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
 * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
@@ -5466,7 +5466,7 @@ function sectionsRouter(options) {
 				if (!p) {
 					const [from, to] = forward ? [a, b] : [b, a];
 					const way = corners.path(from, to);
-					p = dedupe$1(way ? corners.pull(way) : [from, to]);
+					p = dedupe$2(way ? corners.pull(way) : [from, to]);
 					pieces.set(key, p);
 				}
 				if (!used.includes(key)) used.push(key);
@@ -5932,7 +5932,7 @@ function splitPoint(start, targets, split, free, step) {
 	while (d > 0 && !free(at(d))) d -= step;
 	return d > 0 ? at(d) : start;
 }
-const dedupe = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
 /**
 * This function gives the place where a branch leaves its trunk. The branch starts at the last point of the trunk and ends at the plug of the target.
 *
@@ -6041,7 +6041,7 @@ function trunksRouter(options) {
 				const split = splitPoint(ways.out(plug), centers, options.split ?? .5, (p) => !ways.obstacles.inside(p, ways.margin), ways.margin);
 				const way = ways.fromPlug(plug, split);
 				if (!way) continue;
-				const trunk = dedupe(way);
+				const trunk = dedupe$1(way);
 				const end = trunk[trunk.length - 1];
 				const prev = trunk.length >= 2 ? trunk[trunk.length - 2] : plug.point;
 				const len = dist(prev, end);
@@ -6054,11 +6054,11 @@ function trunksRouter(options) {
 				const exits = [];
 				group.forEach((e, i) => {
 					const pt = placePlug(targets[i], e.target, end);
-					const branch = dedupe(ways.toPlug(end, pt) ?? [end, pt.point]);
+					const branch = dedupe$1(ways.toPlug(end, pt) ?? [end, pt.point]);
 					if (!part) {
 						own.push({
 							edge: e.id,
-							points: dedupe([...trunk, ...branch.slice(1)])
+							points: dedupe$1([...trunk, ...branch.slice(1)])
 						});
 						branches.push({
 							edge: e.id,
@@ -6090,7 +6090,7 @@ function trunksRouter(options) {
 				for (const { exit } of exits) if (!stops.has(exit.at)) stops.set(exit.at, exit.point);
 				const line = [...stops].sort((x, y) => x[0] - y[0]);
 				for (const { edge, exit } of exits) {
-					const p = dedupe([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
+					const p = dedupe$1([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
 					points.set(edge, p);
 					own.push({
 						edge,
@@ -6193,7 +6193,7 @@ const ROUTERS = [
 /** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle is a spike, and it gets no arc. */
 const FLAT = 1e-6;
 const SPIKE = .01;
-const SAME = 1e-6;
+const SAME$1 = 1e-6;
 /** A leg with a smaller share of its length on an axis does not grow on that axis. */
 const SLANT = .2;
 const turnOf = (u, w) => Math.atan2(u.x * w.y - u.y * w.x, u.x * w.x + u.y * w.y);
@@ -6203,7 +6203,7 @@ const turnOf = (u, w) => Math.atan2(u.x * w.y - u.y * w.x, u.x * w.x + u.y * w.y
 */
 function jogLength(r, shift) {
 	const d = Math.abs(shift);
-	if (d < SAME || r <= 0) return 0;
+	if (d < SAME$1 || r <= 0) return 0;
 	if (r < d / 2) return 2 * r;
 	return 2 * r * Math.sin(Math.acos(1 - d / (2 * r)));
 }
@@ -6218,7 +6218,7 @@ function legsOf(graph, spacing, maxWidth) {
 			const sp = s.count > 1 ? Math.min(spacing, maxWidth / (s.count - 1)) : 0;
 			const offset = ((s.count - 1) / 2 - ref.lane) * sp;
 			const c = [];
-			for (const p of s.points) if (c.length === 0 || Math.hypot(p.x - c[c.length - 1].x, p.y - c[c.length - 1].y) > SAME) c.push(p);
+			for (const p of s.points) if (c.length === 0 || Math.hypot(p.x - c[c.length - 1].x, p.y - c[c.length - 1].y) > SAME$1) c.push(p);
 			const n = c.length;
 			for (let j = 0; j + 1 < n; j++) {
 				const from = ref.reverse ? n - 1 - j : j;
@@ -6274,7 +6274,7 @@ function shortLegs(legs, minRadius) {
 			const start = j > 0 ? endLength(path[j - 1], X, X, minRadius) : 0;
 			const end = j + 1 < path.length ? endLength(X, path[j + 1], X, minRadius) : 0;
 			const short = 2 * Math.max(start, end) - X.len;
-			if (short <= SAME) continue;
+			if (short <= SAME$1) continue;
 			const known = out.get(X.key);
 			if (!known || known.short < short) out.set(X.key, {
 				leg: X,
@@ -7292,11 +7292,440 @@ function formatLevels(rows) {
 		].join(" | "))).map((b) => `| ${b} |`)
 	].join("\n");
 }
+// src/highways/model.ts
+/** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
+function pointAt(line, at) {
+	if (line.length === 0) throw new Error("The polyline has no point.");
+	if (at <= 0) return line[0];
+	if (at >= line.length - 1) return line[line.length - 1];
+	const i = Math.floor(at);
+	const u = at - i;
+	const a = line[i];
+	if (u === 0) return a;
+	const b = line[i + 1];
+	return {
+		x: a.x + (b.x - a.x) * u,
+		y: a.y + (b.y - a.y) * u
+	};
+}
+/** This function gives the length of a polyline from the place `from` to the place `to`, with `from` not larger than `to`. */
+function lengthBetween(line, from, to) {
+	if (to <= from) return 0;
+	let sum = 0;
+	let prev = pointAt(line, from);
+	for (let i = Math.floor(from) + 1; i < to; i++) {
+		const p = line[i];
+		sum += dist(prev, p);
+		prev = p;
+	}
+	return sum + dist(prev, pointAt(line, to));
+}
+/** This function gives a member of a highway with its merge point and its split point at the places `on` and `off` of the spine. */
+function memberAt(spine, edge, on, off, seq = 0) {
+	return {
+		edge,
+		on,
+		off,
+		merge: pointAt(spine, on),
+		split: pointAt(spine, off),
+		seq
+	};
+}
+/**
+* This function lists the problems of a plan against its graph. A good plan gives an empty list.
+* Each highway has a spine of two points or more, and two members or more. Each member is an edge of the graph, with `on` and `off` on the spine and apart.
+* An edge is a member of a highway one time at most.
+*/
+function checkPlan(graph, plan) {
+	const edges = new Set(graph.edges.map((e) => e.id));
+	const out = [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const h of plan.highways) {
+		if (ids.has(h.id)) out.push(`Two highways have the id "${h.id}".`);
+		ids.add(h.id);
+		const last = h.spine.length - 1;
+		if (h.spine.length < 2) out.push(`The highway "${h.id}" has a spine with fewer than two points.`);
+		if (h.members.length < 2) out.push(`The highway "${h.id}" has fewer than two members.`);
+		const seen = /* @__PURE__ */ new Set();
+		for (const m of h.members) {
+			if (!edges.has(m.edge)) out.push(`The highway "${h.id}" has the member "${m.edge}", which is not an edge of the graph.`);
+			if (seen.has(m.edge)) out.push(`The highway "${h.id}" has the member "${m.edge}" two times.`);
+			seen.add(m.edge);
+			if (!(m.on >= 0 && m.on <= last && m.off >= 0 && m.off <= last)) out.push(`The member "${m.edge}" of the highway "${h.id}" has a place off the spine.`);
+			if (m.on === m.off) out.push(`The member "${m.edge}" of the highway "${h.id}" joins and leaves the spine at one place.`);
+		}
+		if (h.lanes.length !== h.members.length || h.lanes.some((e) => !seen.has(e))) out.push(`The lanes of the highway "${h.id}" are not its members.`);
+	}
+	return out;
+}
+// src/highways/corridors/index.ts
+/** The default options of the strategy `corridors`. */
+const CORRIDOR_DEFAULTS = Object.freeze({
+	rho: .3,
+	minSize: 2,
+	hashes: 64,
+	bands: 32,
+	near: 0,
+	lane: 4
+});
+/**
+* The break-even overlap of two parallel edges for each unit of the lane gap, with the cost exponent 0.5 of the note.
+* A shared stretch shorter than this times the gap adds ink.
+*/
+const BREAK_EVEN = Math.sqrt((2 + Math.SQRT2) / (2 - Math.SQRT2));
+/** This function gives the FNV-1a hash of a string, as an unsigned 32-bit number. */
+function fnv1a(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+/** This function mixes the bits of a 32-bit number (the finalizer of MurmurHash3). */
+function mix(x) {
+	let h = x >>> 0;
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return h >>> 0;
+}
+/** This function gives the MinHash signature of a set of keys with `count` hash functions. */
+function minHash(keys, count) {
+	const sig = new Array(count).fill(4294967295);
+	const seeds = Array.from({ length: count }, (_, i) => mix(Math.imul(i + 1, 2654435769)));
+	for (const key of keys) {
+		const base = fnv1a(key);
+		for (let i = 0; i < count; i++) {
+			const v = mix(base ^ seeds[i]);
+			if (v < sig[i]) sig[i] = v;
+		}
+	}
+	return sig;
+}
+/**
+* This function gives the first way of each edge: the way through the corner graph, with the plugs at its ends.
+* The router `corners` finds the same way before it drops the needless corners.
+*/
+function cornerWays(graph, options) {
+	const byId = nodeIndex(graph);
+	const ways = new WayFinder(graph.nodes, options);
+	const out = [];
+	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));
+		const raw = ways.corners.path(ways.out(ps), ways.out(pt));
+		out.push({
+			edge: e.id,
+			points: raw ? [
+				ps.point,
+				...raw,
+				pt.point
+			] : [ps.point, pt.point]
+		});
+	}
+	return out;
+}
+/** This function gives the way of a route, with a key for each link. Two links with the same ends, in either order, have one key. */
+function wayOf(route, near) {
+	const snap = (p) => near > 0 ? `${Math.round(p.x / near)},${Math.round(p.y / near)}` : `${p.x},${p.y}`;
+	const links = [];
+	const set = /* @__PURE__ */ new Map();
+	let length = 0;
+	for (let i = 1; i < route.points.length; i++) {
+		const p = route.points[i - 1];
+		const q = route.points[i];
+		const len = dist(p, q);
+		if (len <= 1e-9) continue;
+		const a = snap(p);
+		const b = snap(q);
+		if (a === b) continue;
+		const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+		links.push({
+			key,
+			len,
+			a,
+			at: i - 1
+		});
+		if (!set.has(key)) set.set(key, len);
+		length += len;
+	}
+	return {
+		edge: route.edge,
+		points: route.points,
+		links,
+		set,
+		length
+	};
+}
+/** This function gives the length of the common links of two ways. */
+function overlap(p, q) {
+	const [small, large] = p.set.size <= q.set.size ? [p, q] : [q, p];
+	let sum = 0;
+	for (const [key, len] of small.set) if (large.set.has(key)) sum += len;
+	return sum;
+}
+/** This function gives the pairs of ways with one equal band of their signatures, as `i * n + j` with `i < j`, in order. */
+function candidates(ways, hashes, bands) {
+	const rows = Math.max(1, Math.floor(hashes / Math.max(1, bands)));
+	const count = Math.max(1, Math.floor(hashes / rows));
+	const n = ways.length;
+	const pairs = /* @__PURE__ */ new Set();
+	const buckets = /* @__PURE__ */ new Map();
+	ways.forEach((w, i) => {
+		if (w.set.size === 0) return;
+		const sig = minHash(w.set.keys(), rows * count);
+		for (let b = 0; b < count; b++) {
+			const key = `${b}:${sig.slice(b * rows, (b + 1) * rows).join(",")}`;
+			const list = buckets.get(key);
+			if (list) {
+				for (const j of list) pairs.add(j * n + i);
+				list.push(i);
+			} else buckets.set(key, [i]);
+		}
+	});
+	return [...pairs].sort((a, b) => a - b);
+}
+/** This function gives the root of an element of a union-find forest, and shortens the path. */
+function root(parent, i) {
+	while (parent[i] !== i) {
+		parent[i] = parent[parent[i]];
+		i = parent[i];
+	}
+	return i;
+}
+/**
+* This function gives the clusters of the ways. Two ways join when their common links are long.
+* A cluster is a connected part of the joins.
+* MinHash with bands finds the candidate pairs. The function then measures the overlap of each candidate pair.
+* Each cluster keeps the order of the ways, and the clusters come in the order of their first way.
+*/
+function corridorClusters(ways, o) {
+	const n = ways.length;
+	const parent = Array.from({ length: n }, (_, i) => i);
+	const floor = BREAK_EVEN * o.lane;
+	for (const pair of candidates(ways, o.hashes, o.bands)) {
+		const i = Math.floor(pair / n);
+		const j = pair % n;
+		const p = ways[i];
+		const q = ways[j];
+		if (overlap(p, q) >= Math.max(floor, o.rho * Math.min(p.length, q.length))) {
+			const a = root(parent, i);
+			const b = root(parent, j);
+			if (a !== b) parent[Math.max(a, b)] = Math.min(a, b);
+		}
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (let i = 0; i < n; i++) {
+		const r = root(parent, i);
+		const list = groups.get(r);
+		if (list) list.push(i);
+		else groups.set(r, [i]);
+	}
+	return [...groups.values()].filter((g) => g.length >= 2);
+}
+/**
+* This function gives the highway of a pool of ways, or `undefined`. The core is the way with the most shared length.
+* The spine is the stretch of the core with the largest saving. Each link of the spine has two ways of the pool or more.
+* A member is a way of the pool whose links on the spine are long enough, all in one direction.
+*/
+function highwayOf(pool, o) {
+	const count = /* @__PURE__ */ new Map();
+	for (const w of pool) for (const key of w.set.keys()) count.set(key, (count.get(key) ?? 0) + 1);
+	const gain = (key, len) => len * ((count.get(key) ?? 1) - 1);
+	let core;
+	let best = 0;
+	for (const w of pool) {
+		let g = 0;
+		for (const [key, len] of w.set) g += gain(key, len);
+		if (g > best) [core, best] = [w, g];
+	}
+	if (!core) return void 0;
+	let from = -1;
+	let to = -1;
+	let top = 0;
+	let start = 0;
+	let sum = 0;
+	core.links.forEach((l, i) => {
+		if ((count.get(l.key) ?? 0) < 2) {
+			sum = 0;
+			start = i + 1;
+			return;
+		}
+		sum += gain(l.key, l.len);
+		if (sum > top) [top, from, to] = [
+			sum,
+			start,
+			i
+		];
+	});
+	if (from < 0) return void 0;
+	const chosen = core.links.slice(from, to + 1);
+	const spine = [core.points[chosen[0].at], ...chosen.map((l) => core.points[l.at + 1])];
+	const index = /* @__PURE__ */ new Map();
+	chosen.forEach((l, j) => {
+		if (!index.has(l.key)) index.set(l.key, j);
+	});
+	const spineLength = chosen.reduce((s, l) => s + l.len, 0);
+	const floor = BREAK_EVEN * o.lane;
+	const members = [];
+	for (const w of pool) {
+		let first = -1;
+		let last = -1;
+		let forward;
+		let ok = true;
+		let shared = 0;
+		for (const l of w.links) {
+			const j = index.get(l.key);
+			if (j === void 0) continue;
+			const dir = l.a === chosen[j].a;
+			if (forward === void 0) forward = dir;
+			else if (forward !== dir) ok = false;
+			if (first < 0) first = j;
+			else if (forward ? j < last : j > last) ok = false;
+			last = j;
+			shared += l.len;
+		}
+		if (!ok || forward === void 0 || shared < Math.max(floor, o.rho * Math.min(w.length, spineLength))) continue;
+		members.push(forward ? {
+			way: w,
+			on: first,
+			off: last + 1
+		} : {
+			way: w,
+			on: first + 1,
+			off: last
+		});
+	}
+	return {
+		core,
+		spine,
+		members
+	};
+}
+/**
+* This function gives the highways of corridor signatures (HWY-031). Each edge gets a first way: the route of `input.routes`, or its way through the corner graph.
+* The signature of a way is the set of its links. Two edges join when their common links are at least `rho` times the shorter way, and longer than the break-even overlap.
+* MinHash with `hashes` hash functions in `bands` bands finds the candidate pairs fast. Union-find gives the clusters.
+*
+* In each cluster, the spine is the longest common run of links of the way with the most shared length. Each edge on the spine joins it at its first common link and leaves it at its last one.
+* The edges of the cluster that are not on the spine make the next highway, while `minSize` of them remain.
+*/
+function corridorPlan(input, o) {
+	const routes = input.routes?.routes ?? cornerWays(input.graph, {
+		...o.margin === void 0 ? {} : { margin: o.margin },
+		...o.k === void 0 ? {} : { k: o.k }
+	});
+	const known = new Set(input.graph.edges.map((e) => e.id));
+	const ways = routes.filter((r) => known.has(r.edge)).map((r) => wayOf(r, o.near));
+	const highways = [];
+	corridorClusters(ways, o).forEach((cluster, c) => {
+		let pool = cluster.map((i) => ways[i]);
+		while (pool.length >= Math.max(2, o.minSize)) {
+			const found = highwayOf(pool, o);
+			if (!found) break;
+			const { core, spine, members } = found;
+			if (members.length < Math.max(2, o.minSize)) {
+				pool = pool.filter((w) => w !== core);
+				continue;
+			}
+			const lanes = orderLanes(spine, members.map((m) => ({
+				edge: m.way.edge,
+				points: m.way.points
+			})), "bundle");
+			const byEdge = new Map(members.map((m) => [m.way.edge, m]));
+			const list = lanes.map((edge) => {
+				const m = byEdge.get(edge);
+				return memberAt(spine, edge, m.on, m.off);
+			});
+			highways.push({
+				id: `h${highways.length}`,
+				key: `c${c}`,
+				spine,
+				lanes,
+				members: list
+			});
+			const used = new Set(members.map((m) => m.way));
+			pool = pool.filter((w) => !used.has(w));
+		}
+	});
+	return { highways };
+}
+// src/highways/result.ts
+/**
+* This function gives the highways of a result of a router: one highway for each shared run and for each trunk of a bundle.
+* The spine is the points of the run or of the trunk. Each edge of the run is a member, from one end of the spine to the other end, in the way of its route.
+* The member `seq` is the place of the shared stretch in the route of the edge. The lanes keep the lane order of the router.
+*
+* Thus `follow` routes each edge along the shared stretches of the router. A route that does not hold its run is not a member.
+*/
+function planOfResult(result) {
+	const graph = segmentsOf(result);
+	const keys = new Map([...(result.runs ?? []).map((r) => [r.id, r.key]), ...(result.bundles ?? []).map((b) => [b.id, b.key])]);
+	const shared = graph.segments.filter((s) => s.count > 1);
+	const ids = new Set(shared.map((s) => s.id));
+	const place = /* @__PURE__ */ new Map();
+	for (const path of graph.paths) {
+		let seq = 0;
+		for (const ref of path.segments) if (ids.has(ref.segment)) place.set(`${ref.segment}\u0000${path.edge}`, {
+			seq: seq++,
+			reverse: ref.reverse
+		});
+	}
+	const highways = [];
+	for (const s of shared) {
+		const last = s.points.length - 1;
+		const members = [];
+		for (const edge of s.edges) {
+			const at = place.get(`${s.id}\u0000${edge}`);
+			if (at) members.push(at.reverse ? memberAt(s.points, edge, last, 0, at.seq) : memberAt(s.points, edge, 0, last, at.seq));
+		}
+		if (members.length < 2) continue;
+		highways.push({
+			id: `h${highways.length}`,
+			key: keys.get(s.id) ?? s.id,
+			spine: s.points,
+			lanes: members.map((m) => m.edge),
+			members
+		});
+	}
+	return { highways };
+}
+// src/highways/keys/index.ts
+/**
+* This function gives the highways that the router `trunks` decides. A rule gives each edge a key.
+* The edges from one plug with one key share a trunk to a split point. The edges that go on together share a run past it.
+* Each trunk and each run becomes one highway. The function does not change the router: it reads its bundles and its runs.
+*/
+function keysPlan(input, options) {
+	return planOfResult(trunksRouter({
+		...options,
+		name: "keys"
+	}).route(input.graph));
+}
+// src/highways/shared-ways/index.ts
+/**
+* This function gives the highways that the router `shared` decides. The edges of one key go one by one through the corner graph.
+* A link that the key uses already costs less, so the ways of a key come together. Each stretch that two edges or more share becomes one highway.
+* The function does not change the router: it reads its runs.
+*/
+function sharedWaysPlan(input, options) {
+	return planOfResult(sharedRouter({
+		...options,
+		name: "shared-ways"
+	}).route(input.graph));
+}
 // src/strategies/model.ts
 /** The steps that have strategies, in the order of the pipeline. */
 const STEPS = [
 	"group",
 	"router",
+	"highway",
 	"curve",
 	"room"
 ];
@@ -7335,6 +7764,7 @@ function createRegistry(strategies) {
 	const out = {
 		group: [],
 		router: [],
+		highway: [],
 		curve: [],
 		room: []
 	};
@@ -7347,6 +7777,7 @@ function createRegistry(strategies) {
 	return Object.freeze({
 		group: Object.freeze(out.group),
 		router: Object.freeze(out.router),
+		highway: Object.freeze(out.highway),
 		curve: Object.freeze(out.curve),
 		room: Object.freeze(out.room)
 	});
@@ -7356,6 +7787,7 @@ function register(registry, ...strategies) {
 	return createRegistry([
 		...registry.group ?? [],
 		...registry.router,
+		...registry.highway ?? [],
 		...registry.curve,
 		...registry.room,
 		...strategies
@@ -7474,6 +7906,73 @@ const SHARED_SCHEMA = {
 	},
 	laneOrder: LANE_ORDER
 };
+/** The declarations of the options of the highway strategy `corridors` (HWY-031). */
+const CORRIDOR_SCHEMA = {
+	margin: WAY_SCHEMA.margin,
+	k: WAY_SCHEMA.k,
+	rho: {
+		type: "number",
+		min: .1,
+		max: .8,
+		step: .05,
+		default: .3,
+		describe: "Two edges join when their common links are this share of the shorter way, or longer."
+	},
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 2,
+		describe: "A highway has this number of edges or more."
+	},
+	hashes: {
+		type: "integer",
+		min: 16,
+		max: 128,
+		step: 16,
+		scale: "log",
+		marks: [
+			16,
+			32,
+			64,
+			128
+		],
+		default: 64,
+		describe: "The number of hash functions of the signature of a way."
+	},
+	bands: {
+		type: "integer",
+		min: 4,
+		max: 32,
+		step: 4,
+		scale: "log",
+		marks: [
+			4,
+			8,
+			16,
+			32
+		],
+		default: 32,
+		describe: "The number of bands of the signature. Two ways with one equal band are a candidate pair."
+	},
+	near: {
+		type: "number",
+		min: 0,
+		max: 8,
+		step: 1,
+		default: 0,
+		describe: "Two link ends nearer than this grid size are one point. With 0, only equal points are one point."
+	},
+	lane: {
+		type: "number",
+		min: 1,
+		max: 16,
+		step: 1,
+		default: 4,
+		describe: "The gap between two lanes. A common stretch shorter than the break-even overlap for this gap does not join two edges."
+	}
+};
 /** The declarations of the limits of the tree of sections (`SectionOptions`). */
 const SECTION_SCHEMA = {
 	cap: {
@@ -7926,9 +8425,46 @@ const contextOf = (input) => ({
 	...input.endNormal ? { endNormal: input.endNormal } : {},
 	...input.space ? { space: input.space } : {}
 });
+/** The curves of the lanes of each board, for the last options and the last free space. The strategy `highway` draws one lane in each call. */
+const laneCurves = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives the curve of one lane of a board with `highwayCurves` and each option of the strategy `highway`.
+* The lanes of a bundle bend as one. So the function draws all the lanes of the board one time, and keeps them for the next lane.
+*/
+function highwayLane(input, o) {
+	const { board, index } = input.lane;
+	const key = JSON.stringify([
+		o.radius,
+		o.minRadius,
+		o.jog,
+		o.jogPieces
+	]);
+	let hit = laneCurves.get(board);
+	if (!hit || hit.key !== key || hit.space !== input.space) {
+		const curves = highwayCurves(board.graph, board.open, board.width, {
+			radius: o.radius,
+			minRadius: o.minRadius,
+			jog: o.jog,
+			jogPieces: o.jogPieces,
+			...board.maxWidth === void 0 ? {} : { maxWidth: board.maxWidth },
+			...input.space ? { space: input.space } : {}
+		});
+		hit = {
+			key,
+			space: input.space,
+			curves
+		};
+		laneCurves.set(board, hit);
+	}
+	const lane = hit.curves[index];
+	return lane ? [...lane.segments] : highwayCurve(input.points, {
+		radius: o.radius,
+		...input.space ? { space: input.space } : {}
+	});
+}
 /**
 * The built-in curve strategies. The first six are in the order of `CURVE_TYPES`, and each one gives the same segments as `curveOf` with its type.
-* The strategy `highway` gives the curve of `arc` for one polyline. `highwayCurves` bends the lanes of a bundle as one.
+* The strategy `highway` gives the curve of `arc` for one polyline. For a polyline with a `lane`, it bends the lanes of each bundle as one with `highwayCurves`.
 */
 const curveStrategies = Object.freeze({
 	straight: defineStrategy({
@@ -8015,7 +8551,10 @@ const curveStrategies = Object.freeze({
 			jogPieces: 4
 		},
 		schema: HIGHWAY_SCHEMA,
-		run: (input, o) => highwayCurve(input.points, {
+		run: (input, o) => input.lane ? highwayLane({
+			...input,
+			lane: input.lane
+		}, o) : highwayCurve(input.points, {
 			radius: o.radius,
 			...input.space ? { space: input.space } : {}
 		})
@@ -8088,10 +8627,44 @@ const groupStrategies = Object.freeze({
 		run: (graph, o) => cutGroups(graph, o)
 	})
 });
+/**
+* The built-in highway strategies: the decisions of the routers `trunks` and `shared` as plans, and corridor signatures (HWY-031).
+* `follow` routes the edges along a plan, and `highwayRouter` gives a router that does both.
+*/
+const highwayStrategies = Object.freeze({
+	keys: defineStrategy({
+		step: "highway",
+		name: "keys",
+		describe: "The highways of the router `trunks`. The edges from one plug with one key share a trunk, and the edges that go on together share a run past it.",
+		defaults: { rule: byCollection },
+		schema: TRUNKS_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => keysPlan(input, o)
+	}),
+	"shared-ways": defineStrategy({
+		step: "highway",
+		name: "shared-ways",
+		describe: "The highways of the router `shared`. The edges of one key share their ways through the corner graph, and each shared stretch is a highway.",
+		defaults: { rule: byCollection },
+		schema: SHARED_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => sharedWaysPlan(input, o)
+	}),
+	corridors: defineStrategy({
+		step: "highway",
+		name: "corridors",
+		describe: "Corridor signatures. Edges whose first ways share long links make a cluster, found with MinHash. The longest common run of each cluster is its highway.",
+		defaults: { ...CORRIDOR_DEFAULTS },
+		schema: CORRIDOR_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => corridorPlan(input, o)
+	})
+});
 /** 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),
 	...Object.values(routerStrategies),
+	...Object.values(highwayStrategies),
 	...Object.values(curveStrategies),
 	...Object.values(roomStrategies)
 ]);
@@ -10058,6 +10631,194 @@ function paretoFront(items, values, objectives) {
 	const v = items.map(values);
 	return items.filter((_, i) => !v.some((w, j) => j !== i && dominates(w, v[i], objectives)));
 }
+// src/highways/follow.ts
+const SAME = 1e-6;
+const dedupe = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > SAME);
+/** This function tells if a polyline holds the points of `part` in a row, in this order. */
+function holdsInOrder(p, part) {
+	for (let i = 0; i + part.length <= p.length; i++) {
+		let ok = true;
+		for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j], part[j]) <= SAME;
+		if (ok) return true;
+	}
+	return false;
+}
+/** This function tells if a polyline holds the points of `part` in a row, in either direction. */
+const holds = (p, part) => holdsInOrder(p, part) || holdsInOrder(p, [...part].reverse());
+/**
+* This function tells if a point of a spine can be the plug of an end. The point is on the box of the node.
+* When the end has a fixed plug, the point is at that plug.
+*/
+function plugAt(node, end, p) {
+	if (pointBoxDistance(p, node.box) > SAME) return false;
+	const fixed = fixedPortPoint(node, end);
+	return fixed === void 0 || dist(fixed, p) <= SAME;
+}
+/** This function gives the points of the stops from the place `on` to the place `off`. When `on` is larger than `off`, the points go backward. */
+function slice(stops, on, off) {
+	const lo = Math.min(on, off);
+	const hi = Math.max(on, off);
+	const out = stops.filter(([at]) => at >= lo && at <= hi).map(([, p]) => p);
+	return on <= off ? out : out.reverse();
+}
+/**
+* This function routes the edges along a highway plan.
+*
+* An edge of a highway goes from its source plug to its merge point. Then it goes along the spine to its split point, and to its target plug.
+* The ramps go around the boxes through the corner graph (`WayFinder.fromPlug` and `WayFinder.toPlug`).
+* A spine point on the box of the node is the plug itself. When the end has a fixed plug, the point is at that plug.
+*
+* An edge on several highways takes them in the order of `seq`.
+* A way through the corner graph goes from each split point to the next merge point.
+* An edge outside the plan keeps its route from `options.routes`, or goes as in the router `corners`.
+*
+* The result has a shared run for each stretch of a spine where the same two edges or more go. Each run holds the points of its routes in a row.
+* The same graph, plan and options give the same result.
+*/
+function follow(graph, plan, options = {}) {
+	const byId = nodeIndex(graph);
+	const ways = new WayFinder(graph.nodes, options);
+	const base = new Map((options.routes?.routes ?? []).map((r) => [r.edge, r.points]));
+	const lines = plan.highways.map((h) => {
+		const stops = new Map(h.spine.map((p, i) => [i, p]));
+		for (const m of h.members) for (const at of [m.on, m.off]) if (!stops.has(at)) stops.set(at, pointAt(h.spine, at));
+		return [...stops].sort((a, b) => a[0] - b[0]);
+	});
+	const trips = /* @__PURE__ */ new Map();
+	plan.highways.forEach((h, hi) => {
+		for (const m of h.members) {
+			const list = trips.get(m.edge);
+			if (list) list.push({
+				h: hi,
+				m
+			});
+			else trips.set(m.edge, [{
+				h: hi,
+				m
+			}]);
+		}
+	});
+	for (const list of trips.values()) list.sort((a, b) => a.m.seq - b.m.seq || a.h - b.h);
+	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 trip = trips.get(e.id);
+		if (!trip) {
+			const known = base.get(e.id);
+			if (known) {
+				routes.push({
+					edge: e.id,
+					points: known
+				});
+				continue;
+			}
+			const ps = placePlug(s, e.source, center(t.box));
+			const pt = placePlug(t, e.target, center(s.box));
+			routes.push({
+				edge: e.id,
+				points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+			});
+			continue;
+		}
+		const out = [];
+		let at;
+		for (const { h, m } of trip) {
+			const piece = slice(lines[h], m.on, m.off);
+			const first = piece[0];
+			if (at === void 0) {
+				if (!plugAt(s, e.source, first)) {
+					const ps = placePlug(s, e.source, first);
+					out.push(...ways.fromPlug(ps, first) ?? [ps.point, first]);
+				}
+			} else if (dist(at, first) > SAME) {
+				const way = ways.corners.path(at, first);
+				out.push(...way ? ways.corners.pull(way) : [at, first]);
+			}
+			out.push(...piece);
+			at = piece[piece.length - 1];
+		}
+		if (at !== void 0 && !plugAt(t, e.target, at)) {
+			const pt = placePlug(t, e.target, at);
+			out.push(...ways.toPlug(at, pt) ?? [at, pt.point]);
+		}
+		routes.push({
+			edge: e.id,
+			points: dedupe(out)
+		});
+	}
+	const routeOf = new Map(routes.map((r) => [r.edge, r]));
+	const runs = [];
+	plan.highways.forEach((h, hi) => {
+		const stops = lines[hi];
+		const usersOf = (k) => h.members.filter((m) => routeOf.has(m.edge) && Math.min(m.on, m.off) <= stops[k][0] && Math.max(m.on, m.off) >= stops[k + 1][0]).map((m) => m.edge).sort();
+		let k = 0;
+		while (k < stops.length - 1) {
+			const users = usersOf(k);
+			let end = k + 1;
+			while (end < stops.length - 1 && usersOf(end).join("\0") === users.join("\0")) end++;
+			const points = dedupe(stops.slice(k, end + 1).map(([, p]) => p));
+			k = end;
+			if (users.length < 2 || points.length < 2) continue;
+			const mine = users.map((id) => routeOf.get(id)).filter((r) => holds(r.points, points));
+			if (mine.length < 2) continue;
+			runs.push({
+				id: `r${runs.length}`,
+				key: h.key,
+				points,
+				edges: orderLanes(points, mine, options.laneOrder ?? "bundle")
+			});
+		}
+	});
+	return runs.length > 0 ? {
+		routes,
+		runs
+	} : { routes };
+}
+// src/highways/router.ts
+/** This function gives the options of the way finder in the options of a strategy: `margin` and `k`, when they are present. */
+function wayOptionsOf(options) {
+	const o = options;
+	return {
+		...typeof o.margin === "number" ? { margin: o.margin } : {},
+		...typeof o.k === "number" ? { k: o.k } : {}
+	};
+}
+/**
+* This function gives a router that runs a highway strategy and then `follow`. The strategy gets the graph without first routes.
+* The way finder of `follow` takes `margin` and `k` from the options of the strategy, and then from `followOptions`.
+* The router keeps the name and the `maxNodes` of the strategy.
+*/
+function highwayRouter(strategy, options, followOptions = {}) {
+	return {
+		name: strategy.name,
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		route: (graph) => follow(graph, strategy.run({ graph }, options), {
+			...followOptions,
+			...wayOptionsOf({
+				...strategy.defaults,
+				...options
+			})
+		})
+	};
+}
+/**
+* This function gives a router strategy that runs a highway strategy and then `follow`.
+* The router strategy has the name, the options and the schema of the highway strategy.
+* The benchmark and the screen race such a router with the other routers.
+*/
+function highwayRouterStrategy(strategy) {
+	return defineStrategy({
+		step: "router",
+		name: strategy.name,
+		describe: strategy.describe,
+		defaults: strategy.defaults,
+		...strategy.schema === void 0 ? {} : { schema: strategy.schema },
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		run: (graph, options) => follow(graph, strategy.run({ graph }, options), wayOptionsOf(options))
+	});
+}
 // src/bench/suite.ts
 const now = () => globalThis.performance?.now() ?? Date.now();
 /** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
@@ -10119,6 +10880,24 @@ const FRONT_OBJECTIVES = {
 			better: "min"
 		}
 	],
+	highway: [
+		{
+			key: "R1.perEdge",
+			better: "min"
+		},
+		{
+			key: "R5.median",
+			better: "min"
+		},
+		{
+			key: "B1.inkSaved",
+			better: "max"
+		},
+		{
+			key: "R4.turn",
+			better: "min"
+		}
+	],
 	room: [
 		{
 			key: "M1.area",
@@ -10210,18 +10989,23 @@ function curveRuns(graph, result, curves, options) {
 	const u = boardUnit(graph);
 	const routes = [];
 	const ids = [];
-	for (const r of result.routes) {
+	const board = options.lanes;
+	(board ? laneRoutes(board.graph, board.open, board.width, board.maxWidth) : result.routes).forEach((r, i) => {
 		const e = edges.get(r.edge);
 		const s = e && byId.get(e.source.node);
 		const t = e && byId.get(e.target.node);
-		if (!s || !t || r.points.length < 2) continue;
+		if (!s || !t || r.points.length < 2) return;
 		ids.push(r.edge);
-		routes.push({
-			points: r.points,
+		const normals = {
 			startNormal: SIDE_NORMAL[nearestSide(s.box, r.points[0])],
 			endNormal: SIDE_NORMAL[nearestSide(t.box, r.points[r.points.length - 1])]
+		};
+		routes.push({
+			points: r.points,
+			...normals,
+			...board ? { lane: i } : {}
 		});
-	}
+	});
 	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
 	return curves.map((curve) => {
 		const own = options.curveOptions?.[curve.name];
@@ -10230,7 +11014,11 @@ function curveRuns(graph, result, curves, options) {
 			points: r.points,
 			startNormal: r.startNormal,
 			endNormal: r.endNormal,
-			space
+			space,
+			...board && r.lane !== void 0 ? { lane: {
+				board,
+				index: r.lane
+			} } : {}
 		}, own));
 		const samples = drawn.map((d) => sampleCurve(d, .25));
 		const ms = now() - t0;
@@ -10362,8 +11150,8 @@ function groupRun(graph, strategy, options, change, at) {
 	};
 }
 /**
-* This function gives the options of a grouping rule on a fixture. The rule `keys` gets a key from the data of the edges:
-* the collection of the first edge into the node. A node without such an edge is a group alone.
+* This function gives the options of a grouping rule on a fixture. The rule `keys` gets the string `data.group` of the node.
+* A node without it gets a key from the data of the edges: the collection of the first edge into the node. A node without such an edge is a group alone.
 */
 function fixtureGroupOptions(strategy, graph) {
 	if (strategy !== "keys") return {};
@@ -10372,7 +11160,7 @@ function fixtureGroupOptions(strategy, graph) {
 		const c = e.data?.["collection"];
 		if (typeof c === "string" && !key.has(e.target.node)) key.set(e.target.node, c);
 	}
-	return { key: (n) => key.get(n.id) };
+	return { key: (n, i) => byDataGroup(n, i) ?? key.get(n.id) };
 }
 /**
 * This function starts the measure suite of MEAS1. The suite measures each strategy of each step on each seed of each fixture family.
@@ -10400,10 +11188,11 @@ function runSuite(options = {}) {
 	]);
 	const normals = new Set(options.normalCurves ?? ["spline"]);
 	const log = options.log ?? (() => {});
-	const fixtures = steps.has("router") || steps.has("group") ? (options.fixtures ?? FIXTURES).filter((f) => f.nodes <= max) : [];
+	const fixtures = steps.has("router") || steps.has("group") || steps.has("highway") ? (options.fixtures ?? FIXTURES).filter((f) => f.nodes <= max) : [];
 	const routers = steps.has("router") ? listStrategies(registry, "router").filter((s) => options.routers?.includes(s.name) ?? true) : [];
 	const curves = steps.has("curve") ? listStrategies(registry, "curve") : [];
 	const groups = steps.has("group") ? listStrategies(registry, "group") : [];
+	const highways = steps.has("highway") ? listStrategies(registry, "highway").map((s) => highwayRouterStrategy(s)) : [];
 	const rooms = listStrategies(registry, "room");
 	const rows = [];
 	const bench = [];
@@ -10455,6 +11244,38 @@ function runSuite(options = {}) {
 				normals
 			}).map((c) => c.row));
 		}
+		for (const strategy of highways) {
+			if (graph.nodes.length > (strategy.maxNodes ?? Infinity)) continue;
+			const router = asRouter(strategy);
+			const t0 = now();
+			const { row, result } = benchRun(router, spec.name, graph, 2, cellLimit);
+			const ms = now() - t0;
+			const t1 = now();
+			const values = routeMeasures(graph, result, row);
+			const measureMs = now() - t1;
+			let extraMs = 0;
+			if (graph.nodes.length <= stabilityMax) {
+				const t2 = now();
+				const s = routeStability(graph, result, router.route(change.graph), { seed });
+				extraMs = now() - t2;
+				values["Z10.mean"] = s.mean;
+				values["Z10.max"] = s.max;
+				values["Z10.moved"] = s.moved;
+			}
+			rows.push({
+				step: "highway",
+				fixture: spec.name,
+				seed: k,
+				strategy: strategy.name,
+				nodes: row.nodes,
+				edges: row.edges,
+				violations: row.violations + (row.deterministic ? 0 : 1),
+				ms,
+				measureMs,
+				extraMs,
+				values
+			});
+		}
 		for (const strategy of groups) {
 			const opts = fixtureGroupOptions(strategy.name, graph);
 			const changed = {
@@ -10553,7 +11374,7 @@ function runSuite(options = {}) {
 }
 /**
 * This function puts the rows of the suite in the order of one run. It sorts them by fixture family, then by seed.
-* In one seed, the routers come first, and the curves come after the router of the curves. The grouping rules and the room come last.
+* In one seed, the routers come first, and the curves come after the router of the curves. Then the highway strategies come, and the grouping rules and the room come last.
 * A name that is not in its list goes after the names of the list.
 * The workflow `Bench` uses it to join the reports of its parts.
 */
@@ -10571,8 +11392,9 @@ function orderSuiteRows(rows, options = {}) {
 	const rank = (r) => {
 		if (r.step === "router") return [0, 2 * place(routers, r.strategy) * (curves.length + 1)];
 		if (r.step === "curve") return [0, 2 * after * (curves.length + 1) + 1 + place(curves, r.strategy)];
-		if (r.step === "group") return [1, place(names("group"), r.strategy)];
-		return [2, r.strategy === "gutter" ? -1 : place(names("room"), r.strategy)];
+		if (r.step === "highway") return [1, place(names("highway"), r.strategy)];
+		if (r.step === "group") return [2, place(names("group"), r.strategy)];
+		return [3, r.strategy === "gutter" ? -1 : place(names("room"), r.strategy)];
 	};
 	return rows.map((row, i) => ({
 		row,
@@ -10695,7 +11517,7 @@ function ruleCounts(rows) {
 	}
 	return [...out.values()];
 }
-const fmt = (v, d = 3) => v === void 0 || Number.isNaN(v) ? "-" : Number.isInteger(v) ? String(v) : v.toFixed(d);
+const fmt$1 = (v, d = 3) => v === void 0 || Number.isNaN(v) ? "-" : Number.isInteger(v) ? String(v) : v.toFixed(d);
 /** The columns of the tables of `formatSuite`: the keys of the measures of each step. */
 const SUITE_COLUMNS = {
 	router: [
@@ -10713,6 +11535,18 @@ const SUITE_COLUMNS = {
 		"Z7.position",
 		"G8.treeCost"
 	],
+	highway: [
+		"R1.perEdge",
+		"R2.angle",
+		"R2.min",
+		"B1.inkSaved",
+		"R5.median",
+		"R5.q95",
+		"R4.turn",
+		"R11.q05",
+		"B4.ambiguity",
+		"Z10.moved"
+	],
 	curve: [
 		"C1.share",
 		"C1.max",
@@ -10753,11 +11587,11 @@ function formatSummaries(summaries, step, columns = SUITE_COLUMNS[step]) {
 		...summaries.filter((s) => s.step === step).map((s) => {
 			const cells = columns.map((c) => {
 				const m = s.measures[c];
-				return m && m.n > 0 ? `${fmt(m.median)} (${fmt(m.iqr)})` : "-";
+				return m && m.n > 0 ? `${fmt$1(m.median)} (${fmt$1(m.iqr)})` : "-";
 			});
 			if (step === "router") {
 				const c = s.measures["R1.crossings"];
-				cells.push(c && c.median > 0 ? fmt(c.iqr / c.median) : "-");
+				cells.push(c && c.median > 0 ? fmt$1(c.iqr / c.median) : "-");
 			}
 			return `| ${s.strategy} | ${s.fixture} | ${s.seeds} | ${s.violations} | ${cells.join(" | ")} |`;
 		})
@@ -11021,6 +11855,31 @@ function medianOf(values) {
 	const [a, b] = [s[mid - 1], s[mid]];
 	return a === b ? a : (a + b) / 2;
 }
+/**
+* This function gives the measures of the level links of a result: the links through a box (`Z3.through`) and the length of all links (`Z3.length`).
+* A result without a level with groups gives no measure.
+*/
+function levelLinkMeasures(result) {
+	const levels = (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1));
+	if (levels.length === 0) return {};
+	const length = levels.reduce((sum, l) => sum + l.links.reduce((s, k) => s + polylineLength(k.points), 0), 0);
+	return {
+		"Z3.through": sumFaults(measureLevelFaults(result)).through,
+		"Z3.length": length
+	};
+}
+/** This function gives the lanes of a result with each shared segment open. A result without shared segments gives `undefined`. */
+function laneBoard(result, lanes) {
+	const graph = segmentsOf(result);
+	const open = new Set(graph.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+	if (open.size === 0) return void 0;
+	return {
+		graph,
+		open,
+		width: lanes.width,
+		...lanes.maxWidth === void 0 ? {} : { maxWidth: lanes.maxWidth }
+	};
+}
 /** The steps that `compareStep` compares, in the order of the pipeline. */
 const COMPARE_STEPS = [
 	"group",
@@ -11029,7 +11888,7 @@ const COMPARE_STEPS = [
 ];
 /**
 * This function runs each strategy of one step on one graph and measures it with the measures of `runSuite`. Then it gives the Pareto front.
-* The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve.
+* The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve, or their lanes with the option `lanes`.
 * The step `group` routes the graph with `sections` on the tree of each grouping rule.
 *
 * The same graph and the same options give the same measures. Only the times change.
@@ -11060,6 +11919,7 @@ function compareStep(step, graph, options = {}) {
 			const { row, result } = benchRun(router, name, graph, 2);
 			const values = {
 				...routeMeasures(graph, result, row),
+				...levelLinkMeasures(result),
 				ink: row.quality.ink,
 				ms: row.ms
 			};
@@ -11081,6 +11941,7 @@ function compareStep(step, graph, options = {}) {
 	} else if (step === "curve") {
 		const result = asRouter(getStrategy(registry, "router", options.curveRouter ?? "corners")).route(graph);
 		const u = boardUnit(graph);
+		const lanes = options.lanes && laneBoard(result, options.lanes);
 		rows = curveRuns(graph, result, listStrategies(registry, "curve"), {
 			...at,
 			smooth: /* @__PURE__ */ new Set([
@@ -11092,7 +11953,8 @@ function compareStep(step, graph, options = {}) {
 				"highway"
 			]),
 			normals: /* @__PURE__ */ new Set(["spline"]),
-			curveOptions: own
+			curveOptions: own,
+			...lanes ? { lanes } : {}
 		}).map(({ row, drawn, edges }) => {
 			const peaks = drawn.map((d) => peakCurvature(d) * u);
 			const values = {
@@ -11151,6 +12013,1442 @@ function compareStep(step, graph, options = {}) {
 		excluded: rows.filter((r) => !fair.includes(r)).map((r) => r.strategy)
 	};
 }
-export { BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BUILT_IN_STRATEGIES, CAP_SWEEP, CASES, CLEARANCE_CAP, COMPARE_STEPS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, FIXTURES, FRONT_OBJECTIVES, GROWTH_SWEEP, Grid, KD_DEFAULTS, KENDALL_EXACT, LANE_ORDERS, OUTSIDE_SLACK, Obstacles, PICK, PROPOSED_RULES, ROOM_FAMILIES, ROUTERS, SECTION_DEFAULTS, SIDE_NORMAL, SLACK_SWEEP, SPACING_LIMIT, STEPS, STRATEGIES, STRETCH_SWEEP, SUITE_COLUMNS, SoftGraph, TOLERANCE, WayFinder, adjustedRandIndex, allSections, ambiguity, arcCurve, asRouter, backtrackOf, balance, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, bendCount, bendingEnergy, boardGaps, boardUnit, boxExit, boxesOverlap, buildSections, byCollection, byDataGroup, capSettings, center, changeGraph, checkLevels, checkOptions, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, compareStep, cornersRouter, countCrossings, countOverlaps, createRegistry, crossesItself, crossingAngle, crossingAngles, cubicAt, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, cutGroups, cutShare, defineStrategy, denseGroupsBoard, detourSpread, dist, distinctPoints, dominates, drawnSegments, familySeed, farLevel, findStrategy, fixedPortPoint, fixtureGroupOptions, formatBendRoom, formatCurves, formatFaults, formatFronts, formatHighways, formatLevelRoom, formatLevels, formatMeasureTime, formatRoom, formatRules, formatSections, formatSummaries, formatTable, frechet, g1Defect, g2Defect, gapLanes, getStrategy, goesOutAndBack, groupEdges, groupRun, groupSettings, groupStability, groupStrategies, growthSettings, hasCusp, highwayCurve, highwayCurves, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, itemSizes, jogPeaks, joinReports, kdGroups, kendallTau, keyGroups, keyedSections, laneOrder, laneRoutes, laneSettings, leafGroups, levelCut, levelGrouping, levelMeasures, levelPairs, levelRoom, listOptions, listStrategies, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, modularity, nearestSide, nestedGridBoard, nestingFaults, nodeIndex, offsetPolyline, openGaps, optionDefaults, orderChanges, orderLanes, orderRows, orderStability, orderSuiteRows, packedGridBoard, paretoFront, passSettings, pathPoints, peakCurvature, pickLevel, placePlug, plugSpacing, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, positionStability, pullApart, quadtreeGroups, quantile, register, rng, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roundCorners, roundedCurve, routeMeasures, routeStability, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runSuite, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, slackSettings, smoothCurve, splineCurve, splitPoint, straightCurve, straightRouter, stretchSettings, suiteFronts, sumFaults, summarize, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, toSvgPath, totalTurn, treeCost, treeDepth, trunksRouter, turns, withBends };
+// src/bench/screen/hash.ts
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+/** This function gives the bytes of a string in UTF-8. */
+function utf8(text) {
+	const out = [];
+	for (const ch of text) {
+		const c = ch.codePointAt(0);
+		if (c < 128) out.push(c);
+		else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return Uint8Array.from(out);
+}
+/** This function gives the SHA-256 digest of a string, as 64 lowercase hex characters. It encodes the string in UTF-8. */
+function sha256Hex(text) {
+	const bytes = utf8(text);
+	const bits = bytes.length * 8;
+	const total = Math.ceil((bytes.length + 9) / 64) * 64;
+	const data = new Uint8Array(total);
+	data.set(bytes);
+	data[bytes.length] = 128;
+	const view = new DataView(data.buffer);
+	view.setUint32(total - 8, Math.floor(bits / 4294967296));
+	view.setUint32(total - 4, bits >>> 0);
+	const h = [
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	];
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	const rotr = (x, n) => x >>> n | x << 32 - n;
+	for (let off = 0; off < total; off += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + 4 * i);
+		for (let i = 16; i < 64; i++) {
+			const a = w[i - 15];
+			const b = w[i - 2];
+			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
+			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let [a, b, c, d, e, f, g, k] = h;
+		for (let i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = k + s1 + ch + K[i] + w[i] >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			k = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		h[0] = h[0] + a >>> 0;
+		h[1] = h[1] + b >>> 0;
+		h[2] = h[2] + c >>> 0;
+		h[3] = h[3] + d >>> 0;
+		h[4] = h[4] + e >>> 0;
+		h[5] = h[5] + f >>> 0;
+		h[6] = h[6] + g >>> 0;
+		h[7] = h[7] + k >>> 0;
+	}
+	return h.map((x) => x.toString(16).padStart(8, "0")).join("");
+}
+/**
+* This function writes a value as canonical JSON: the keys of each object in sorted order, and no whitespace.
+* It drops a key whose value is `undefined`, as `JSON.stringify` does.
+*/
+function canonicalJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map((v) => v === void 0 ? "null" : canonicalJson(v)).join(",")}]`;
+	const o = value;
+	return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(",")}}`;
+}
+/**
+* This function gives the hash of a JSON document: the first 16 hex characters of the SHA-256 of its canonical JSON.
+* The document does not include its own field `hash`. The function removes that field before it calculates the hash.
+*/
+function documentHash(value) {
+	const { hash: _hash, ...rest } = value;
+	return sha256Hex(canonicalJson(rest)).slice(0, 16);
+}
+/** This function gives the 32-bit FNV-1a hash of the UTF-8 bytes of a text, as an unsigned integer. */
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (const byte of utf8(text)) {
+		h ^= byte;
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+/** This function gives the seed of one step of a generator: `fnv1a32("<seed>:<step>")`. */
+function stepSeed(seed, step) {
+	return fnv1a32(`${seed}:${step}`);
+}
+/** This function gives the generator `mulberry32` for a seed. Each call gives the next number from 0 to below 1. */
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** This function rounds a number to 3 decimals, as the files of a corpus keep it. The value `-0` becomes `0`. */
+function round3(value) {
+	const r = Math.round(value * 1e3) / 1e3;
+	return r === 0 ? 0 : r;
+}
+// src/bench/screen/forms.ts
+const TO_FILE = {
+	north: "top",
+	east: "right",
+	south: "bottom",
+	west: "left"
+};
+const TO_MODEL = {
+	top: "north",
+	right: "east",
+	bottom: "south",
+	left: "west"
+};
+/** This function gives the side of a box that holds a point, relative to the top-left corner of the box. */
+function sideAt(p, w, h) {
+	return [
+		["top", Math.abs(p.y)],
+		["right", Math.abs(w - p.x)],
+		["bottom", Math.abs(h - p.y)],
+		["left", Math.abs(p.x)]
+	].reduce((a, b) => b[1] < a[1] ? b : a)[0];
+}
+/** This function gives 0 for -0, because JSON writes -0 as 0. Then a file and the graph that it comes from hold the same numbers. */
+const num = round3;
+function portToFile(p, n) {
+	const side = p.side ? TO_FILE[p.side] : p.at ? sideAt(p.at, n.box.w, n.box.h) : void 0;
+	return {
+		id: p.id,
+		...side ? { side } : {},
+		...p.at ? {
+			x: num(p.at.x),
+			y: num(p.at.y)
+		} : {}
+	};
+}
+function portToModel(p) {
+	if (p.x !== void 0 && p.y !== void 0) return {
+		id: p.id,
+		at: {
+			x: p.x,
+			y: p.y
+		}
+	};
+	return {
+		id: p.id,
+		...p.side ? { side: TO_MODEL[p.side] } : {}
+	};
+}
+/**
+* This function writes a graph as an input file of the form `layout-input/1`, with its hash.
+* A fixed plug gets `x`, `y` and the side that holds it. `inputGraph` reads the file back.
+*/
+function graphInput(graph, head) {
+	const boxes = graph.nodes.map((n) => ({
+		id: n.id,
+		w: num(n.box.w),
+		h: num(n.box.h),
+		x: num(n.box.x),
+		y: num(n.box.y),
+		...n.ports ? { ports: n.ports.map((p) => portToFile(p, n)) } : {},
+		...n.data ? { data: n.data } : {}
+	}));
+	const edges = graph.edges.map((e) => ({
+		id: e.id,
+		source: e.source.node,
+		target: e.target.node,
+		...e.source.port !== void 0 ? { sourcePort: e.source.port } : {},
+		...e.target.port !== void 0 ? { targetPort: e.target.port } : {},
+		...e.data ? { data: e.data } : {}
+	}));
+	const body = {
+		schema: "layout-input/1",
+		id: head.id,
+		set: head.set,
+		family: head.family,
+		seed: head.seed,
+		...head.base !== void 0 ? { base: head.base } : {},
+		...head.change !== void 0 ? { change: head.change } : {},
+		...head.step !== void 0 ? { step: head.step } : {},
+		source: head.source ?? "made-up",
+		generator: head.generator ?? null,
+		...head.cell !== void 0 ? { cell: head.cell } : {},
+		boxes,
+		edges
+	};
+	return {
+		...body,
+		hash: documentHash(body)
+	};
+}
+/**
+* This function gives the bounding box of a region: the smallest box that holds it.
+*/
+function regionBounds(region) {
+	if (region.kind === "rect") return {
+		x: region.x,
+		y: region.y,
+		w: region.w,
+		h: region.h
+	};
+	if (region.kind === "circle") return {
+		x: region.cx - region.r,
+		y: region.cy - region.r,
+		w: 2 * region.r,
+		h: 2 * region.r
+	};
+	if (region.kind === "ellipse") return {
+		x: region.cx - region.rx,
+		y: region.cy - region.ry,
+		w: 2 * region.rx,
+		h: 2 * region.ry
+	};
+	const xs = region.points.map((p) => p[0]);
+	const ys = region.points.map((p) => p[1]);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		w: Math.max(...xs) - x,
+		h: Math.max(...ys) - y
+	};
+}
+/**
+* This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
+* Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
+* The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
+* A box without `x` and `y` is an error.
+*/
+function inputGraph(input) {
+	const nodes = input.boxes.map((b) => {
+		if (b.x === void 0 || b.y === void 0) throw new Error(`The box "${b.id}" of the input "${input.id}" has no position. The router needs a placed input.`);
+		return {
+			id: b.id,
+			box: {
+				x: b.x,
+				y: b.y,
+				w: b.w,
+				h: b.h
+			},
+			...b.ports ? { ports: b.ports.map(portToModel) } : {},
+			...b.data ? { data: b.data } : {}
+		};
+	});
+	for (const o of input.obstacles ?? []) nodes.push({
+		id: o.id,
+		box: regionBounds(o.region)
+	});
+	return {
+		nodes,
+		edges: input.edges.map((e) => ({
+			id: e.id,
+			source: {
+				node: e.source,
+				...e.sourcePort !== void 0 ? { port: e.sourcePort } : {}
+			},
+			target: {
+				node: e.target,
+				...e.targetPort !== void 0 ? { port: e.targetPort } : {}
+			},
+			...e.data ? { data: e.data } : {}
+		}))
+	};
+}
+/**
+* This function writes an input file as text: the keys in sorted order, and one box or one edge on each line.
+* `JSON.parse` of the text gives the input again.
+*/
+function formatInput(input) {
+	const o = input;
+	return `{\n${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => {
+		const v = o[k];
+		if (Array.isArray(v)) return `  ${JSON.stringify(k)}: [${v.length === 0 ? "]" : `\n${v.map((x) => `    ${canonical(x)}`).join(",\n")}\n  ]`}`;
+		return `  ${JSON.stringify(k)}: ${canonical(v)}`;
+	}).join(",\n")}\n}\n`;
+}
+/** This function writes a value as canonical JSON with a space after each colon and comma, for a line of a file. */
+function canonical(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(canonical).join(", ")}]`;
+	const o = value;
+	return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}: ${canonical(o[k])}`).join(", ")}}`;
+}
+/** This function writes records as JSON Lines: one record on each line. */
+function recordLines(records) {
+	return records.map((r) => JSON.stringify(r) + "\n").join("");
+}
+/** This function reads JSON Lines. It ignores an empty line. */
+function parseLines(text) {
+	return text.split(/\r?\n/).filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+}
+/**
+* This function gives a copy of a value that JSON keeps.
+* A function becomes the text `function:<name>`, and a number that is not finite becomes its text.
+*/
+function jsonSafe(value) {
+	if (typeof value === "function") return `function:${value.name || "anonymous"}`;
+	if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(jsonSafe);
+	if (value instanceof Set) return [...value].map(jsonSafe);
+	if (value instanceof Map) return Object.fromEntries([...value].map(([k, v]) => [String(k), jsonSafe(v)]));
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = jsonSafe(v);
+	return out;
+}
+/**
+* The measures of the records of the stage `route`, with the placement dependence of each one.
+* A joint harness that moves the boxes and routes the edges reads `placementDependent`.
+* It compares a measure with the value `true` only between runs on the same input.
+*/
+const MEASURES = Object.freeze([
+	[
+		"R1.crossings",
+		"R1",
+		"route.crossings",
+		"count",
+		"lower",
+		true
+	],
+	[
+		"R1.perEdge",
+		"R1",
+		"route.crossings.per-edge",
+		"count for each edge",
+		"lower",
+		true
+	],
+	[
+		"R2.angle",
+		"R2",
+		"route.crossing-angle.mean",
+		"0 to 1",
+		"higher",
+		true
+	],
+	[
+		"R2.min",
+		"R2",
+		"route.crossing-angle.min",
+		"degrees",
+		"higher",
+		true
+	],
+	[
+		"R3.bends",
+		"R3",
+		"route.bends",
+		"count for each route",
+		"lower",
+		false
+	],
+	[
+		"R4.turn",
+		"R4",
+		"route.turn.mean",
+		"half turns for each route",
+		"lower",
+		false
+	],
+	[
+		"R4.max",
+		"R4",
+		"route.turn.max",
+		"degrees",
+		"lower",
+		false
+	],
+	[
+		"R5.median",
+		"R5",
+		"route.detour.median",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"R5.q95",
+		"R5",
+		"route.detour.q95",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"R5.mean",
+		"R5",
+		"route.detour.mean",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"R6.worstDetour",
+		"R6",
+		"route.detour.max",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"R7.backtrack",
+		"R7",
+		"route.backtrack",
+		"0 to 1",
+		"lower",
+		false
+	],
+	[
+		"R8.clearance",
+		"R8",
+		"route.clearance.mean",
+		"units",
+		"higher",
+		true
+	],
+	[
+		"R8.tight",
+		"R8",
+		"route.clearance.tight",
+		"0 to 1",
+		"lower",
+		true
+	],
+	[
+		"R9.through",
+		"R9",
+		"route.through",
+		"count",
+		"lower",
+		true
+	],
+	[
+		"R10.plugAngle",
+		"R10",
+		"route.plug-angle",
+		"degrees",
+		"lower",
+		false
+	],
+	[
+		"R11.min",
+		"R11",
+		"route.plug-spacing.min",
+		"0 to 1",
+		"higher",
+		true
+	],
+	[
+		"R11.q05",
+		"R11",
+		"route.plug-spacing.q05",
+		"0 to 1",
+		"higher",
+		true
+	],
+	[
+		"R13.outside",
+		"R13",
+		"route.outside",
+		"count",
+		"lower",
+		false
+	],
+	[
+		"R15.inflections",
+		"R15",
+		"route.inflections",
+		"count for each route",
+		"lower",
+		false
+	],
+	[
+		"ink",
+		"R1",
+		"route.ink",
+		"units",
+		"lower",
+		true
+	],
+	[
+		"B1.inkSaved",
+		"B1",
+		"route.bundle.ink-saved",
+		"0 to 1",
+		"higher",
+		false
+	],
+	[
+		"B4.ambiguity",
+		"B4",
+		"route.bundle.ambiguity",
+		"0 to 1",
+		"lower",
+		false
+	],
+	[
+		"Z10.mean",
+		"Z10",
+		"route.stability.mean",
+		"units of the board",
+		"lower",
+		false
+	],
+	[
+		"Z10.max",
+		"Z10",
+		"route.stability.max",
+		"units of the board",
+		"lower",
+		false
+	],
+	[
+		"Z10.moved",
+		"Z10",
+		"route.stability.moved",
+		"0 to 1",
+		"lower",
+		false
+	],
+	[
+		"Z10.base.mean",
+		"Z10",
+		"route.stability.base.mean",
+		"units of the board",
+		"lower",
+		false
+	],
+	[
+		"Z10.base.max",
+		"Z10",
+		"route.stability.base.max",
+		"units of the board",
+		"lower",
+		false
+	],
+	[
+		"Z10.base.moved",
+		"Z10",
+		"route.stability.base.moved",
+		"0 to 1",
+		"lower",
+		false
+	],
+	[
+		"level-nesting",
+		"Z6",
+		"route.level.nesting",
+		"count",
+		"lower",
+		false
+	],
+	[
+		"Z3.through",
+		"Z3",
+		"route.level.through",
+		"count",
+		"lower",
+		true
+	],
+	[
+		"Z3.length",
+		"Z3",
+		"route.level.link-length",
+		"units",
+		"lower",
+		true
+	],
+	[
+		"Z4.farItems",
+		"Z4",
+		"route.level.far-items",
+		"count",
+		"lower",
+		true
+	],
+	[
+		"Z7.position",
+		"Z7",
+		"route.level.position",
+		"no unit",
+		"lower",
+		true
+	],
+	[
+		"Z8.order",
+		"Z8",
+		"route.level.order",
+		"-1 to 1",
+		"higher",
+		true
+	],
+	[
+		"G1.modularity",
+		"G1",
+		"route.group.modularity",
+		"-0.5 to 1",
+		"higher",
+		true
+	],
+	[
+		"G2.cut",
+		"G2",
+		"route.group.cut",
+		"0 to 1",
+		"lower",
+		true
+	],
+	[
+		"G6.balance",
+		"G6",
+		"route.group.balance",
+		"0 to 1",
+		"higher",
+		true
+	],
+	[
+		"G8.treeCost",
+		"G8",
+		"route.group.tree-cost",
+		"0 to 1",
+		"lower",
+		true
+	],
+	[
+		"G9.ari",
+		"G9",
+		"route.group.stability",
+		"-1 to 1",
+		"higher",
+		true
+	],
+	[
+		"C1.max",
+		"C1",
+		"route.curve.c1.max",
+		"degrees",
+		"lower",
+		false
+	],
+	[
+		"C1.share",
+		"C1",
+		"route.curve.c1.share",
+		"0 to 1",
+		"lower",
+		false
+	],
+	[
+		"C2.median",
+		"C2",
+		"route.curve.c2.median",
+		"no unit",
+		"lower",
+		false
+	],
+	[
+		"C2.max",
+		"C2",
+		"route.curve.c2.max",
+		"no unit",
+		"lower",
+		false
+	],
+	[
+		"C3.median",
+		"C3",
+		"route.curve.c3.median",
+		"no unit",
+		"lower",
+		false
+	],
+	[
+		"C3.q95",
+		"C3",
+		"route.curve.c3.q95",
+		"no unit",
+		"lower",
+		false
+	],
+	[
+		"C5.peak",
+		"C5",
+		"route.curve.c5.peak",
+		"curvature times the unit of the board",
+		"lower",
+		false
+	],
+	[
+		"C6.length",
+		"C6",
+		"route.curve.c6.length",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"curve-clear",
+		"C7",
+		"route.curve.rule.clear",
+		"count",
+		"lower",
+		false
+	],
+	[
+		"curve-ends",
+		"C10",
+		"route.curve.rule.ends",
+		"count",
+		"lower",
+		false
+	],
+	[
+		"curve-g1",
+		"C1",
+		"route.curve.rule.g1",
+		"count",
+		"lower",
+		false
+	],
+	[
+		"curve-simple",
+		"C9",
+		"route.curve.rule.simple",
+		"count",
+		"lower",
+		false
+	]
+].map(([key, id, name, unit, better, placementDependent]) => Object.freeze({
+	key,
+	id,
+	name,
+	unit,
+	better,
+	placementDependent
+})));
+const BY_KEY = new Map(MEASURES.map((m) => [m.key, m]));
+const BY_NAME = new Map(MEASURES.map((m) => [m.name, m]));
+/** This function gives the measure of a key of `runSuite` or `compareStep`, or `undefined` for a key that is not in `MEASURES`. */
+function measureByKey(key) {
+	return BY_KEY.get(key);
+}
+/** This function gives the measure of a name of a record, or `undefined` for a name that is not in `MEASURES`. */
+function measureByName(name) {
+	return BY_NAME.get(name);
+}
+/** This function gives the name of a key in a record. A key that is not in `MEASURES` gets the name `route.other.<key>`. */
+function measureName(key) {
+	return BY_KEY.get(key)?.name ?? `route.other.${key.toLowerCase()}`;
+}
+/** This function gives the objectives of a Pareto front by the names of a record, from objectives by the keys of `runSuite`. */
+function namedObjectives(objectives) {
+	return objectives.map((o) => ({
+		key: measureName(o.key),
+		better: o.better
+	}));
+}
+// src/bench/screen/set.ts
+const fixture = (name) => FIXTURES.find((f) => f.name === name);
+const DENSE = {
+	name: "dense-groups",
+	kind: "clustered",
+	nodes: 150,
+	edgesPerNode: 2,
+	seed: 3
+};
+const PACKED = {
+	cols: 12,
+	rows: 8,
+	long: 48
+};
+/** This function gives a family of `makeFixture`. The member `k` has the seed `familySeed(spec, k)`, as in `runSuite`. */
+function fixtureFamily(spec, shows, seeds, cell) {
+	const { name, seed: _seed, ...params } = spec;
+	return {
+		name,
+		shows,
+		seeds,
+		cell,
+		make: (k) => makeFixture({
+			...spec,
+			seed: familySeed(spec, k)
+		}),
+		generator: (k) => ({
+			name: "fixture",
+			version: 1,
+			params,
+			seed: familySeed(spec, k)
+		})
+	};
+}
+/** The cell dimensions that each family of `screen-v1` shares. */
+const BASE = {
+	containerSize: "freeAspect",
+	containerShape: "rect",
+	obstacles: "none",
+	mode: "offline",
+	groups: "none"
+};
+/**
+* The screen set `screen-v1`: 14 boards of made-up data from 10 to 150 nodes. Each family shows a known hard case.
+* The seed 0 of each family is the fixture or the case board of the benchmark. The seed `k` of a fixture family is `familySeed(spec, k)`, as in `runSuite`.
+* The generators wrap the fixtures and the case boards without a change to their output.
+* This set does not change. The tests compare it with the files in `corpus/screen-v1`.
+*/
+const SCREEN_V1 = {
+	id: "screen-v1",
+	families: [
+		fixtureFamily(fixture("tiny-uniform"), "A tiny board: the cost of a strategy at its start.", 3, {
+			...BASE,
+			count: "10",
+			edgeDensity: "medium",
+			edgeShape: "random",
+			ports: "free"
+		}),
+		fixtureFamily(fixture("small-clustered"), "Clusters, and fixed plugs on 20% of the nodes.", 3, {
+			...BASE,
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "clustered",
+			ports: "fixed"
+		}),
+		fixtureFamily(DENSE, "Dense groups whose boxes overlap at the far view.", 3, {
+			...BASE,
+			count: "100",
+			edgeDensity: "medium",
+			edgeShape: "clustered",
+			ports: "free"
+		}),
+		{
+			name: "hub-chain",
+			shows: "A chain of hubs: routes climb away from their targets.",
+			seeds: 1,
+			cell: {
+				...BASE,
+				count: "100",
+				edgeDensity: "medium",
+				edgeShape: "hubChain",
+				ports: "free"
+			},
+			make: () => hubChainBoard(),
+			generator: () => ({
+				name: "case.hub-chain",
+				version: 1,
+				params: {},
+				seed: 3
+			})
+		},
+		{
+			name: "many-groups",
+			shows: "Many groups: level links go around the board.",
+			seeds: 1,
+			cell: {
+				...BASE,
+				count: "100",
+				edgeDensity: "medium",
+				edgeShape: "clustered",
+				ports: "free"
+			},
+			make: () => manyGroupsBoard(),
+			generator: () => ({
+				name: "case.many-groups",
+				version: 1,
+				params: {},
+				seed: 7
+			})
+		},
+		{
+			name: "packed-grid",
+			shows: "A packed grid: boxes touch, with no channel for the routes.",
+			seeds: 3,
+			cell: {
+				...BASE,
+				count: "100",
+				edgeDensity: "medium",
+				edgeShape: "longRange",
+				ports: "free"
+			},
+			make: (k) => packedGridBoard({
+				...PACKED,
+				seed: 11 + 1009 * k
+			}),
+			generator: (k) => ({
+				name: "case.packed-grid",
+				version: 1,
+				params: PACKED,
+				seed: 11 + 1009 * k
+			})
+		}
+	]
+};
+/** The screen sets by id. */
+const SCREEN_SETS = { [SCREEN_V1.id]: SCREEN_V1 };
+/** This function gives the id of the member `seed` of a family of a set: `<set>/<family>/s<seed>`. */
+function inputId(set, family, seed) {
+	return `${set}/${family}/s${seed}`;
+}
+/** This function gives the input files of a screen set, in the order of its families and seeds. Each file has its hash. */
+function screenInputs(set = SCREEN_V1) {
+	return set.families.flatMap((f) => Array.from({ length: f.seeds }, (_, k) => graphInput(f.make(k), {
+		id: inputId(set.id, f.name, k),
+		set: set.id,
+		family: f.name,
+		seed: k,
+		generator: f.generator(k),
+		cell: f.cell
+	})));
+}
+/** This function gives the manifest of a list of inputs. The inputs of one generator, version and parameters share one spec. */
+function corpusManifest(corpus, inputs) {
+	const specs = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const g = input.generator;
+		if (!g) continue;
+		const key = JSON.stringify([
+			g.name,
+			g.version,
+			g.params
+		]);
+		const spec = specs.get(key) ?? {
+			generator: g.name,
+			version: g.version,
+			params: g.params,
+			seeds: []
+		};
+		if (!spec.seeds.includes(g.seed)) spec.seeds.push(g.seed);
+		specs.set(key, spec);
+	}
+	return {
+		schema: "layout-corpus/1",
+		corpus,
+		specs: [...specs.values()],
+		inputs: inputs.map((i) => ({
+			id: i.id,
+			hash: i.hash,
+			cell: i.cell ?? {}
+		}))
+	};
+}
+// src/bench/screen/screen.ts
+/** The steps of the screen, in the order of the pipeline. */
+const SCREEN_STEPS = [
+	"group",
+	"router",
+	"highway",
+	"curve"
+];
+/** The routers that the screen of the step `highway` also runs by default. They are the baselines of the note on highways. */
+const HIGHWAY_BASE_ROUTERS = [
+	"corners",
+	"shared",
+	"trunks"
+];
+/** The hard rules of the routes of a router, or of a plan after `follow`. */
+const ROUTE_RULES = [
+	"complete",
+	"ends-at-plugs",
+	"fixed-plugs",
+	"no-pass-through",
+	"counts-sum",
+	"link-ends",
+	"bundle-trunk",
+	"run-shared",
+	"same-twice"
+];
+/** The hard rules of each step of the screen, in the order of the records. A good run has 0 for each rule. */
+const SCREEN_RULES = {
+	router: ROUTE_RULES,
+	highway: ROUTE_RULES,
+	group: [
+		"sections",
+		"counts-sum",
+		"link-ends",
+		"same-twice"
+	],
+	curve: ["same-twice"]
+};
+/** This function counts the violations of each rule, with 0 for each rule of `rules`. */
+function countRules(rules, violations) {
+	const out = Object.fromEntries(rules.map((r) => [r, 0]));
+	for (const v of violations) out[v.rule] = (out[v.rule] ?? 0) + 1;
+	return out;
+}
+/** This function gives the median of a list of numbers, or `NaN` for an empty list. */
+function median(values) {
+	return quantile(values, .5);
+}
+/** This function tells if a value meets a comparison with an expected value. */
+function meets(value, op, expected) {
+	if (op === "<") return value < expected;
+	if (op === "<=") return value <= expected;
+	if (op === ">") return value > expected;
+	if (op === ">=") return value >= expected;
+	return value === expected;
+}
+/** This function makes the registry of a screen. It refuses a strategy of another step, and a new strategy with the name of a built-in strategy. */
+function screenRegistry(step, strategies, baseline) {
+	const builtins = listStrategies(STRATEGIES, step);
+	const chosen = [];
+	for (const s of strategies) {
+		if (typeof s === "string") {
+			const known = builtins.find((b) => b.name === s);
+			if (!known) throw new Error(`There is no ${step} "${s}". The registry has ${builtins.map((b) => b.name).join(", ")}.`);
+			chosen.push(known);
+			continue;
+		}
+		if (s.step !== step) throw new Error(`The strategy "${s.name}" is of the step "${s.step}", not "${step}".`);
+		const known = builtins.find((b) => b.name === s.name);
+		if (known && known !== s) throw new Error(`The new ${step} "${s.name}" has the name of a built-in strategy. Give it another name.`);
+		chosen.push(s);
+	}
+	const candidates = new Set(chosen.map((s) => s.name));
+	const others = STEPS.filter((x) => x !== step).flatMap((x) => listStrategies(STRATEGIES, x));
+	const own = baseline ? [...builtins, ...chosen.filter((s) => !builtins.includes(s))] : chosen.filter((s, i) => chosen.indexOf(s) === i);
+	return {
+		registry: createRegistry([...others, ...own]),
+		candidates
+	};
+}
+/** This function tells if a step of the screen gives routes. The step `router` gives routes, and the step `highway` gives routes after `follow`. */
+const givesRoutes = (step) => step === "router" || step === "highway";
+/** This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router. */
+function rowValues(step, graph, row) {
+	const values = { ...row.values };
+	delete values["ms"];
+	if (givesRoutes(step) && row.result) {
+		const q = measureQuality(graph, row.result);
+		values["R3.bends"] = q.bends;
+		values["R8.clearance"] = q.clearance;
+		values["R8.tight"] = q.tight;
+		values["R10.plugAngle"] = q.plugAngle;
+		values["R15.inflections"] = q.inflections;
+	}
+	return values;
+}
+/** This function gives the hard rules of a row of `compareStep`, and tells if the row gave the same output two times. */
+function rowRules(step, graph, row, again) {
+	const rules = SCREEN_RULES[step];
+	if (givesRoutes(step)) {
+		const all = row.result ? checkProperties(graph, row.result, 1e6) : [];
+		const deterministic = row.violations === all.length;
+		return {
+			hard: {
+				...countRules(rules, all),
+				"same-twice": deterministic ? 0 : 1
+			},
+			deterministic
+		};
+	}
+	if (step === "group") {
+		const all = row.result ? checkLevels(graph, row.result.levels ?? [], 1e6) : [{ rule: "sections" }];
+		const deterministic = again !== void 0 && sameData(row.tree, again.tree) && sameData(row.result, again.result);
+		return {
+			hard: {
+				...countRules(rules, all),
+				"same-twice": deterministic ? 0 : 1
+			},
+			deterministic
+		};
+	}
+	const deterministic = again !== void 0 && sameData(row.curves, again.curves);
+	return {
+		hard: {
+			...countRules(rules, []),
+			"same-twice": deterministic ? 0 : 1
+		},
+		deterministic
+	};
+}
+/** This function keeps the finite values and gives them the names of a record. */
+function named(values) {
+	const out = {};
+	for (const [k, v] of Object.entries(values)) if (Number.isFinite(v)) out[measureName(k)] = v;
+	return out;
+}
+/**
+* This function screens strategies of one step on the inputs of a screen set. It is the cheap test of a new idea before a full build.
+* Each strategy runs on each input with `compareStep`, and each run gives one record of the form `layout-record/1`.
+* A strategy can be a name of the registry or a strategy object, for example from a prototype file. The registry does not change.
+*
+* The step `router` routes each input two times for the rule "same twice". The steps `group` and `curve` run each input two times for the same rule.
+*
+* The step `highway` makes the plan of each strategy and routes it with `follow`, two times. It also runs the routers of `baseRouters`.
+* An input with a `base` in the inputs also gets the measures `route.stability.base.*`: the routes on the variant against the routes on its base.
+* The same inputs and the same options give the same records. Only the times change.
+*/
+function screen(step, strategies = [], options = {}) {
+	const set = options.set ?? SCREEN_V1;
+	const screened = screenRegistry(step, strategies, options.baseline ?? true);
+	const candidates = screened.candidates;
+	const base = step === "highway" ? (options.baseRouters ?? HIGHWAY_BASE_ROUTERS).map((name) => getStrategy(STRATEGIES, "router", name)) : [];
+	const registry = step === "highway" ? createRegistry([...base, ...listStrategies(screened.registry, "highway").map((s) => highwayRouterStrategy(s))]) : screened.registry;
+	const compareAs = step === "highway" ? "router" : step;
+	const baseNames = new Set(base.map((s) => s.name));
+	const stepOf = (name) => baseNames.has(name) ? "router" : step;
+	const own = options.options ?? {};
+	const seed = options.seed ?? 1;
+	const log = options.log ?? (() => {});
+	const families = options.families;
+	const inputs = (options.inputs ?? screenInputs(set)).filter((i) => families?.includes(i.family) ?? true);
+	const bases = new Set(inputs.flatMap((i) => i.base !== void 0 ? [i.base] : []));
+	const byName = new Map(listStrategies(registry, compareAs).map((s) => [s.name, s]));
+	const records = [];
+	const comparisons = [];
+	const kept = /* @__PURE__ */ new Map();
+	const variants = [];
+	for (const input of inputs) {
+		const graph = inputGraph(input);
+		const compare = {
+			registry,
+			options: own,
+			seed,
+			name: input.id,
+			...options.curveRouter ? { curveRouter: options.curveRouter } : {}
+		};
+		const cmp = compareStep(compareAs, graph, compare);
+		const again = givesRoutes(step) ? void 0 : compareStep(compareAs, graph, compare);
+		comparisons.push(cmp);
+		log(`${input.id}: ${graph.nodes.length} nodes, ${graph.edges.length} edges, ${cmp.rows.map((r) => `${r.strategy} ${r.ms.toFixed(0)}`).join(", ")}`);
+		if (bases.has(input.id)) kept.set(input.id, {
+			graph,
+			results: new Map(cmp.rows.flatMap((r) => r.result ? [[r.strategy, r.result]] : []))
+		});
+		cmp.rows.forEach((row, i) => {
+			const strategy = byName.get(row.strategy);
+			const head = {
+				schema: "layout-record/1",
+				stage: "route",
+				step: stepOf(row.strategy),
+				strategy: row.strategy,
+				options: jsonSafe({
+					...strategy.defaults,
+					...own[row.strategy]
+				}),
+				corpus: input.set,
+				input: input.id,
+				inputHash: input.hash,
+				set: input.set,
+				seed: input.seed,
+				nodes: graph.nodes.length,
+				edges: graph.edges.length
+			};
+			const prediction = options.predictions?.find((p) => p.strategy === row.strategy && p.set === input.set && p.input === input.id)?.id;
+			const tail = {
+				...prediction !== void 0 ? { prediction } : {},
+				...options.commit !== void 0 ? { commit: options.commit } : {}
+			};
+			if (row.skipped !== void 0) {
+				records.push({
+					...head,
+					measures: {},
+					hard: {},
+					tolerance: { through: TOLERANCE },
+					deterministic: true,
+					ms: 0,
+					...tail,
+					skipped: row.skipped
+				});
+				return;
+			}
+			const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
+			const record = {
+				...head,
+				measures: named(rowValues(step, graph, row)),
+				hard,
+				tolerance: { through: TOLERANCE },
+				deterministic,
+				ms: row.ms,
+				...tail
+			};
+			records.push(record);
+			if (givesRoutes(step) && input.base !== void 0 && row.result) variants.push({
+				record,
+				base: input.base,
+				result: row.result
+			});
+		});
+	}
+	for (const v of variants) {
+		const base = kept.get(v.base);
+		const before = base?.results.get(v.record.strategy);
+		if (!base || !before) continue;
+		const s = routeStability(base.graph, before, v.result, { seed });
+		Object.assign(v.record.measures, named({
+			"Z10.base.mean": s.mean,
+			"Z10.base.max": s.max,
+			"Z10.base.moved": s.moved
+		}));
+	}
+	return {
+		records,
+		summary: summarizeScreen(records, comparisons, {
+			set: set.id,
+			step,
+			candidates,
+			...options.predictions ? { predictions: options.predictions } : {}
+		})
+	};
+}
+/** This function gives the summary of the records of a screen. */
+function summarizeScreen(records, comparisons, at) {
+	const objectives = namedObjectives(FRONT_OBJECTIVES[at.step]);
+	const names = [...new Set(records.map((r) => r.strategy))];
+	const total = (r) => Object.values(r.hard).reduce((n, v) => n + v, 0);
+	const floor = /* @__PURE__ */ new Map();
+	const best = /* @__PURE__ */ new Map();
+	for (const r of records) {
+		if (r.skipped !== void 0 || at.candidates.has(r.strategy)) continue;
+		if (total(r) >= (best.get(r.input) ?? Number.POSITIVE_INFINITY)) continue;
+		best.set(r.input, total(r));
+		floor.set(r.input, r.hard);
+	}
+	const overFloor = (r) => Object.entries(r.hard).reduce((n, [k, v]) => n + Math.max(0, v - (floor.get(r.input)?.[k] ?? 0)), 0);
+	const strategies = names.map((strategy) => {
+		const all = records.filter((r) => r.strategy === strategy);
+		const ran = all.filter((r) => r.skipped === void 0);
+		const hard = {};
+		for (const r of ran) for (const [k, v] of Object.entries(r.hard)) hard[k] = (hard[k] ?? 0) + v;
+		const keys = [...new Set(ran.flatMap((r) => Object.keys(r.measures)))];
+		const medians = Object.fromEntries(keys.map((k) => [k, median(ran.flatMap((r) => r.measures[k] === void 0 ? [] : [r.measures[k]]))]));
+		return {
+			strategy,
+			candidate: at.candidates.has(strategy),
+			runs: ran.length,
+			skipped: all.length - ran.length,
+			deterministic: ran.every((r) => r.deterministic),
+			hard,
+			hardTotal: Object.values(hard).reduce((s, v) => s + v, 0),
+			hardOverFloor: ran.reduce((n, r) => n + overFloor(r), 0),
+			medians,
+			ms: median(ran.map((r) => r.ms)),
+			onFront: comparisons.filter((c) => c.front.includes(strategy)).length
+		};
+	});
+	const fair = strategies.filter((s) => s.runs > 0 && s.hardOverFloor === 0 && s.deterministic);
+	const front = paretoFront(fair, (s) => Object.fromEntries(objectives.map((o) => [o.key, s.medians[o.key] ?? NaN])), objectives).map((s) => s.strategy);
+	const predictions = (at.predictions ?? []).map((p) => {
+		const op = p.op ?? (measureByName(p.measure)?.better === "higher" ? ">=" : "<=");
+		const values = records.filter((r) => r.strategy === p.strategy && r.set === p.set && r.skipped === void 0 && (p.input === void 0 || r.input === p.input)).flatMap((r) => r.measures[p.measure] === void 0 ? [] : [r.measures[p.measure]]);
+		const measured = values.length === 0 ? void 0 : p.input !== void 0 ? values[0] : median(values);
+		return {
+			...p,
+			op,
+			...measured === void 0 ? {} : {
+				measured,
+				met: meets(measured, op, p.expected)
+			}
+		};
+	});
+	return {
+		set: at.set,
+		step: at.step,
+		inputs: comparisons.length,
+		objectives,
+		strategies,
+		front,
+		excluded: strategies.filter((s) => !fair.includes(s)).map((s) => s.strategy),
+		predictions
+	};
+}
+const fmt = (v) => v === void 0 || Number.isNaN(v) ? "-" : Number.isInteger(v) ? String(v) : v.toFixed(3);
+/** This function writes the summary of a screen as Markdown: one row for each strategy, the front and the predictions. */
+function formatScreen(summary) {
+	const axes = summary.objectives.map((o) => `${o.key} ${o.better === "min" ? "↓" : "↑"}`);
+	const lines = [
+		`## Screen of the step \`${summary.step}\` on \`${summary.set}\``,
+		"",
+		`${summary.inputs} inputs, ${summary.strategies.length} strategies. Each cell of a measure is the median over the inputs.`,
+		"The floor of an input is the counts of the hard rules of the built-in strategy with the fewest breaks on that input.",
+		"",
+		`| strategy | new | runs | skipped | hard | over the floor | same twice | on the front of an input | ms | ${axes.join(" | ")} |`,
+		`|---|---|---:|---:|---:|---:|---|---:|---:|${axes.map(() => "---:").join("|")}|`,
+		...summary.strategies.map((s) => `| ${s.strategy} | ${s.candidate ? "yes" : ""} | ${s.runs} | ${s.skipped} | ${s.hardTotal} | ${s.hardOverFloor} | ${s.deterministic ? "yes" : "no"} | ${s.onFront} | ${fmt(s.ms)} | ${summary.objectives.map((o) => fmt(s.medians[o.key])).join(" | ")} |`),
+		"",
+		`Pareto front over the medians: ${summary.front.join(", ") || "-"}.`,
+		`Not on the front because of a break over the floor, no run or two different outputs: ${summary.excluded.join(", ") || "-"}.`
+	];
+	if (summary.predictions.length > 0) {
+		lines.push("", "| prediction | strategy | input | measure | expected | measured | met | reason |", "|---|---|---|---|---:|---:|---|---|");
+		for (const p of summary.predictions) lines.push(`| ${p.id} | ${p.strategy} | ${p.input ?? "median"} | ${p.measure} | ${p.op} ${fmt(p.expected)} | ${fmt(p.measured)} | ${p.met === void 0 ? "-" : p.met ? "yes" : "no"} | ${p.reason} |`);
+	}
+	return lines.join("\n") + "\n";
+}
+// src/bench/screen/generators.ts
+/** This function gives a whole number from `lo` to `hi`, both included, from a generator of random numbers. */
+function randomInt(r, lo, hi) {
+	return lo + Math.floor(r() * (hi - lo + 1));
+}
+/**
+* This function makes the input of the shared generator `rect-scattered`, version 1: a fixed rectangle container, scattered obstacles and boxes without positions.
+* The repository `packing` makes the same file, byte for byte. A test in each repository pins the hashes of the seeds 1, 2 and 3.
+* The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
+*/
+function rectScattered(seed, params, set = "xcheck-v1") {
+	let r = mulberry32(stepSeed(seed, "container"));
+	const w = randomInt(r, 600, 1e3);
+	const h = randomInt(r, 400, 800);
+	r = mulberry32(stepSeed(seed, "obstacles"));
+	const n = randomInt(r, 3, 8);
+	const obstacles = [];
+	for (let i = 0; i < n; i++) {
+		const ow = randomInt(r, 40, 160);
+		const oh = randomInt(r, 40, 160);
+		const x = randomInt(r, 0, w - ow);
+		const y = randomInt(r, 0, h - oh);
+		obstacles.push({
+			id: `o${i}`,
+			region: {
+				kind: "rect",
+				x,
+				y,
+				w: ow,
+				h: oh
+			}
+		});
+	}
+	r = mulberry32(stepSeed(seed, "boxes"));
+	const boxes = Array.from({ length: params.count }, (_, i) => {
+		const bw = randomInt(r, 20, 120);
+		const bh = randomInt(r, 20, 80);
+		return {
+			id: `b${i}`,
+			w: bw,
+			h: bh
+		};
+	});
+	const body = {
+		schema: "layout-input/1",
+		id: `${set}/rect-scattered/s${seed}`,
+		set,
+		family: "rect-scattered",
+		seed,
+		source: "made-up",
+		generator: {
+			name: "rect-scattered",
+			version: 1,
+			params: { count: params.count },
+			seed
+		},
+		container: {
+			w,
+			h,
+			fixed: "size"
+		},
+		obstacles,
+		boxes,
+		edges: []
+	};
+	return {
+		...body,
+		hash: documentHash(body)
+	};
+}
+export { BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BUILT_IN_STRATEGIES, CAP_SWEEP, CASES, CLEARANCE_CAP, COMPARE_STEPS, CORRIDOR_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, FIXTURES, FRONT_OBJECTIVES, GROWTH_SWEEP, Grid, HIGHWAY_BASE_ROUTERS, KD_DEFAULTS, KENDALL_EXACT, LANE_ORDERS, MEASURES, OUTSIDE_SLACK, Obstacles, PICK, PROPOSED_RULES, ROOM_FAMILIES, ROUTERS, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SECTION_DEFAULTS, SIDE_NORMAL, SLACK_SWEEP, SPACING_LIMIT, STEPS, STRATEGIES, STRETCH_SWEEP, SUITE_COLUMNS, SoftGraph, TOLERANCE, WayFinder, adjustedRandIndex, allSections, ambiguity, arcCurve, asRouter, backtrackOf, balance, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, bendCount, bendingEnergy, boardGaps, boardUnit, boxExit, boxesOverlap, buildSections, byCollection, byDataGroup, canonicalJson, capSettings, center, changeGraph, checkLevels, checkOptions, checkPlan, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, compareStep, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createRegistry, crossesItself, crossingAngle, crossingAngles, cubicAt, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, cutGroups, cutShare, defineStrategy, denseGroupsBoard, detourSpread, dist, distinctPoints, documentHash, dominates, drawnSegments, familySeed, farLevel, findStrategy, fixedPortPoint, fixtureGroupOptions, fnv1a32, follow, formatBendRoom, formatCurves, formatFaults, formatFronts, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, frechet, g1Defect, g2Defect, gapLanes, getStrategy, goesOutAndBack, graphInput, groupEdges, groupRun, groupSettings, groupStability, groupStrategies, growthSettings, hasCusp, highwayCurve, highwayCurves, highwayRouter, highwayRouterStrategy, highwayStrategies, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, inputGraph, inputId, itemSizes, jogPeaks, joinReports, jsonSafe, kdGroups, kendallTau, keyGroups, keyedSections, keysPlan, laneOrder, laneRoutes, laneSettings, leafGroups, lengthBetween, levelCut, levelGrouping, levelMeasures, levelPairs, levelRoom, listOptions, listStrategies, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, memberAt, minHash, modularity, mulberry32, namedObjectives, nearestSide, nestedGridBoard, nestingFaults, nodeIndex, offsetPolyline, openGaps, optionDefaults, orderChanges, orderLanes, orderRows, orderStability, orderSuiteRows, packedGridBoard, paretoFront, parseLines, passSettings, pathPoints, peakCurvature, pickLevel, placePlug, planOfResult, plugSpacing, plugsRouter, pointAt, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, positionStability, pullApart, quadtreeGroups, quantile, randomInt, recordLines, rectScattered, regionBounds, register, rng, roomDemand, roomLinks, roomOrderFaults, roomStrategies, round3, roundCorners, roundedCurve, routeMeasures, routeStability, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runSuite, sameData, sampleCurve, screen, screenInputs, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, sha256Hex, sharedRouter, sharedWaysPlan, sideAngle, sideToward, slackSettings, smoothCurve, splineCurve, splitPoint, stepSeed, straightCurve, straightRouter, stretchSettings, suiteFronts, sumFaults, summarize, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, toSvgPath, totalTurn, treeCost, treeDepth, trunksRouter, turns, utf8, withBends };
 
 //# sourceMappingURL=index.js.map