@mark1russell7/highways 0.4.0 → 0.4.1

package/build/index.js

@@ -427,7 +427,7 @@ const COLLECTIONS = [
 	"scores",
 	"teams"
 ];
-const SIDES$1 = [
+const SIDES$2 = [
 	"north",
 	"east",
 	"south",
@@ -496,7 +496,7 @@ function makeFixture(spec) {
 		clusterOf.push(cluster);
 		const id = `n${nodes.length}`;
 		if (R() < (spec.fixedPorts ?? 0)) {
-			const s = SIDES$1[Math.floor(R() * 4)];
+			const s = SIDES$2[Math.floor(R() * 4)];
 			const t = .2 + .6 * R();
 			const at = s === "north" ? {
 				x: w * t,
@@ -1049,7 +1049,7 @@ function checkProperties(graph, result, limit = 100) {
 		}
 		for (const id of run.edges) {
 			const r = routes.get(id);
-			if (!r || !(holds$1(r.points, run.points) || holds$1(r.points, [...run.points].reverse()))) {
+			if (!r || !(holds$2(r.points, run.points) || holds$2(r.points, [...run.points].reverse()))) {
 				if (add({
 					rule: "run-shared",
 					edge: id,
@@ -1096,7 +1096,7 @@ function checkLevels(graph, levels, limit = 100) {
 			const s = boxOf.get(l.source);
 			const t = boxOf.get(l.target);
 			const p = l.points;
-			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
+			if (!s || !t || p.length < 2 || !onBoundary$1(p[0], s) || !onBoundary$1(p[p.length - 1], t)) {
 				if (add({
 					rule: "link-ends",
 					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
@@ -1107,12 +1107,12 @@ function checkLevels(graph, levels, limit = 100) {
 	return out;
 }
 /** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
-function onBoundary(p, b) {
+function onBoundary$1(p, b) {
 	const inner = inflate(b, -.5);
 	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
 }
 /** This function tells if the polyline `p` holds the points of `part` in a row. */
-function holds$1(p, part) {
+function holds$2(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;
@@ -2286,7 +2286,7 @@ function partBefore(P, Q) {
 		}
 	}
 }
-const byEdge = (P, Q) => P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
+const byEdge$1 = (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$3 || Math.abs(a.x - b.x) <= SAME$3 && a.y < b.y;
 /**
@@ -2323,14 +2323,14 @@ function orderLanes(run, routes, order = "run") {
 			else lost.push(r.edge);
 		}
 	}
-	if (order === "run") placed.sort((P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge(P, Q));
+	if (order === "run") placed.sort((P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge$1(P, Q));
 	else {
-		placed.sort(byEdge);
+		placed.sort(byEdge$1);
 		placed.sort((P, Q) => {
 			const after = partAfter(P, Q);
 			const before = partBefore(P, Q);
 			if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
-			return after?.side ?? before?.side ?? byEdge(P, Q);
+			return after?.side ?? before?.side ?? byEdge$1(P, Q);
 		});
 	}
 	return [...placed.map((x) => x.edge), ...lost.sort()];
@@ -4598,6 +4598,201 @@ function pickLevel(sizes, scale, options = PICK) {
 	for (let d = 0; d < n - 1; d++) if (sizes[d] * scale >= itemAt) pick = d;
 	return pick;
 }
+// src/plugs/justify.ts
+/**
+* Plug justification (WILD-002, with NAT-031): the plugs of one side keep their order and a minimum gap.
+* They move the least distance from their ideal places.
+*/
+/**
+* This function places `ideal.length` points on the segment from `lo` to `hi` of one side.
+* The points keep the order of their ideal places. Two neighbours are at least `gap` apart, or the side divided evenly when it is too short.
+* The sum of the squares of the moves is the least. The answer is exact: a fit by pool adjacent violators.
+*
+* The function `tie` orders two points with the same ideal place. The result is in the order of `ideal`.
+*/
+function justifyPlugs(ideal, lo, hi, gap, tie) {
+	const k = ideal.length;
+	if (k === 0) return [];
+	const order = ideal.map((_, i) => i).sort((a, b) => ideal[a] - ideal[b] || (tie ? tie(a) - tie(b) : 0) || a - b);
+	const s = k > 1 ? Math.max(0, Math.min(gap, (hi - lo) / (k - 1))) : 0;
+	const y = isotonic(order.map((j, i) => ideal[j] - i * s));
+	const top = Math.max(lo, hi - (k - 1) * s);
+	const out = new Array(k);
+	order.forEach((j, i) => {
+		out[j] = Math.max(lo, Math.min(top, y[i])) + i * s;
+	});
+	return out;
+}
+/** This function gives the non-decreasing sequence nearest to `v` in the sum of squares (pool adjacent violators). */
+function isotonic(v) {
+	const mean = [];
+	const size = [];
+	for (const x of v) {
+		mean.push(x);
+		size.push(1);
+		while (mean.length > 1 && mean[mean.length - 2] > mean[mean.length - 1]) {
+			const m = mean.pop();
+			const n = size.pop();
+			const i = mean.length - 1;
+			mean[i] = (mean[i] * size[i] + m * n) / (size[i] + n);
+			size[i] += n;
+		}
+	}
+	const out = [];
+	mean.forEach((m, i) => {
+		for (let j = 0; j < size[i]; j++) out.push(m);
+	});
+	return out;
+}
+// src/plugs/side.ts
+/**
+* Free plugs on a side (WILD-001): the search of a route starts from the whole free side, not from one point of it.
+* Thus the first leg goes straight out to the first corner of the way, and the plug is the foot of that leg.
+*/
+/** This function gives the free side of an end, or `undefined` when the plug of the end is fixed. */
+function freeSide(node, end, toward, inset) {
+	if (fixedPortPoint(node, end)) return void 0;
+	const side = (end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port))?.side ?? sideToward(node.box, toward);
+	const b = node.box;
+	const along = side === "east" || side === "west" ? "y" : "x";
+	const start = along === "y" ? b.y : b.x;
+	const len = along === "y" ? b.h : b.w;
+	const m = Math.min(inset, len / 4);
+	const at = side === "east" ? b.x + b.w : side === "west" ? b.x : side === "south" ? b.y + b.h : b.y;
+	const point = pointOnSide(b, side, toward, inset);
+	return {
+		node,
+		side,
+		normal: SIDE_NORMAL[side],
+		along,
+		at,
+		lo: start + m,
+		hi: start + len - m,
+		facing: {
+			point,
+			normal: SIDE_NORMAL[side]
+		}
+	};
+}
+/** This function gives the point of the side at `v` on the axis along the side. */
+function footAt(f, v) {
+	return f.along === "y" ? {
+		x: f.at,
+		y: v
+	} : {
+		x: v,
+		y: f.at
+	};
+}
+/**
+* This function gives the places that the search tries on one free side. A place is the out point of a plug on the side.
+* A place is also a corner in front of the side. The plug of a corner is the foot of the leg to it.
+*/
+function startsOf(ways, f, others, bend, most) {
+	const margin = ways.margin;
+	const pad = margin / 2;
+	const own = /* @__PURE__ */ new Set([f.node]);
+	const starts = [];
+	const out = (p) => ({
+		x: p.x + f.normal.x * margin,
+		y: p.y + f.normal.y * margin
+	});
+	const plugAt = (v) => ({
+		point: footAt(f, v),
+		normal: f.normal
+	});
+	starts.push({
+		plug: f.facing,
+		point: out(f.facing.point),
+		cost: margin
+	});
+	const mid = (f.lo + f.hi) / 2;
+	for (const v of [
+		f.lo,
+		mid,
+		f.hi,
+		...others
+	]) {
+		if (v < f.lo - 1e-9 || v > f.hi + 1e-9) continue;
+		const p = out(footAt(f, v));
+		if (!ways.obstacles.inside(p, 0, f.node)) starts.push({
+			plug: plugAt(v),
+			point: p,
+			cost: margin
+		});
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const v of [
+		f.lo,
+		mid,
+		f.hi,
+		f.facing.point[f.along]
+	]) for (const c of ways.corners.nearestVisible(out(footAt(f, v)), 16)) seen.add(c);
+	for (const c of seen) {
+		const q = ways.corners.points[c];
+		const across = f.along === "y" ? "x" : "y";
+		const depth = (q[across] - f.at) * f.normal[across];
+		if (depth < margin - 1e-9) continue;
+		const v = Math.max(f.lo, Math.min(f.hi, q[f.along]));
+		const foot = footAt(f, v);
+		const angle = Math.atan2(Math.abs(q[f.along] - v), depth);
+		if (angle > Math.PI / 4 + 1e-9) continue;
+		if (!ways.obstacles.clear(foot, q, pad, own)) continue;
+		starts.push({
+			plug: plugAt(v),
+			point: q,
+			cost: dist(foot, q) * (1 + bend * angle)
+		});
+	}
+	const best = /* @__PURE__ */ new Map();
+	for (const s of starts) {
+		const key = Math.round(s.plug.point[f.along] * 2);
+		const old = best.get(key);
+		if (!old || s.cost < old.cost) best.set(key, s);
+	}
+	const facing = f.facing.point[f.along];
+	return [...best.values()].sort((a, b) => Math.abs(a.plug.point[f.along] - facing) - Math.abs(b.plug.point[f.along] - facing)).slice(0, Math.max(1, most));
+}
+/**
+* This function places the two plugs of an edge with a free side. A fixed plug stays at its point.
+* The search (A*) starts from each place of the free side of the source. It ends at each place of the free side of the target.
+* The plugs are the places of the shortest way. Without a way, the plugs face the other end, as `placePlug` places them.
+*/
+function sidePlugs(ways, s, es, t, et, options = {}) {
+	const inset = options.inset ?? 6;
+	const ps = placePlug(s, es, center(t.box));
+	const pt = placePlug(t, et, center(s.box));
+	if (s === t) return [ps, pt];
+	const fs = freeSide(s, es, center(t.box), inset);
+	const ft = freeSide(t, et, center(s.box), inset);
+	if (!fs && !ft) return [ps, pt];
+	const bend = options.bend ?? 1;
+	const most = options.most ?? 16;
+	const fixed = (p) => [{
+		plug: p,
+		point: ways.out(p),
+		cost: ways.margin
+	}];
+	const facingPair = fs && ft && fs.along === ft.along && fs.normal.x === -ft.normal.x && fs.normal.y === -ft.normal.y;
+	const shared = (a, b, p) => {
+		if (!a) return [];
+		if (facingPair && b) {
+			const lo = Math.max(a.lo, b.lo);
+			const hi = Math.min(a.hi, b.hi);
+			return lo <= hi ? [
+				lo,
+				(lo + hi) / 2,
+				hi
+			] : [];
+		}
+		return [p.point[a.along]];
+	};
+	const from = fs ? startsOf(ways, fs, shared(fs, ft, pt), bend, most) : fixed(ps);
+	const to = ft ? startsOf(ways, ft, shared(ft, fs, ps), bend, most) : fixed(pt);
+	const way = ways.corners.pathAmong(from, to);
+	if (!way) return [ps, pt];
+	return [from[way.from].plug, to[way.to].plug];
+}
 // src/routers/corners.ts
 /**
 * This function makes a router that goes around the nodes.
@@ -4611,17 +4806,39 @@ function cornersRouter(options) {
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const routes = [];
+			if ((options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
+				for (const e of graph.edges) {
+					const s = byId.get(e.source.node);
+					const t = byId.get(e.target.node);
+					if (!s || !t) continue;
+					const ps = placePlug(s, e.source, center(t.box));
+					const pt = placePlug(t, e.target, center(s.box));
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+				}
+				return { routes };
+			}
+			const ends = [];
 			for (const e of graph.edges) {
 				const s = byId.get(e.source.node);
 				const t = byId.get(e.target.node);
 				if (!s || !t) continue;
-				const ps = placePlug(s, e.source, center(t.box));
-				const pt = placePlug(t, e.target, center(s.box));
-				routes.push({
-					edge: e.id,
-					points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
-				});
+				const [ps, pt] = options.plugs === "side" ? sidePlugs(ways, s, e.source, t, e.target) : [placePlug(s, e.source, center(t.box)), placePlug(t, e.target, center(s.box))];
+				ends.push([
+					e,
+					s,
+					t,
+					ps,
+					pt
+				]);
 			}
+			if ((options.plugGap ?? 0) > 0) spacePlugs(ends, options.plugGap);
+			for (const [e, s, t, ps, pt] of ends) routes.push({
+				edge: e.id,
+				points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+			});
 			return { routes };
 		}
 	};
@@ -4630,6 +4847,69 @@ function cornersRouter(options) {
 		maxNodes: options.maxNodes
 	};
 }
+/**
+* This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
+* The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
+*/
+function spacePlugs(ends, gap) {
+	const inset = 6;
+	const sides = /* @__PURE__ */ new Map();
+	ends.forEach(([e, s, t, ps, pt], i) => {
+		for (const [end, node, plug, other, k] of [[
+			e.source,
+			s,
+			ps,
+			pt,
+			3
+		], [
+			e.target,
+			t,
+			pt,
+			ps,
+			4
+		]]) {
+			if ((end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port))?.at !== void 0) continue;
+			const key = JSON.stringify([
+				node.id,
+				plug.normal.x,
+				plug.normal.y
+			]);
+			let side = sides.get(key);
+			if (!side) sides.set(key, side = {
+				node,
+				normal: plug.normal,
+				items: []
+			});
+			side.items.push([
+				i,
+				k,
+				other.point
+			]);
+		}
+	});
+	for (const { node, normal, items } of sides.values()) {
+		if (items.length < 2) continue;
+		const along = normal.x !== 0 ? "y" : "x";
+		const b = node.box;
+		const start = along === "y" ? b.y : b.x;
+		const len = along === "y" ? b.h : b.w;
+		const m = Math.min(inset, len / 4);
+		const placed = justifyPlugs(items.map(([i, k]) => ends[i][k].point[along]), start + m, start + len - m, gap, (j) => items[j][2][along]);
+		items.forEach(([i, k], j) => {
+			const old = ends[i][k];
+			ends[i][k] = {
+				point: along === "y" ? {
+					x: old.point.x,
+					y: placed[j]
+				} : {
+					x: placed[j],
+					y: old.point.y
+				},
+				normal: old.normal
+			};
+		});
+	}
+}
 // src/routers/plugs.ts
 /**
 * Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
@@ -4819,7 +5099,7 @@ const LEVEL_LINK_DEFAULTS = Object.freeze({
 	plugInset: 6,
 	throughCost: 8
 });
-const EPS$2 = 1e-6;
+const EPS$3 = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
 * and the points where the way turns back on itself.
@@ -4834,15 +5114,15 @@ function tidy(p) {
 function tidyPoints(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$2) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$3) continue;
 		while (out.length >= 2) {
 			const a = out[out.length - 2];
 			const b = out[out.length - 1];
 			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-			if (Math.abs(cross) > EPS$2 * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$3 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$2) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$3) continue;
 		out.push(q);
 	}
 	return out;
@@ -5097,7 +5377,7 @@ function facingPlugs(a, b, inset) {
 	}
 	return [plug(a, sa, center(b)), plug(b, sb, center(a))];
 }
-const SIDES = [
+const SIDES$1 = [
 	"north",
 	"east",
 	"south",
@@ -5116,7 +5396,7 @@ function sidePlug(ways, node, toward) {
 		y: toward.y - c.y
 	};
 	const facing = (s) => SIDE_NORMAL[s].x * d.x + SIDE_NORMAL[s].y * d.y;
-	const order = [...SIDES].sort((u, v) => facing(v) - facing(u));
+	const order = [...SIDES$1].sort((u, v) => facing(v) - facing(u));
 	const plug = (s) => {
 		const n = SIDE_NORMAL[s];
 		return {
@@ -5139,7 +5419,7 @@ function freePlugs(ways, node, inset) {
 	if (known) return known;
 	const b = node.box;
 	const out = [];
-	for (const side of SIDES) {
+	for (const side of SIDES$1) {
 		const n = SIDE_NORMAL[side];
 		const across = n.x === 0;
 		const lo = across ? b.x : b.y;
@@ -5215,7 +5495,7 @@ function freeSpans(lo, hi, covered) {
 		if (x >= hi) break;
 	}
 	if (x < hi) out.push([x, hi]);
-	return out.filter(([a, b]) => b - a > EPS$2);
+	return out.filter(([a, b]) => b - a > EPS$3);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -5347,7 +5627,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 		out.push(...step.legs);
 		const end = out[out.length - 1];
 		const before = out[out.length - 2];
-		axis = Math.abs(end.y - before.y) < EPS$2 ? "x" : Math.abs(end.x - before.x) < EPS$2 ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$3 ? "x" : Math.abs(end.x - before.x) < EPS$3 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -5357,7 +5637,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
 */
 function square(a, b, obstacles, pad, from, to) {
-	if (Math.abs(a.x - b.x) < EPS$2 || Math.abs(a.y - b.y) < EPS$2) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$3 || Math.abs(a.y - b.y) < EPS$3) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -5388,7 +5668,7 @@ const SECTIONS_DEFAULTS = Object.freeze({
 	stretchPad: 4,
 	hubSlack: 80
 });
-const dedupe$2 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+const dedupe$3 = (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 +5746,7 @@ function sectionsRouter(options) {
 				if (!p) {
 					const [from, to] = forward ? [a, b] : [b, a];
 					const way = corners.path(from, to);
-					p = dedupe$2(way ? corners.pull(way) : [from, to]);
+					p = dedupe$3(way ? corners.pull(way) : [from, to]);
 					pieces.set(key, p);
 				}
 				if (!used.includes(key)) used.push(key);
@@ -5623,6 +5903,136 @@ function makeLevels(graph, root, routeOf, options) {
 	}
 	return levels;
 }
+// src/routers/snell.ts
+/**
+* This function gives the Snell merge point of a route (NAT-035).
+* The route comes from `from`, reaches a run at `at` and goes on along the run to `next`.
+* A unit of length on the run costs `d` against 1 off it. The cheapest route meets the run at the angle `acos(d)`.
+* The function gives the distance from `at` toward `next` of that merge point. A value of 0 or less tells that the turn at `at` is already at most `acos(d)`.
+*/
+function snellOffset(from, at, next, d) {
+	const len = dist(at, next);
+	if (len <= 0) return 0;
+	const ux = (next.x - at.x) / len;
+	const uy = (next.y - at.y) / len;
+	const vx = from.x - at.x;
+	const vy = from.y - at.y;
+	const along = vx * ux + vy * uy;
+	const h = Math.abs(vx * uy - vy * ux);
+	const c = Math.min(.999, Math.max(0, d));
+	return along + h * c / Math.sqrt(1 - c * c);
+}
+/** The turn, in radians from 0 to π, at `b` on the way from `a` through `b` to `c`. */
+function turnAt(a, b, c) {
+	const ux = b.x - a.x;
+	const uy = b.y - a.y;
+	const vx = c.x - b.x;
+	const vy = c.y - b.y;
+	return Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+}
+/**
+* This function moves the merge points of the ways of the router `shared` to the Snell angle (NAT-035). It changes the ways in place.
+*
+* A way joins a run at a corner `J` when it comes alone from the corner before.
+* The link from `J` to the next corner has other edges of its key.
+* When the way turns at `J` by more than `acos(d)`, it goes directly to a new point `J*` on that link.
+* At `J*`, the way meets the link at the angle `acos(d)`.
+* Each way on the link gets `J*` as a new corner, so the run keeps the same points in each route. Then the same rule moves the exits, on the reversed ways.
+*
+* `firstId` is the first free id of a corner. `clear` tells if a line keeps out of the boxes. `delta` gives the cost share `d` of a link with `f` other edges.
+*/
+function snellMerges(ways, firstId, clear, delta) {
+	let next = firstId;
+	const keys = /* @__PURE__ */ new Map();
+	for (const w of ways) {
+		if (!w.found) continue;
+		const list = keys.get(w.key);
+		if (list) list.push(w);
+		else keys.set(w.key, [w]);
+	}
+	for (const group of keys.values()) {
+		if (group.length < 2) continue;
+		const linkOf = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
+		const on = /* @__PURE__ */ new Map();
+		const add = (k, w) => {
+			const set = on.get(k);
+			if (set) set.add(w);
+			else on.set(k, /* @__PURE__ */ new Set([w]));
+		};
+		const drop = (k, w) => {
+			const set = on.get(k);
+			if (!set) return;
+			set.delete(w);
+			if (set.size === 0) on.delete(k);
+		};
+		for (const w of group) for (let i = 1; i < w.ids.length; i++) add(linkOf(w.ids[i - 1], w.ids[i]), w);
+		for (const back of [false, true]) for (const w of group) {
+			if (back) {
+				w.seq.reverse();
+				w.ids.reverse();
+			}
+			for (let i = 1; i < w.ids.length - 1; i++) {
+				const before = on.get(linkOf(w.ids[i - 1], w.ids[i]));
+				const after = on.get(linkOf(w.ids[i], w.ids[i + 1]));
+				if (!before || !after || before.size !== 1 || after.size < 2) continue;
+				const P = w.seq[i - 1];
+				const J = w.seq[i];
+				const N = w.seq[i + 1];
+				const d = delta(after.size - 1);
+				if (turnAt(P, J, N) <= Math.acos(d) + .001) continue;
+				const len = dist(J, N);
+				let t = Math.min(len, snellOffset(P, J, N, d));
+				const pointAt = (s) => ({
+					x: J.x + (N.x - J.x) * s / len,
+					y: J.y + (N.y - J.y) * s / len
+				});
+				let tries = 0;
+				while (t >= 1 && !clear(P, pointAt(t)) && tries < 3) {
+					t /= 2;
+					tries++;
+				}
+				if (t < 1 || !clear(P, pointAt(t))) continue;
+				const a = w.ids[i - 1];
+				const j = w.ids[i];
+				const n = w.ids[i + 1];
+				if (t >= len - 1e-6) {
+					drop(linkOf(a, j), w);
+					drop(linkOf(j, n), w);
+					w.seq.splice(i, 1);
+					w.ids.splice(i, 1);
+					add(linkOf(a, n), w);
+					continue;
+				}
+				const star = pointAt(t);
+				const id = next++;
+				const users = [...after];
+				on.delete(linkOf(j, n));
+				for (const o of users) {
+					for (let k = 0; k < o.ids.length - 1; k++) {
+						const x = o.ids[k];
+						const y = o.ids[k + 1];
+						if (x === j && y === n || x === n && y === j) {
+							o.seq.splice(k + 1, 0, star);
+							o.ids.splice(k + 1, 0, id);
+							break;
+						}
+					}
+					add(linkOf(j, id), o);
+					add(linkOf(id, n), o);
+				}
+				drop(linkOf(a, j), w);
+				drop(linkOf(j, id), w);
+				w.seq.splice(i, 1);
+				w.ids.splice(i, 1);
+				add(linkOf(a, id), w);
+			}
+			if (back) {
+				w.seq.reverse();
+				w.ids.reverse();
+			}
+		}
+	}
+}
 // src/routers/shared.ts
 const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 /** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
@@ -5641,6 +6051,10 @@ function turn(from, base, to) {
 */
 function sharedRouter(options) {
 	const discount = Math.min(1, Math.max(.05, options.discount ?? .5));
+	const flow = options.cost === "flow";
+	const alpha = Math.min(1, Math.max(.1, options.alpha ?? .6));
+	const share = (f) => f <= 0 ? 1 : flow ? (f + 1) ** alpha - f ** alpha : discount;
+	const passes = Math.max(1, Math.floor(options.passes ?? 1));
 	const keyOf = (e) => {
 		if (!options.rule) return "*";
 		return options.rule(e) ?? `\u0000${e.id}`;
@@ -5680,13 +6094,16 @@ function sharedRouter(options) {
 				});
 			}
 			const discounted = /* @__PURE__ */ new Map();
-			const order = [...all].sort((p, q) => byText(p.key, q.key) || dist(q.ps.point, q.pt.point) - dist(p.ps.point, p.pt.point) || byText(p.edge.id, q.edge.id));
-			for (const w of order) {
+			const order = orderWays(all, options.order ?? "span", graph);
+			const top = /* @__PURE__ */ new Map();
+			const route = (w) => {
 				let used = discounted.get(w.key);
 				if (!used) discounted.set(w.key, used = /* @__PURE__ */ new Map());
 				const mine = used;
-				const way = corners.path(ways.out(w.ps), ways.out(w.pt), (i, j, d) => mine.has(link(i, j)) ? d * discount : d, discount);
-				if (!way) continue;
+				const floor = flow ? share(top.get(w.key) ?? 0) : discount;
+				const cost = flow ? (i, j, d) => d * share(mine.get(link(i, j))?.length ?? 0) : (i, j, d) => mine.has(link(i, j)) ? d * discount : d;
+				const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
+				if (!way) return;
 				w.found = true;
 				w.seq = way;
 				w.ids = way.map((p, i) => i === 0 || i === way.length - 1 ? endId(p) : index.get(p));
@@ -5697,7 +6114,32 @@ function sharedRouter(options) {
 					const list = mine.get(link(a, b));
 					if (list) list.push(w.edge.id);
 					else mine.set(link(a, b), [w.edge.id]);
+					if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b)).length));
+				}
+			};
+			for (const w of order) route(w);
+			for (let pass = 1; pass < passes; pass++) for (const w of order) {
+				if (!w.found) continue;
+				const mine = discounted.get(w.key);
+				for (let i = 1; i < w.ids.length; i++) {
+					const a = w.ids[i - 1];
+					const b = w.ids[i];
+					if (a >= corners.points.length || b >= corners.points.length) continue;
+					const k = link(a, b);
+					const list = mine.get(k);
+					if (!list) continue;
+					const at = list.indexOf(w.edge.id);
+					if (at >= 0) list.splice(at, 1);
+					if (list.length === 0) mine.delete(k);
 				}
+				w.found = false;
+				w.seq = [];
+				w.ids = [];
+				route(w);
+			}
+			if (options.merge === "snell") {
+				const pad = ways.margin / 2;
+				snellMerges(order, corners.points.length + ends.size, (a, b) => ways.obstacles.clear(a, b, pad), (f) => Math.min(.95, share(f)));
 			}
 			const users = /* @__PURE__ */ new Map();
 			for (const w of order) {
@@ -5785,6 +6227,33 @@ function sharedRouter(options) {
 	};
 }
 /**
+* This function gives the order of the ways for the router `shared`. The ways of one key stay together, in the order of the keys.
+* In a key, the order is `order`, and the edge id breaks each tie. The order `load` counts the edges of the key between the same two sections.
+*/
+function orderWays(all, order, graph) {
+	const span = (w) => dist(w.ps.point, w.pt.point);
+	if (order === "input") {
+		const at = new Map(all.map((w, i) => [w, i]));
+		return [...all].sort((p, q) => byText(p.key, q.key) || at.get(p) - at.get(q));
+	}
+	if (order === "shortest") return [...all].sort((p, q) => byText(p.key, q.key) || span(p) - span(q) || byText(p.edge.id, q.edge.id));
+	if (order === "span") return [...all].sort((p, q) => byText(p.key, q.key) || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+	const leafOf = /* @__PURE__ */ new Map();
+	const walk = (s) => {
+		if (s.children.length === 0) for (const i of s.nodes) leafOf.set(graph.nodes[i].id, s.id);
+		for (const c of s.children) walk(c);
+	};
+	walk(buildSections(graph.nodes));
+	const pair = (w) => {
+		const a = leafOf.get(w.edge.source.node) ?? "";
+		const b = leafOf.get(w.edge.target.node) ?? "";
+		return `${w.key}\u0000${a < b ? a : b}\u0000${a < b ? b : a}`;
+	};
+	const load = /* @__PURE__ */ new Map();
+	for (const w of all) load.set(pair(w), (load.get(pair(w)) ?? 0) + 1);
+	return [...all].sort((p, q) => byText(p.key, q.key) || load.get(pair(q)) - load.get(pair(p)) || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+}
+/**
 * This function gives the lane order of a run with the option `laneOrder: "run"` (metro-line order). Two edges of the run go together past its last corner
 * until they part. The edge that turns more to the left there gets the lane more to the left.
 * Two edges can part only before the first corner. Then the edge that comes from more to the left gets the lane more to the left.
@@ -5874,6 +6343,162 @@ const straightRouter = {
 		return { routes };
 	}
 };
+// src/routers/fan.ts
+/**
+* This function gives the Gilbert split point of a trunk with `targets.length` edges (EDA-030). The point makes the flow cost least:
+* `len(start, s) * k^alpha + Σ_j len(s, t_j)`, with `k` the number of targets. Weighted Weiszfeld steps find it.
+* The distance from `start` stays from `lo` to `hi` times the distance to the center of the targets.
+* It is also at most half of the distance to the nearest target.
+* The point moves back toward `start` out of the boxes, in steps of `step`.
+*/
+function gilbertPoint(start, targets, alpha, free, step, lo = .2, hi = .8) {
+	if (targets.length === 0) return start;
+	const k = targets.length;
+	const c = {
+		x: targets.reduce((s, p) => s + p.x, 0) / k,
+		y: targets.reduce((s, p) => s + p.y, 0) / k
+	};
+	const L = dist(start, c);
+	if (L === 0) return start;
+	const w0 = k ** Math.min(1, Math.max(0, alpha));
+	let s = {
+		x: start.x + (c.x - start.x) * .5,
+		y: start.y + (c.y - start.y) * .5
+	};
+	for (let it = 0; it < 32; it++) {
+		let sx = 0;
+		let sy = 0;
+		let sw = 0;
+		const pull = (p, w) => {
+			const d = Math.max(1e-6, dist(s, p));
+			sx += w * p.x / d;
+			sy += w * p.y / d;
+			sw += w / d;
+		};
+		pull(start, w0);
+		for (const t of targets) pull(t, 1);
+		const n = {
+			x: sx / sw,
+			y: sy / sw
+		};
+		const moved = dist(n, s);
+		s = n;
+		if (moved < .001) break;
+	}
+	const r = dist(start, s);
+	const most = Math.min(hi * L, .5 * Math.min(...targets.map((p) => dist(start, p))));
+	const want = Math.min(most, Math.max(lo * L, r));
+	const dir = r > 1e-9 ? {
+		x: (s.x - start.x) / r,
+		y: (s.y - start.y) / r
+	} : {
+		x: (c.x - start.x) / L,
+		y: (c.y - start.y) / L
+	};
+	const at = (t) => ({
+		x: start.x + dir.x * t,
+		y: start.y + dir.y * t
+	});
+	let d = want;
+	while (d > 0 && !free(at(d))) d -= step;
+	return d > 0 ? at(d) : start;
+}
+/**
+* This function grows a balancing-factor tree from `root` to the targets (NAT-017, after Cuntz and others, 2010).
+* At each step, the target `t` joins the place `v` of the tree with the least `|v - goal(t)| + bf * PL(v)`.
+* `PL(v)` is the length of the tree from the root to `v`.
+* A place is a point of the tree, or the foot of `goal(t)` on a link of the tree. `bf` 0 gives the least ink, and a large `bf` gives direct routes.
+* `branch(v, t)` gives the way from `v` to the plug of the target `t`: its first point is `v`, and its last point is the plug.
+*/
+function balancedFan(root, goals, bf, branch) {
+	const points = [{
+		point: root,
+		parent: -1,
+		pl: 0,
+		open: true
+	}];
+	const leaf = goals.map(() => -1);
+	const left = new Set(goals.map((_, i) => i));
+	while (left.size > 0) {
+		let best = Infinity;
+		let pick = -1;
+		let at = -1;
+		let foot;
+		for (const t of left) {
+			const g = goals[t];
+			for (let v = 0; v < points.length; v++) {
+				const p = points[v];
+				if (!p.open) continue;
+				const c = dist(p.point, g) + bf * p.pl;
+				if (c < best - 1e-9) {
+					best = c;
+					pick = t;
+					at = v;
+					foot = void 0;
+				}
+				if (p.parent < 0) continue;
+				const a = points[p.parent].point;
+				const b = p.point;
+				const L = dist(a, b);
+				if (L <= 1e-9) continue;
+				const u = ((g.x - a.x) * (b.x - a.x) + (g.y - a.y) * (b.y - a.y)) / (L * L);
+				if (u <= 1e-6 || u >= 1 - 1e-6) continue;
+				const f = {
+					x: a.x + u * (b.x - a.x),
+					y: a.y + u * (b.y - a.y)
+				};
+				const pl = points[p.parent].pl + u * L;
+				const cf = dist(f, g) + bf * pl;
+				if (cf < best - 1e-9) {
+					best = cf;
+					pick = t;
+					at = v;
+					foot = {
+						point: f,
+						pl
+					};
+				}
+			}
+		}
+		left.delete(pick);
+		let from = at;
+		if (foot) {
+			points.push({
+				point: foot.point,
+				parent: points[at].parent,
+				pl: foot.pl,
+				open: true
+			});
+			from = points.length - 1;
+			points[at].parent = from;
+		}
+		const way = branch(points[from].point, pick);
+		let prev = from;
+		for (let i = 1; i < way.length; i++) {
+			const q = way[i];
+			const base = points[prev];
+			if (dist(q, base.point) <= 1e-9) continue;
+			points.push({
+				point: q,
+				parent: prev,
+				pl: base.pl + dist(base.point, q),
+				open: i < way.length - 1
+			});
+			prev = points.length - 1;
+		}
+		leaf[pick] = prev;
+	}
+	return {
+		points,
+		leaf
+	};
+}
+/** This function gives the points of the tree from the root to the point `i`. */
+function fanPath(fan, i) {
+	const out = [];
+	for (let j = i; j >= 0; j = fan.points[j].parent) out.push(fan.points[j].point);
+	return out.reverse();
+}
 // src/routers/trunks.ts
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 const byCollection = (e) => {
@@ -5932,7 +6557,7 @@ function splitPoint(start, targets, split, free, step) {
 	while (d > 0 && !free(at(d))) d -= step;
 	return d > 0 ? at(d) : start;
 }
-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 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.
 *
@@ -6038,10 +6663,42 @@ function trunksRouter(options) {
 					y: centers.reduce((a, p) => a + p.y, 0) / centers.length
 				};
 				const plug = placePlug(s, first.source, c);
-				const split = splitPoint(ways.out(plug), centers, options.split ?? .5, (p) => !ways.obstacles.inside(p, ways.margin), ways.margin);
+				const start = ways.out(plug);
+				const key = id.split("\0")[2];
+				if (options.fan === "tree") {
+					const pts = group.map((e, i) => placePlug(targets[i], e.target, start));
+					const bf = Math.min(1, Math.max(0, options.bf ?? .4));
+					const fan = balancedFan(start, pts.map((pt) => ways.out(pt)), bf, (from, t) => ways.toPlug(from, pts[t]) ?? [from, pts[t].point]);
+					const own = group.map((e, i) => ({
+						edge: e.id,
+						points: dedupe$2([plug.point, ...fanPath(fan, fan.leaf[i])])
+					}));
+					for (const r of own) points.set(r.edge, r.points);
+					const order = options.laneOrder ?? "bundle";
+					const common = own[0].points.slice(0, commonStart(own, 0));
+					bundles.push({
+						id: `b${bundles.length}`,
+						key,
+						node: s.id,
+						edges: orderLanes(common, own, order),
+						trunk: common
+					});
+					for (const way of sharedWays(own, common.length)) {
+						const users = own.filter((r) => way.edges.includes(r.edge));
+						runs.push({
+							id: `r${runs.length}`,
+							key,
+							points: way.points,
+							edges: orderLanes(way.points, users, order)
+						});
+					}
+					continue;
+				}
+				const free = (p) => !ways.obstacles.inside(p, ways.margin);
+				const split = options.splitAt === "gilbert" ? gilbertPoint(start, centers, options.alpha ?? .5, free, ways.margin) : splitPoint(start, centers, options.split ?? .5, free, ways.margin);
 				const way = ways.fromPlug(plug, split);
 				if (!way) continue;
-				const trunk = dedupe$1(way);
+				const trunk = dedupe$2(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 +6711,11 @@ function trunksRouter(options) {
 				const exits = [];
 				group.forEach((e, i) => {
 					const pt = placePlug(targets[i], e.target, end);
-					const branch = dedupe$1(ways.toPlug(end, pt) ?? [end, pt.point]);
+					const branch = dedupe$2(ways.toPlug(end, pt) ?? [end, pt.point]);
 					if (!part) {
 						own.push({
 							edge: e.id,
-							points: dedupe$1([...trunk, ...branch.slice(1)])
+							points: dedupe$2([...trunk, ...branch.slice(1)])
 						});
 						branches.push({
 							edge: e.id,
@@ -6072,7 +6729,6 @@ function trunksRouter(options) {
 						exit
 					});
 				});
-				const key = id.split("\0")[2];
 				if (!part) {
 					for (const r of own) points.set(r.edge, r.points);
 					const edges = options.laneOrder === "run" || trunk.length < 2 ? laneOrder(dir, end, branches) : orderLanes(trunk, own, "bundle");
@@ -6090,7 +6746,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$1([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
+					const p = dedupe$2([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
 					points.set(edge, p);
 					own.push({
 						edge,
@@ -6564,7 +7220,7 @@ function routeLanes(items, links, gaps, gutter, snap, weight, router) {
 				w: weight(links[i])
 			});
 		});
-		return density(spans);
+		return density$1(spans);
 	});
 }
 /** This function gives the points of the way of each link on the probe board, in the order of the links. */
@@ -6635,7 +7291,7 @@ function merge(spans) {
 	return out;
 }
 /** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
-function density(spans) {
+function density$1(spans) {
 	const events = [];
 	for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
 	events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
@@ -6690,7 +7346,13 @@ const LANE_ORDERS = [
 	"ends",
 	"crossings"
 ];
-const EPS$1 = 1e-6;
+/** The lane rules of `gapLanes`, in the order of the benchmark. */
+const LANE_TRACKS = [
+	"stack",
+	"left-edge",
+	"free"
+];
+const EPS$2 = 1e-6;
 const ROUNDS = 8;
 /**
 * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
@@ -6698,14 +7360,24 @@ const ROUNDS = 8;
 * When a move puts a link through more boxes than before, the link keeps its points.
 */
 function gapLanes(items, links, options = {}) {
+	return laneGaps(items, links, options).links;
+}
+/** This function gives the lanes of each gap that holds a piece of a link, with the options of `gapLanes`. A gap without a piece is not in the list. */
+function gapLaneCounts(items, links, options = {}) {
+	return laneGaps(items, links, options).counts;
+}
+/** This function does the work of `gapLanes` and `gapLaneCounts`. It gives the moved links and the lanes of each gap. */
+function laneGaps(items, links, options) {
 	const spacing = Math.max(0, options.spacing ?? 4);
 	const order = options.order ?? "crossings";
+	const tracks = options.tracks ?? "stack";
 	const moved = links.map((l) => l.points.map((p) => ({
 		x: p.x,
 		y: p.y
 	})));
+	const counts = [];
 	for (const g of boardGaps(items, options.snap)) {
-		if (g.width <= EPS$1) continue;
+		if (g.width <= EPS$2) continue;
 		const across = g.axis;
 		const along = g.axis === "x" ? "y" : "x";
 		const lo = g.at - g.width;
@@ -6716,8 +7388,8 @@ function gapLanes(items, links, options = {}) {
 			for (let i = 2; i <= p.length - 2; i++) {
 				const a = p[i - 1];
 				const b = p[i];
-				if (Math.abs(a[across] - b[across]) > EPS$1 || a[across] <= lo + EPS$1 || a[across] >= hi - EPS$1) continue;
-				if (Math.abs(a[along] - b[along]) <= EPS$1) continue;
+				if (Math.abs(a[across] - b[across]) > EPS$2 || a[across] <= lo + EPS$2 || a[across] >= hi - EPS$2) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS$2) continue;
 				const side = (q, r) => Math.sign(r[across] - q[across]);
 				pieces.push({
 					link: li,
@@ -6730,13 +7402,15 @@ function gapLanes(items, links, options = {}) {
 		});
 		if (pieces.length === 0) continue;
 		const list = orderPieces(pieces, order);
-		const lane = [];
-		let n = 0;
-		list.forEach((P, i) => {
-			let k = 0;
-			for (let j = 0; j < i; j++) if (overlaps(list[j], P)) k = Math.max(k, lane[j] + 1);
-			lane.push(k);
-			n = Math.max(n, k + 1);
+		const lane = tracks === "stack" ? stackLanes(list) : leftEdgeLanes(list, tracks === "left-edge");
+		const n = lane.reduce((m, k) => Math.max(m, k + 1), 0);
+		counts.push({
+			axis: g.axis,
+			at: g.at,
+			width: g.width,
+			lanes: n,
+			pieces: list.length,
+			density: density(list)
 		});
 		const step = Math.min(spacing, g.width / (n + 1));
 		const mid = (lo + hi) / 2;
@@ -6748,20 +7422,81 @@ function gapLanes(items, links, options = {}) {
 	}
 	const boxes = new Grid(Math.max(20, meanSide(items)));
 	for (const i of items) boxes.add(i.box, i.box);
-	return links.map((l, i) => hits(boxes, moved[i]) > hits(boxes, l.points) ? l : {
-		...l,
-		points: moved[i]
+	return {
+		links: links.map((l, i) => hits(boxes, moved[i]) > hits(boxes, l.points) ? l : {
+			...l,
+			points: moved[i]
+		}),
+		counts
+	};
+}
+/** This function gives the lanes of the rule `stack`. A piece goes one lane past each piece before it in the order that it overlaps. */
+function stackLanes(list) {
+	const lane = [];
+	list.forEach((P, i) => {
+		let k = 0;
+		for (let j = 0; j < i; j++) if (overlaps(list[j], P)) k = Math.max(k, lane[j] + 1);
+		lane.push(k);
 	});
+	return lane;
+}
+/**
+* This function gives the lanes of the left-edge rule (Hashimoto and Stevens, 1971) for the pieces in lane order.
+* With `constrained`, a piece stays below a later piece that it overlaps when the swap of the two adds crossings (`cost`).
+* These constraints follow the lane order, so they have no cycle. Each pass fills one lane, from the near side.
+* A pass takes the free pieces whose constraints are met, in the order of their start. It puts each piece that does not overlap the last piece of the lane.
+*/
+function leftEdgeLanes(list, constrained) {
+	const n = list.length;
+	const below = list.map(() => []);
+	const wait = new Array(n).fill(0);
+	if (constrained) for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const P = list[i];
+		const Q = list[j];
+		if (overlaps(P, Q) && cost$1(Q, P) > cost$1(P, Q)) {
+			below[i].push(j);
+			wait[j]++;
+		}
+	}
+	const byStart = list.map((_, i) => i).sort((a, b) => list[a].lo - list[b].lo || a - b);
+	const lane = new Array(n).fill(-1);
+	let placed = 0;
+	for (let track = 0; placed < n; track++) {
+		const now = [];
+		let end = -Infinity;
+		for (const i of byStart) {
+			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$2) continue;
+			now.push(i);
+			end = list[i].hi;
+		}
+		for (const i of now) lane[i] = track;
+		for (const i of now) for (const j of below[i]) wait[j]--;
+		placed += now.length;
+	}
+	return lane;
+}
+/** This function gives the largest number of pieces that overlap at one place. Pieces that only touch do not overlap. */
+function density(list) {
+	const events = [];
+	for (const P of list) events.push([P.lo, 1], [P.hi, -1]);
+	events.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+	let open = 0;
+	let most = 0;
+	for (const [, d] of events) {
+		open += d;
+		most = Math.max(most, open);
+	}
+	return most;
 }
-const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$1;
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$2;
 /**
 * This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
 * A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
 */
 function cost$1(P, Q) {
 	let c = 0;
-	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$1 && y < Q.hi - EPS$1) c++;
-	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$1 && y < P.hi - EPS$1) c++;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$2 && y < Q.hi - EPS$2) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$2 && y < P.hi - EPS$2) c++;
 	return c;
 }
 /** This function gives the pieces of one gap in lane order, from the near side to the far side. */
@@ -7857,7 +8592,23 @@ const RUN_LANE_ORDER = {
 	default: "run"
 };
 /** The declarations of the options of the routers `corners` and `corners-smooth`. */
-const CORNERS_SCHEMA = WAY_SCHEMA;
+const CORNERS_SCHEMA = {
+	...WAY_SCHEMA,
+	plugs: {
+		type: "enum",
+		values: ["facing", "side"],
+		default: "facing",
+		describe: "With `facing`, a free plug faces the other end. With `side`, the search starts from the whole free side, and the plug goes where the way leaves (WILD-001)."
+	},
+	plugGap: {
+		type: "number",
+		min: 0,
+		max: 24,
+		step: 1,
+		default: 0,
+		describe: "With a gap above 0, the free plugs of a side keep their order and at least this gap (WILD-002). 0 keeps each plug where it is."
+	}
+};
 /** The declarations of the options of the router `trunks`. */
 const TRUNKS_SCHEMA = {
 	...WAY_SCHEMA,
@@ -7887,6 +8638,34 @@ const TRUNKS_SCHEMA = {
 		values: ["part", "split"],
 		default: "part",
 		describe: "With `part`, a lane leaves the trunk where its way parts from the other ways. With `split`, each lane leaves at the split point."
+	},
+	splitAt: {
+		type: "enum",
+		values: ["share", "gilbert"],
+		default: "share",
+		describe: "With `share`, the split point is at `split` of the way. With `gilbert`, it is where the flow cost is least (EDA-030)."
+	},
+	alpha: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05,
+		default: .5,
+		describe: "The exponent of the flow cost of the split `gilbert`. A smaller value moves the split toward the targets."
+	},
+	fan: {
+		type: "enum",
+		values: ["split", "tree"],
+		default: "split",
+		describe: "With `split`, the edges of a group share a trunk to a split point. With `tree`, they grow a balancing-factor tree (NAT-017)."
+	},
+	bf: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05,
+		default: .4,
+		describe: "The balancing factor of the fan `tree`. 0 gives the least ink, and a larger factor gives more direct routes."
 	}
 };
 /** The declarations of the options of the routers `shared` and `shared-all`. */
@@ -7904,7 +8683,46 @@ const SHARED_SCHEMA = {
 		default: .5,
 		describe: "The cost of a link that an edge with the same key uses already, as a share of its length."
 	},
-	laneOrder: LANE_ORDER
+	laneOrder: LANE_ORDER,
+	cost: {
+		type: "enum",
+		values: ["fixed", "flow"],
+		default: "fixed",
+		describe: "With `fixed`, a shared link costs `discount` of its length. With `flow`, a link with `f` edges costs `len * f^alpha` (EDA-029)."
+	},
+	alpha: {
+		type: "number",
+		min: .1,
+		max: 1,
+		step: .05,
+		default: .6,
+		describe: "The exponent of the cost `flow`. A smaller value gives more sharing."
+	},
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 5,
+		step: 1,
+		default: 1,
+		describe: "In each pass after the first, each edge finds its way again with the ways of the other edges fixed (HWY-039)."
+	},
+	order: {
+		type: "enum",
+		values: [
+			"span",
+			"shortest",
+			"load",
+			"input"
+		],
+		default: "span",
+		describe: "The order of the edges of a key: the longest first, the shortest first, the most edges between two sections first, or the input order (NAT-024)."
+	},
+	merge: {
+		type: "enum",
+		values: ["corner", "snell"],
+		default: "corner",
+		describe: "With `corner`, a route joins a run at a corner of the graph. With `snell`, it joins at the angle `acos(d)` (NAT-035)."
+	}
 };
 /** The declarations of the options of the highway strategy `corridors` (HWY-031). */
 const CORRIDOR_SCHEMA = {
@@ -8671,11 +9489,11 @@ const BUILT_IN_STRATEGIES = Object.freeze([
 /** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
 const STRATEGIES = createRegistry(BUILT_IN_STRATEGIES);
 // src/bench/measures/curves.ts
-const EPS = 1e-9;
+const EPS$1 = 1e-9;
 const DEG = 180 / Math.PI;
 const unit = (x, y) => {
 	const l = Math.hypot(x, y);
-	return l > EPS ? {
+	return l > EPS$1 ? {
 		x: x / l,
 		y: y / l
 	} : void 0;
@@ -8694,7 +9512,7 @@ function frame(from, s, t) {
 				x: -Math.sin(a) * sign,
 				y: Math.cos(a) * sign
 			},
-			curvature: s.radius > EPS ? sign / s.radius : 0
+			curvature: s.radius > EPS$1 ? sign / s.radius : 0
 		};
 	}
 	const [p0, p1, p2, p3] = [
@@ -8718,7 +9536,7 @@ function frame(from, s, t) {
 		y: 6 * (p1.y - 2 * p2.y + p3.y)
 	};
 	const speed = Math.hypot(d.x, d.y);
-	if (speed > EPS) return {
+	if (speed > EPS$1) return {
 		tangent: {
 			x: d.x / speed,
 			y: d.y / speed
@@ -8787,13 +9605,13 @@ function g2Defect(segments, u) {
 */
 function bendingEnergy(points, tolerance = .25) {
 	const q = [];
-	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS) q.push(v);
+	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS$1) q.push(v);
 	if (q.length < 3) return 0;
 	const phi = turns(q);
 	let sum = 0;
 	for (let i = 1; i + 1 < q.length; i++) {
 		const t = Math.abs(phi[i - 1]);
-		if (t < EPS) continue;
+		if (t < EPS$1) continue;
 		const l = Math.min((dist(q[i - 1], q[i]) + dist(q[i], q[i + 1])) / 2, 8 * tolerance / t);
 		sum += t * t / l;
 	}
@@ -9420,15 +10238,7 @@ function measureBoard(graph, spacing, order) {
 		order
 	}) : level;
 	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
-	const edgeOf = /* @__PURE__ */ new Map();
-	for (const e of graph.edges) {
-		const key = `${e.source.node}\u0000${e.target.node}`;
-		if (!edgeOf.has(key)) edgeOf.set(key, e.id);
-	}
-	const q = measureQuality(graph, { routes: drawn.map((l) => ({
-		edge: edgeOf.get(`${l.source}\u0000${l.target}`),
-		points: l.points
-	})) });
+	const q = farQuality(graph, drawn);
 	const segments = segmentsOf(sectionsRouter({ name: "sections" }).route(graph));
 	const lanes = laneRoutes(segments, new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges))), spacing);
 	return {
@@ -9439,22 +10249,46 @@ function measureBoard(graph, spacing, order) {
 		laneThrough: measureRouteFaults(graph, { routes: lanes }).through
 	};
 }
-/**
-* This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
-* The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
-*/
-function benchRoom(fixture, graph, options = {}, methods = [roomStrategies.routes, roomStrategies.lines]) {
-	const spacing = options.spacing ?? 4;
-	const area0 = areaOf$1(graph.nodes);
-	const links = roomLinks(graph);
-	const row = (board, nodes, ms) => ({
-		fixture,
-		board,
-		area: area0 > 0 ? areaOf$1(nodes) / area0 : 1,
-		ms,
-		...measureBoard({
-			nodes,
-			edges: graph.edges
+/** This function gives the links of the far view of a board: `levelLinks` with each node as one item. */
+function farLinks(graph) {
+	return levelLinks(graph.nodes.map((n) => ({
+		id: n.id,
+		box: n.box,
+		nodes: [n.id]
+	})), roomLinks(graph).map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})));
+}
+/** This function measures the links of the far view with `measureQuality`. Each link stands for the first edge of its pair, because `measureQuality` reads routes of edges. */
+function farQuality(graph, drawn) {
+	const edgeOf = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const key = `${e.source.node}\u0000${e.target.node}`;
+		if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+	}
+	return measureQuality(graph, { routes: drawn.map((l) => ({
+		edge: edgeOf.get(`${l.source}\u0000${l.target}`),
+		points: l.points
+	})) });
+}
+/**
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+* The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
+*/
+function benchRoom(fixture, graph, options = {}, methods = [roomStrategies.routes, roomStrategies.lines]) {
+	const spacing = options.spacing ?? 4;
+	const area0 = areaOf$1(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf$1(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
 		}, spacing)
 	});
 	const rows = [row("packed", graph.nodes, 0)];
@@ -9779,6 +10613,94 @@ function formatBendRoom(rows) {
 		...rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${r.bundles} | ${(r.worstSpacing * 100).toFixed(1)}% | ${r.minRadius === Infinity ? "-" : r.minRadius.toFixed(2)} | ${r.underMin} | ${r.through} |`)
 	].join("\n");
 }
+/**
+* This function gives R12 (lane separation) of the links. Two legs of two links are near when they are parallel and nearer than `near`.
+* R12 is the length of the near legs, as a share of the ink.
+* It reads only the legs on an axis. The links of the far view have no other legs.
+*/
+function laneSeparation(links, near) {
+	let ink = 0;
+	let close = 0;
+	for (const across of ["x", "y"]) {
+		const along = across === "x" ? "y" : "x";
+		const legs = [];
+		links.forEach((l, li) => {
+			for (let i = 1; i < l.points.length; i++) {
+				const a = l.points[i - 1];
+				const b = l.points[i];
+				if (Math.abs(a[across] - b[across]) > 1e-6 || Math.abs(a[along] - b[along]) <= 1e-6) continue;
+				legs.push({
+					link: li,
+					at: a[across],
+					lo: Math.min(a[along], b[along]),
+					hi: Math.max(a[along], b[along])
+				});
+			}
+		});
+		legs.sort((p, q) => p.at - q.at);
+		for (let i = 0; i < legs.length; i++) {
+			const P = legs[i];
+			ink += P.hi - P.lo;
+			for (let j = i + 1; j < legs.length && legs[j].at - P.at < near; j++) {
+				const Q = legs[j];
+				if (Q.link !== P.link) close += Math.max(0, Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo));
+			}
+		}
+	}
+	return ink > 0 ? close / ink : 0;
+}
+/**
+* This function measures each lane rule of `gapLanes` (EDA-004) on the board as it is, and on the board that `makeRoom` opens.
+* The lane order is `crossings` for each rule. The lanes are `spacing` apart where the gap has room.
+*/
+function benchTracks(fixture, graph, spacing = 4, rules = LANE_TRACKS) {
+	const open = makeRoom(graph.nodes, roomLinks(graph), {
+		gutter: 8,
+		spacing,
+		method: "routes"
+	}).items;
+	const rows = [];
+	for (const [board, nodes] of [["given", graph.nodes], ["open", open]]) {
+		const g = {
+			nodes,
+			edges: graph.edges
+		};
+		const level = farLinks(g);
+		const boxes = new Map(nodes.map((n) => [n.id, n.box]));
+		for (const tracks of rules) {
+			const options = {
+				spacing,
+				order: "crossings",
+				tracks
+			};
+			const counts = gapLaneCounts(nodes, level, options);
+			const drawn = gapLanes(nodes, level, options);
+			const q = farQuality(g, drawn);
+			rows.push({
+				fixture,
+				board,
+				tracks,
+				gaps: counts.length,
+				lanes: counts.reduce((s, c) => s + c.lanes, 0),
+				density: counts.reduce((s, c) => s + c.density, 0),
+				squeezed: counts.filter((c) => c.width / (c.lanes + 1) < spacing - 1e-9).length,
+				crossings: q.crossings,
+				ink: q.ink,
+				separation: laneSeparation(drawn, spacing),
+				through: measureLinks(boxes, drawn).through
+			});
+		}
+	}
+	return rows;
+}
+/** This function writes the rows of `benchTracks` as a Markdown table. */
+function formatTracks(rows) {
+	return [
+		"| fixture | board | tracks | gaps | lanes | density | squeezed | crossings | ink | R12 | through |",
+		"|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => `| ${r.fixture} | ${r.board} | ${r.tracks} | ${r.gaps} | ${r.lanes} | ${r.density} | ${r.squeezed} | ${r.crossings} | ${Math.round(r.ink)} | ${r.separation.toFixed(4)} | ${r.through} |`)
+	].join("\n");
+}
 // src/bench/sections.ts
 const now$1 = () => globalThis.performance?.now() ?? Date.now();
 /** This function gives the number of items of the first level with more than one item, or 0 for a result without levels. */
@@ -10268,6 +11190,104 @@ function ambiguity(graph, routes, options = {}) {
 		estimated: !exact
 	};
 }
+/** The drawn segments of each route, as keys, in the order of its points. A segment shorter than the grain of `segmentKey` has no key. */
+function routeKeys(routes) {
+	const keys = /* @__PURE__ */ new Map();
+	const users = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const own = [];
+		for (let i = 1; i < r.points.length; i++) {
+			const k = segmentKey(r.points[i - 1], r.points[i]);
+			if (k === void 0) continue;
+			own.push(k);
+			let set = users.get(k);
+			if (!set) users.set(k, set = /* @__PURE__ */ new Set());
+			set.add(r.edge);
+		}
+		keys.set(r.edge, own);
+	}
+	return {
+		keys,
+		users
+	};
+}
+/**
+* This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
+* An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
+* The scale is 0 to 1. A higher value is better only in context. The cost is linear.
+*/
+function bundledShare(result) {
+	const routes = result.routes;
+	if (routes.length === 0) return 0;
+	const shared = /* @__PURE__ */ new Set();
+	for (const run of result.runs ?? []) for (const e of run.edges) shared.add(e);
+	for (const b of result.bundles ?? []) if (b.edges.length > 1) for (const e of b.edges) shared.add(e);
+	const { keys, users } = routeKeys(routes);
+	for (const [edge, own] of keys) if (own.some((k) => (users.get(k)?.size ?? 0) > 1)) shared.add(edge);
+	let count = 0;
+	for (const r of routes) if (shared.has(r.edge)) count++;
+	return count / routes.length;
+}
+/**
+* This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
+* The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
+* The cost is an extra run of the base router, and then linear.
+*/
+function bundleStretch(routes, base) {
+	const baseLength = /* @__PURE__ */ new Map();
+	for (const r of base) baseLength.set(r.edge, polylineLength(r.points));
+	const st = [];
+	for (const r of routes) {
+		const b = baseLength.get(r.edge);
+		if (b === void 0 || b <= 1 || r.points.length < 2) continue;
+		st.push(polylineLength(r.points) / b);
+	}
+	if (st.length === 0) return {
+		median: 1,
+		q95: 1,
+		edges: 0
+	};
+	return {
+		median: quantile(st, .5),
+		q95: quantile(st, .95),
+		edges: st.length
+	};
+}
+/**
+* This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
+* A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
+* One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
+* Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
+*/
+function mergeAngle(routes) {
+	const { users } = routeKeys(routes);
+	const sig = /* @__PURE__ */ new Map();
+	for (const [k, set] of users) sig.set(k, [...set].sort().join("\0"));
+	let max = 0;
+	for (const r of routes) {
+		let prev;
+		for (let i = 1; i < r.points.length; i++) {
+			const a = r.points[i - 1];
+			const b = r.points[i];
+			const k = segmentKey(a, b);
+			if (k === void 0) continue;
+			if (prev && sig.get(prev.k) !== sig.get(k) && ((users.get(prev.k)?.size ?? 0) > 1 || (users.get(k)?.size ?? 0) > 1)) {
+				const ux = prev.b.x - prev.a.x;
+				const uy = prev.b.y - prev.a.y;
+				const vx = b.x - a.x;
+				const vy = b.y - a.y;
+				const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+				max = Math.max(max, turn * 180 / Math.PI);
+			}
+			prev = {
+				k,
+				a,
+				b
+			};
+		}
+	}
+	return max;
+}
 // src/bench/measures/levels.ts
 /** This function gives the levels in the order of their depth, from the far view to the near view. */
 function byDepth(levels) {
@@ -10631,27 +11651,337 @@ 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;
+// 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 false;
+	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 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.
+* 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 plugAt(node, end, p) {
-	if (pointBoxDistance(p, node.box) > SAME) return false;
-	const fixed = fixedPortPoint(node, end);
+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/order/index.ts
+/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
+function byHash(a, b) {
+	if (a.h !== b.h) return a.h - b.h;
+	return a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0;
+}
+/**
+* This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
+* The nodes and the edges do not change. Two orders of the same edges give the same graph.
+* The hash spreads the edges, so the stable order does not favor the edges of one node or one collection.
+*/
+function stableOrder(graph) {
+	const edges = graph.edges.map((e) => ({
+		h: fnv1a32(e.id),
+		e
+	})).sort(byHash).map((x) => x.e);
+	return {
+		...graph,
+		edges
+	};
+}
+/** This function gives the graph with its edges in a random order of the seed. The same graph and seed always give the same order. */
+function shuffleEdges(graph, seed) {
+	const edges = [...graph.edges];
+	const r = rng(seed);
+	for (let i = edges.length - 1; i > 0; i--) {
+		const j = Math.floor(r() * (i + 1));
+		[edges[i], edges[j]] = [edges[j], edges[i]];
+	}
+	return {
+		...graph,
+		edges
+	};
+}
+/**
+* This function routes the graph in the stable order of `stableOrder`, with the function `route`.
+* The routes come back in the order of the input edges, so the caller sees no change of order.
+* The bundles, the runs and the levels come from the stable order. Thus each order of the input gives the same data.
+*/
+function routeInStableOrder(graph, route) {
+	const result = route(stableOrder(graph));
+	const index = new Map(graph.edges.map((e, i) => [e.id, i]));
+	const at = (edge) => index.get(edge) ?? Number.MAX_SAFE_INTEGER;
+	const routes = [...result.routes].sort((a, b) => at(a.edge) - at(b.edge));
+	return {
+		...result,
+		routes
+	};
+}
+/** This function gives a router that routes each graph in the stable order of WILD-053. It keeps the name and the `maxNodes` of the router. */
+function withStableOrder(router) {
+	return {
+		...router,
+		route: (graph) => routeInStableOrder(graph, (g) => router.route(g))
+	};
+}
+/**
+* This function gives a router strategy that runs `strategy` in the stable order of WILD-053. The output does not depend on the order of the input edges.
+* The new strategy has the name `<name>+stable`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+*/
+function stableOrderStrategy(strategy) {
+	return defineStrategy({
+		step: "router",
+		name: `${strategy.name}+stable`,
+		describe: `${strategy.describe} The edges go in a stable order: by a hash of their ids.`,
+		defaults: { ...strategy.defaults },
+		...strategy.schema === void 0 ? {} : { schema: strategy.schema },
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		run: (graph, options) => routeInStableOrder(graph, (g) => strategy.run(g, options))
+	});
+}
+// src/bench/measures/order.ts
+/**
+* This function gives `IQR / median` of the values. Values with a median of 0 give `IQR / mean`, and values that are all 0 give 0.
+* An IQR below `1e-9` of the median is rounding noise of the sums, so it gives 0.
+*/
+function spread(values) {
+	const iqr = quantile(values, .75) - quantile(values, .25);
+	const mid = Math.abs(quantile(values, .5));
+	if (iqr <= 1e-9 * Math.max(1, mid)) return 0;
+	if (mid > 0) return iqr / mid;
+	const mean = values.reduce((s, v) => s + Math.abs(v), 0) / values.length;
+	return mean > 0 ? iqr / mean : 0;
+}
+/** This function gives the routes by the id of the edge, in the order of the ids, so two orders of the input compare. */
+function byEdge(routes) {
+	return [...routes].sort((a, b) => a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : 0);
+}
+/**
+* This function measures the order fragility of a router on one graph (W3, from WILD-056).
+* It routes the graph with `orders` random orders of the edges.
+* It gives the spread `IQR / median` of the crossings, the detour, the ink saved and the ink.
+* It also gives the share of orders that change a route, and the price of anarchy of the crossings.
+* The cost is `orders` extra runs of the router.
+*/
+function orderFragility(graph, route, options = {}) {
+	const orders = Math.max(1, Math.floor(options.orders ?? 20));
+	const seed = options.seed ?? 1;
+	const baseRoutes = byEdge((options.base ?? route(graph)).routes);
+	const crossings = [];
+	const detour = [];
+	const saved = [];
+	const ink = [];
+	let changed = 0;
+	for (let k = 0; k < orders; k++) {
+		const routes = byEdge(route(shuffleEdges(graph, seed + k)).routes);
+		const segs = drawnSegments(routes);
+		crossings.push(crossingAngles(segs).crossings);
+		detour.push(detourSpread(routes).median);
+		saved.push(inkSaved(routes));
+		let length = 0;
+		for (const [a, b] of segs) length += Math.hypot(b.x - a.x, b.y - a.y);
+		ink.push(length);
+		if (!sameData(routes, baseRoutes)) changed++;
+	}
+	const own = crossingAngles(drawnSegments(baseRoutes)).crossings;
+	const best = Math.min(...crossings);
+	return {
+		orders,
+		crossings: spread(crossings),
+		detour: spread(detour),
+		inkSaved: spread(saved),
+		ink: spread(ink),
+		changed: changed / orders,
+		poa: best > 0 ? own / best : own === 0 ? 1 : NaN
+	};
+}
+// src/highways/follow.ts
+const SAME = 1e-6;
+const dedupe$1 = (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$1 = (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. */
@@ -10745,7 +12075,7 @@ function follow(graph, plan, options = {}) {
 		}
 		routes.push({
 			edge: e.id,
-			points: dedupe(out)
+			points: dedupe$1(out)
 		});
 	}
 	const routeOf = new Map(routes.map((r) => [r.edge, r]));
@@ -10758,10 +12088,10 @@ function follow(graph, plan, options = {}) {
 			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));
+			const points = dedupe$1(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));
+			const mine = users.map((id) => routeOf.get(id)).filter((r) => holds$1(r.points, points));
 			if (mine.length < 2) continue;
 			runs.push({
 				id: `r${runs.length}`,
@@ -12013,230 +13343,47 @@ function compareStep(step, graph, options = {}) {
 		excluded: rows.filter((r) => !fair.includes(r)).map((r) => r.strategy)
 	};
 }
-// 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);
+// 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 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
+/** 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 {
@@ -12592,6 +13739,86 @@ const MEASURES = Object.freeze([
 		"lower",
 		false
 	],
+	[
+		"B2.share",
+		"B2",
+		"route.bundle.share",
+		"0 to 1",
+		"higher",
+		false
+	],
+	[
+		"B3.median",
+		"B3",
+		"route.bundle.stretch.median",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"B3.q95",
+		"B3",
+		"route.bundle.stretch.q95",
+		"ratio",
+		"lower",
+		false
+	],
+	[
+		"B6.max",
+		"B6",
+		"route.bundle.merge-angle.max",
+		"degrees",
+		"lower",
+		false
+	],
+	[
+		"W3.crossings",
+		"W3",
+		"route.order.crossings",
+		"IQR over the median",
+		"lower",
+		true
+	],
+	[
+		"W3.detour",
+		"W3",
+		"route.order.detour",
+		"IQR over the median",
+		"lower",
+		true
+	],
+	[
+		"W3.inkSaved",
+		"W3",
+		"route.order.ink-saved",
+		"IQR over the median",
+		"lower",
+		true
+	],
+	[
+		"W3.ink",
+		"W3",
+		"route.order.ink",
+		"IQR over the median",
+		"lower",
+		true
+	],
+	[
+		"W3.changed",
+		"W3",
+		"route.order.changed",
+		"0 to 1",
+		"lower",
+		true
+	],
+	[
+		"W3.poa",
+		"W3",
+		"route.order.poa",
+		"ratio",
+		"lower",
+		true
+	],
 	[
 		"Z10.mean",
 		"Z10",
@@ -13035,6 +14262,639 @@ function corpusManifest(corpus, inputs) {
 		}))
 	};
 }
+// src/repair/walk.ts
+/** The sides of a box, as the indexes of two corners: north, east, south and west. */
+const SIDES = [
+	[0, 1],
+	[1, 2],
+	[3, 2],
+	[0, 3]
+];
+const SIDE_INDEX = {
+	north: 0,
+	east: 1,
+	south: 2,
+	west: 3
+};
+/** This function gives the four corners of a box: top left, top right, bottom right and bottom left. */
+function corners(b) {
+	return [
+		{
+			x: b.x,
+			y: b.y
+		},
+		{
+			x: b.x + b.w,
+			y: b.y
+		},
+		{
+			x: b.x + b.w,
+			y: b.y + b.h
+		},
+		{
+			x: b.x,
+			y: b.y + b.h
+		}
+	];
+}
+const EPS = 1e-6;
+const keyOf = (p) => `${Math.round(p.x * 1e3)},${Math.round(p.y * 1e3)}`;
+/** This function tells if the point `c` is on the axis-parallel segment `pq`. */
+function onSide(c, p, q) {
+	if (Math.abs(p.y - q.y) <= EPS) return Math.abs(c.y - p.y) <= EPS && c.x >= Math.min(p.x, q.x) - EPS && c.x <= Math.max(p.x, q.x) + EPS;
+	return Math.abs(c.x - p.x) <= EPS && c.y >= Math.min(p.y, q.y) - EPS && c.y <= Math.max(p.y, q.y) + EPS;
+}
+/** This function drops each point that is on the straight line between the point before it and the point after it. */
+function straighten(p) {
+	const out = [];
+	for (const v of p) {
+		if (out.length > 0 && dist(out[out.length - 1], v) <= EPS) continue;
+		while (out.length >= 2) {
+			const a = out[out.length - 2];
+			const b = out[out.length - 1];
+			const cross = (b.x - a.x) * (v.y - b.y) - (b.y - a.y) * (v.x - b.x);
+			const dot = (b.x - a.x) * (v.x - b.x) + (b.y - a.y) * (v.y - b.y);
+			if (Math.abs(cross) > EPS || dot < 0) break;
+			out.pop();
+		}
+		out.push(v);
+	}
+	return out;
+}
+/**
+* The boundary walk of the repair step (RULE-046): a graph of the sides of the boxes.
+* The vertices are the corners of the boxes. The edges are the parts of each side between two corners on it.
+* A walk on this graph goes along the boundaries of the boxes, and not through a box. Thus it joins two boxes also when the boxes touch.
+* The graph drops each part of a side that goes through another box, so overlapping boxes do not open a way.
+*/
+var BoundaryWalk = class {
+	#points = [];
+	#index = /* @__PURE__ */ new Map();
+	#next = [];
+	/** The vertices on each side of each node, in the order along the side. */
+	#sides = /* @__PURE__ */ new Map();
+	/** This constructor makes the graph of the sides of the nodes. `grid` holds the nodes by their boxes. */
+	constructor(nodes, grid) {
+		for (const n of nodes) for (const c of corners(n.box)) this.#vertex(c);
+		for (const n of nodes) {
+			const cs = corners(n.box);
+			const lists = [];
+			for (const [i, j] of SIDES) {
+				const p = cs[i];
+				const q = cs[j];
+				const on = /* @__PURE__ */ new Set([this.#vertex(p), this.#vertex(q)]);
+				const area = {
+					x: Math.min(p.x, q.x) - 1,
+					y: Math.min(p.y, q.y) - 1,
+					w: Math.abs(q.x - p.x) + 2,
+					h: Math.abs(q.y - p.y) + 2
+				};
+				grid.query(area, (m) => {
+					for (const c of corners(m.box)) if (onSide(c, p, q)) on.add(this.#vertex(c));
+				});
+				const list = [...on].sort((u, v) => dist(p, this.#points[u]) - dist(p, this.#points[v]) || u - v);
+				lists.push(list);
+				for (let k = 1; k < list.length; k++) {
+					const u = list[k - 1];
+					const v = list[k];
+					const a = this.#points[u];
+					const b = this.#points[v];
+					if (dist(a, b) <= EPS || this.#blocked(grid, a, b)) continue;
+					this.#link(u, v);
+				}
+			}
+			this.#sides.set(n, lists);
+		}
+	}
+	/** This method gives the index of the vertex at the point, and adds the vertex if it is new. */
+	#vertex(p) {
+		const k = keyOf(p);
+		let i = this.#index.get(k);
+		if (i === void 0) {
+			i = this.#points.length;
+			this.#points.push(p);
+			this.#next.push([]);
+			this.#index.set(k, i);
+		}
+		return i;
+	}
+	#link(u, v) {
+		const d = dist(this.#points[u], this.#points[v]);
+		if (this.#next[u].some((e) => e.to === v)) return;
+		this.#next[u].push({
+			to: v,
+			d
+		});
+		this.#next[v].push({
+			to: u,
+			d
+		});
+	}
+	/** This method tells if the segment goes through a box, as the rule `no-pass-through` tests it. */
+	#blocked(grid, a, b) {
+		return grid.someSegment(a, b, 0, (n) => segmentHitsBox(a, b, inflate(n.box, -.5)));
+	}
+	/** This method finds the side of `node` that is nearest to `p`. It gives the two vertices of that side that are next to `p`. */
+	#around(node, p) {
+		const list = this.#sides.get(node)?.[SIDE_INDEX[nearestSide(node.box, p)]];
+		if (!list || list.length === 0) return [];
+		const from = this.#points[list[0]];
+		const at = dist(from, p);
+		let k = 0;
+		while (k < list.length && dist(from, this.#points[list[k]]) < at) k++;
+		return [list[k - 1], list[k]].filter((v) => v !== void 0);
+	}
+	/**
+	* This method gives a way along the boundaries of the boxes. The way goes from the point `a` on the box of `s` to the point `b` on the box of `t`.
+	* A point that is not on its box goes first to the nearest point of the boundary.
+	* The method gives `undefined` when no way joins the two boxes.
+	*/
+	path(a, s, b, t) {
+		const a1 = nearestOnBoundary(s.box, a);
+		const b1 = nearestOnBoundary(t.box, b);
+		const n = this.#points.length;
+		const src = n;
+		const dst = n + 1;
+		const extra = /* @__PURE__ */ new Map();
+		const add = (u, v, d) => {
+			if (!extra.has(u)) extra.set(u, []);
+			extra.get(u).push({
+				to: v,
+				d
+			});
+		};
+		for (const v of this.#around(s, a1)) add(src, v, dist(a1, this.#points[v]));
+		for (const v of this.#around(t, b1)) add(v, dst, dist(b1, this.#points[v]));
+		if (!extra.has(src)) return void 0;
+		const pointOf = (i) => i === src ? a1 : i === dst ? b1 : this.#points[i];
+		const best = new Float64Array(n + 2).fill(Infinity);
+		const prev = new Int32Array(n + 2).fill(-1);
+		best[src] = 0;
+		const heap = [[0, src]];
+		const less = (x, y) => x[0] < y[0] || x[0] === y[0] && x[1] < y[1];
+		const pop = () => {
+			const top = heap[0];
+			const last = heap.pop();
+			if (heap.length > 0) {
+				heap[0] = last;
+				let i = 0;
+				for (;;) {
+					const l = 2 * i + 1;
+					const r = l + 1;
+					let m = i;
+					if (l < heap.length && less(heap[l], heap[m])) m = l;
+					if (r < heap.length && less(heap[r], heap[m])) m = r;
+					if (m === i) break;
+					[heap[i], heap[m]] = [heap[m], heap[i]];
+					i = m;
+				}
+			}
+			return top;
+		};
+		const push = (x) => {
+			heap.push(x);
+			let i = heap.length - 1;
+			while (i > 0) {
+				const p = i - 1 >> 1;
+				if (!less(heap[i], heap[p])) break;
+				[heap[i], heap[p]] = [heap[p], heap[i]];
+				i = p;
+			}
+		};
+		while (heap.length > 0) {
+			const [d, u] = pop();
+			if (d > best[u]) continue;
+			if (u === dst) break;
+			const edges = [...u < n ? this.#next[u] : [], ...extra.get(u) ?? []];
+			for (const e of edges) {
+				const nd = d + e.d;
+				if (nd < best[e.to]) {
+					best[e.to] = nd;
+					prev[e.to] = u;
+					push([nd, e.to]);
+				}
+			}
+		}
+		if (prev[dst] === -1) return void 0;
+		const way = [];
+		for (let i = dst; i !== -1; i = prev[i]) way.push(pointOf(i));
+		way.reverse();
+		return straighten([
+			a,
+			...way,
+			b
+		]);
+	}
+};
+/** This function gives the point of the boundary of the box that is nearest to `p`. A point on the boundary gives itself. */
+function nearestOnBoundary(box, p) {
+	const x0 = box.x;
+	const y0 = box.y;
+	const x1 = box.x + box.w;
+	const y1 = box.y + box.h;
+	if (!(p.x > x0 && p.x < x1 && p.y > y0 && p.y < y1)) return {
+		x: Math.min(x1, Math.max(x0, p.x)),
+		y: Math.min(y1, Math.max(y0, p.y))
+	};
+	const side = nearestSide(box, p);
+	if (side === "north") return {
+		x: p.x,
+		y: y0
+	};
+	if (side === "south") return {
+		x: p.x,
+		y: y1
+	};
+	if (side === "west") return {
+		x: x0,
+		y: p.y
+	};
+	return {
+		x: x1,
+		y: p.y
+	};
+}
+// src/repair/index.ts
+/** The repair step makes at most this number of fixes for one route. A route that needs more keeps its base route. */
+const MAX_FIXES = 64;
+/** This function tells if the point is on the boundary of the box, within `TOLERANCE`, as the rule `link-ends` tests it. */
+function onBoundary(p, b) {
+	const inner = inflate(b, -.5);
+	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+}
+/** This function tells if the polyline `p` holds the points of `part` in a row, within `TOLERANCE`. */
+function holds(p, part) {
+	if (part.length === 0) return true;
+	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
+	return false;
+}
+/** This function drops each point that is at the same place as the point before it. */
+function dedupe(p) {
+	const out = [];
+	for (const v of p) if (out.length === 0 || dist(out[out.length - 1], v) > 1e-9) out.push(v);
+	return out;
+}
+/**
+* This function repairs the breaks of the hard rules in the routes of any router (RULE-046). The input result does not change.
+*
+* - It adds a route through the corner graph for each edge without a route (`complete`).
+* - It moves each end back to its fixed plug, or to the nearest point of the box of its node (`ends-at-plugs` and `fixed-plugs`).
+* - It pushes each inner leg out of a box that it goes through, to the near side of the box (`no-pass-through`).
+* - It replaces each other leg through a box with a detour through the corner graph.
+* - When a leg does not repair, it routes the whole route again through the corner graph.
+*   Else it walks along the boundaries of the boxes (`BoundaryWalk`).
+* - A route that still breaks a rule keeps its base route.
+* - It takes an edge out of a run or a bundle when its new route does not hold the run or the trunk (`run-shared` and `bundle-trunk`).
+* - It moves the ends of each level link to the boundaries of its items (`link-ends`).
+*
+* A route without a break does not change. The same input gives the same output.
+*/
+function repairResult(graph, result, options = {}) {
+	const margin = options.margin ?? 5;
+	const doPush = options.push ?? true;
+	const doDetour = options.detour ?? true;
+	const doReroute = options.reroute ?? true;
+	const doWalk = options.walk ?? true;
+	const byId = nodeIndex(graph);
+	const grid = new Grid(180);
+	for (const n of graph.nodes) grid.add(n, n.box);
+	let ways;
+	let walker;
+	const walkerOf = () => walker ??= new BoundaryWalk(graph.nodes, grid);
+	const waysOf = () => ways ??= new WayFinder(graph.nodes, {
+		margin,
+		...options.k === void 0 ? {} : { k: options.k }
+	});
+	const counts = {
+		routes: 0,
+		faulty: 0,
+		snapped: 0,
+		pushed: 0,
+		detoured: 0,
+		rerouted: 0,
+		walked: 0,
+		added: 0,
+		kept: 0,
+		unbundled: 0,
+		linkEnds: 0
+	};
+	const hitOf = (p, q, s, t) => {
+		let hit;
+		grid.querySegment(p, q, 0, (n) => {
+			if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
+		});
+		return hit;
+	};
+	const clear = (p, s, t) => {
+		for (let i = 1; i < p.length; i++) if (hitOf(p[i - 1], p[i], s, t)) return false;
+		return true;
+	};
+	const leave = (p) => {
+		let on;
+		grid.query({
+			x: p.x - TOLERANCE,
+			y: p.y - TOLERANCE,
+			w: 2 * TOLERANCE,
+			h: 2 * TOLERANCE
+		}, (n) => {
+			if (!on && pointBoxDistance(p, n.box) <= .5) on = n;
+		});
+		if (!on) return p;
+		const at = nearestOnBoundary(on.box, p);
+		const nrm = SIDE_NORMAL[nearestSide(on.box, at)];
+		return {
+			x: at.x + nrm.x * margin,
+			y: at.y + nrm.y * margin
+		};
+	};
+	const push = (p, i, box, s, t) => {
+		const a = p[i - 1];
+		const b = p[i];
+		const len = dist(a, b);
+		if (len <= 0) return void 0;
+		const nx = -(b.y - a.y) / len;
+		const ny = (b.x - a.x) / len;
+		const big = inflate(box, margin / 2);
+		const proj = [
+			{
+				x: big.x,
+				y: big.y
+			},
+			{
+				x: big.x + big.w,
+				y: big.y
+			},
+			{
+				x: big.x,
+				y: big.y + big.h
+			},
+			{
+				x: big.x + big.w,
+				y: big.y + big.h
+			}
+		].map((c) => (c.x - a.x) * nx + (c.y - a.y) * ny);
+		const shifts = [Math.max(...proj), Math.min(...proj)].sort((u, v) => Math.abs(u) - Math.abs(v));
+		for (const d of shifts) {
+			const moved = [...p];
+			moved[i - 1] = {
+				x: a.x + nx * d,
+				y: a.y + ny * d
+			};
+			moved[i] = {
+				x: b.x + nx * d,
+				y: b.y + ny * d
+			};
+			if (clear([
+				p[i - 2],
+				moved[i - 1],
+				moved[i],
+				p[i + 1]
+			], s, t)) return moved;
+		}
+	};
+	const detour = (p, i, s, t) => {
+		const a = p[i - 1];
+		const b = p[i];
+		const finder = waysOf();
+		const way = finder.corners.path(leave(a), leave(b));
+		if (!way) return void 0;
+		const mid = dedupe([
+			a,
+			...finder.corners.pull(way),
+			b
+		]);
+		if (!clear(mid, s, t)) return void 0;
+		return [
+			...p.slice(0, i - 1),
+			...mid,
+			...p.slice(i + 1)
+		];
+	};
+	const changed = /* @__PURE__ */ new Set();
+	const repairOne = (r, s, t, e) => {
+		let p = dedupe(r.points);
+		if (p.length < 2) p = [...r.points];
+		let snapped = 0;
+		const first = p[0];
+		const last = p[p.length - 1];
+		const wantA = fixedPortPoint(s, e.source) ?? (pointBoxDistance(first, s.box) > .5 ? nearestOnBoundary(s.box, first) : void 0);
+		const wantB = fixedPortPoint(t, e.target) ?? (pointBoxDistance(last, t.box) > .5 ? nearestOnBoundary(t.box, last) : void 0);
+		if (wantA && dist(wantA, first) > .5) {
+			p[0] = wantA;
+			snapped++;
+		}
+		if (wantB && dist(wantB, last) > .5) {
+			p[p.length - 1] = wantB;
+			snapped++;
+		}
+		let fault = snapped > 0;
+		let pushed = 0;
+		let detoured = 0;
+		let fixes = 0;
+		let failed = false;
+		for (let i = 1; i < p.length;) {
+			const hit = hitOf(p[i - 1], p[i], s, t);
+			if (!hit) {
+				i++;
+				continue;
+			}
+			fault = true;
+			if (++fixes > MAX_FIXES) {
+				failed = true;
+				break;
+			}
+			const moved = doPush && i >= 2 && i + 1 < p.length ? push(p, i, hit.box, s, t) : void 0;
+			if (moved) {
+				p = moved;
+				pushed++;
+				i++;
+				continue;
+			}
+			const around = doDetour ? detour(p, i, s, t) : void 0;
+			if (!around) {
+				failed = true;
+				break;
+			}
+			i += around.length - p.length + 1;
+			p = around;
+			detoured++;
+		}
+		if (!fault) return r;
+		counts.faulty++;
+		let whole;
+		if (failed) {
+			const a = p[0];
+			const b = p[p.length - 1];
+			const finder = doReroute ? waysOf() : void 0;
+			const way = finder?.corners.path(leave(a), leave(b));
+			const again = way ? dedupe([
+				a,
+				...finder.corners.pull(way),
+				b
+			]) : void 0;
+			if (again && clear(again, s, t)) {
+				p = again;
+				whole = "rerouted";
+			} else {
+				const walk = doWalk ? walkerOf().path(a, s, b, t) : void 0;
+				if (walk && clear(walk, s, t)) {
+					p = walk;
+					whole = "walked";
+				}
+			}
+			if (!whole) {
+				counts.kept++;
+				return r;
+			}
+			counts[whole]++;
+		}
+		counts.snapped += snapped;
+		if (!whole) {
+			counts.pushed += pushed;
+			counts.detoured += detoured;
+		}
+		changed.add(r.edge);
+		return {
+			edge: r.edge,
+			points: p
+		};
+	};
+	const routeOf = /* @__PURE__ */ new Map();
+	for (const r of result.routes) if (!routeOf.has(r.edge)) routeOf.set(r.edge, r);
+	const repaired = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const s = byId.get(e.source.node);
+		const t = byId.get(e.target.node);
+		if (!s || !t || repaired.has(e.id)) continue;
+		counts.routes++;
+		const r = routeOf.get(e.id);
+		if (r && r.points.length >= 2) {
+			repaired.set(e.id, repairOne(r, s, t, e));
+			continue;
+		}
+		counts.faulty++;
+		const ps = placePlug(s, e.source, center(t.box));
+		const pt = placePlug(t, e.target, center(s.box));
+		let way = waysOf().between(ps, pt, /* @__PURE__ */ new Set([s, t]));
+		if (!clear(way, s, t)) way = doWalk ? walkerOf().path(ps.point, s, pt.point, t) : void 0;
+		if (!way || !clear(way, s, t)) {
+			counts.kept++;
+			continue;
+		}
+		counts.added++;
+		changed.add(e.id);
+		repaired.set(e.id, {
+			edge: e.id,
+			points: way
+		});
+	}
+	const out = [];
+	const placed = /* @__PURE__ */ new Set();
+	for (const r of result.routes) {
+		const first = !placed.has(r.edge);
+		placed.add(r.edge);
+		out.push(first ? repaired.get(r.edge) ?? r : r);
+	}
+	for (const e of graph.edges) if (!placed.has(e.id) && repaired.has(e.id)) out.push(repaired.get(e.id));
+	const final = /* @__PURE__ */ new Map();
+	for (const r of out) if (!final.has(r.edge)) final.set(r.edge, r);
+	let runs;
+	if (result.runs) {
+		runs = [];
+		for (const run of result.runs) {
+			const edges = run.edges.filter((id) => {
+				if (!changed.has(id)) return true;
+				const r = final.get(id);
+				const ok = r !== void 0 && (holds(r.points, run.points) || holds(r.points, [...run.points].reverse()));
+				if (!ok) counts.unbundled++;
+				return ok;
+			});
+			if (edges.length === run.edges.length) runs.push(run);
+			else if (edges.length >= 2) runs.push({
+				...run,
+				edges
+			});
+			else counts.unbundled += edges.length;
+		}
+	}
+	let bundles;
+	if (result.bundles) {
+		bundles = [];
+		for (const b of result.bundles) {
+			const edges = b.edges.filter((id) => {
+				if (!changed.has(id)) return true;
+				const r = final.get(id);
+				const ok = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((q, i) => dist(q, r.points[i]) <= .5);
+				if (!ok) counts.unbundled++;
+				return ok;
+			});
+			if (edges.length === b.edges.length) bundles.push(b);
+			else if (edges.length > 0) bundles.push({
+				...b,
+				edges
+			});
+		}
+	}
+	let levels;
+	if (result.levels) levels = result.levels.map((level) => {
+		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
+		let touched = false;
+		const links = level.links.map((l) => {
+			const sb = boxOf.get(l.source);
+			const tb = boxOf.get(l.target);
+			const p = l.points;
+			if (!sb || !tb || p.length < 2) return l;
+			const a = onBoundary(p[0], sb) ? void 0 : nearestOnBoundary(sb, p[0]);
+			const b = onBoundary(p[p.length - 1], tb) ? void 0 : nearestOnBoundary(tb, p[p.length - 1]);
+			if (!a && !b) return l;
+			touched = true;
+			counts.linkEnds += (a ? 1 : 0) + (b ? 1 : 0);
+			const points = [...p];
+			if (a) points[0] = a;
+			if (b) points[points.length - 1] = b;
+			return {
+				...l,
+				points
+			};
+		});
+		return touched ? {
+			...level,
+			links
+		} : level;
+	});
+	return {
+		result: {
+			...result,
+			routes: out,
+			...runs ? { runs } : {},
+			...bundles ? { bundles } : {},
+			...levels ? { levels } : {}
+		},
+		counts
+	};
+}
+/** This function gives a router that repairs the routes of `router` with `repairResult`. It keeps the name and the `maxNodes` of the router. */
+function withRepair(router, options = {}) {
+	return {
+		...router,
+		route: (graph) => repairResult(graph, router.route(graph), options).result
+	};
+}
+/**
+* This function gives a router strategy that runs `strategy` and then the repair step (RULE-046) with `repair`.
+* The new strategy has the name `<name>+repair`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+*/
+function repairStrategy(strategy, repair = {}) {
+	return defineStrategy({
+		step: "router",
+		name: `${strategy.name}+repair`,
+		describe: `${strategy.describe} Then one repair step fixes the breaks of the hard rules.`,
+		defaults: { ...strategy.defaults },
+		...strategy.schema === void 0 ? {} : { schema: strategy.schema },
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		run: (graph, options) => repairResult(graph, strategy.run(graph, options), repair).result
+	});
+}
 // src/bench/screen/screen.ts
 /** The steps of the screen, in the order of the pipeline. */
 const SCREEN_STEPS = [
@@ -13049,6 +14909,8 @@ const HIGHWAY_BASE_ROUTERS = [
 	"shared",
 	"trunks"
 ];
+/** The wrappers of `ScreenWrap`. */
+const SCREEN_WRAPS = ["stable", "repair"];
 /** The hard rules of the routes of a router, or of a plan after `follow`. */
 const ROUTE_RULES = [
 	"complete",
@@ -13117,8 +14979,11 @@ function screenRegistry(step, strategies, baseline) {
 }
 /** 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) {
+/**
+* This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
+* A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
+*/
+function rowValues(step, graph, row, base) {
 	const values = { ...row.values };
 	delete values["ms"];
 	if (givesRoutes(step) && row.result) {
@@ -13128,6 +14993,11 @@ function rowValues(step, graph, row) {
 		values["R8.tight"] = q.tight;
 		values["R10.plugAngle"] = q.plugAngle;
 		values["R15.inflections"] = q.inflections;
+		values["B2.share"] = bundledShare(row.result);
+		const st = bundleStretch(row.result.routes, base());
+		values["B3.median"] = st.median;
+		values["B3.q95"] = st.q95;
+		values["B6.max"] = mergeAngle(row.result.routes);
 	}
 	return values;
 }
@@ -13165,6 +15035,21 @@ function rowRules(step, graph, row, again) {
 		deterministic
 	};
 }
+/** This function adds the router `<name>+<w>` for each router of the registry and each wrapper `w`. It gives the new registry and the new names. */
+function wrapRouters(registry, wraps) {
+	const routers = listStrategies(registry, "router");
+	const added = [];
+	for (const w of wraps) for (const s of routers) added.push(w === "stable" ? stableOrderStrategy(s) : repairStrategy(s));
+	return {
+		registry: added.length === 0 ? registry : register(registry, ...added),
+		added: added.map((s) => s.name)
+	};
+}
+/** This function gives the name of a router without the suffix of a wrapper, for example `shared` for `shared+repair`. */
+function unwrappedName(name) {
+	for (const w of SCREEN_WRAPS) if (name.endsWith(`+${w}`)) return name.slice(0, -(w.length + 1));
+	return name;
+}
 /** This function keeps the finite values and gives them the names of a record. */
 function named(values) {
 	const out = {};
@@ -13187,11 +15072,22 @@ function screen(step, strategies = [], options = {}) {
 	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 unwrapped = step === "highway" ? createRegistry([...base, ...listStrategies(screened.registry, "highway").map((s) => highwayRouterStrategy(s))]) : screened.registry;
+	const wrapped = givesRoutes(step) ? wrapRouters(unwrapped, options.wrap ?? []) : {
+		registry: unwrapped,
+		added: []
+	};
+	const registry = wrapped.registry;
+	for (const name of wrapped.added) candidates.add(name);
 	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 stepOf = (name) => baseNames.has(unwrappedName(name)) ? "router" : step;
+	const own = { ...options.options };
+	for (const name of wrapped.added) {
+		const from = options.options?.[unwrappedName(name)];
+		if (own[name] === void 0 && from !== void 0) own[name] = from;
+	}
+	const shuffles = givesRoutes(step) ? Math.max(0, Math.floor(options.shuffles ?? 0)) : 0;
 	const seed = options.seed ?? 1;
 	const log = options.log ?? (() => {});
 	const families = options.families;
@@ -13219,6 +15115,8 @@ function screen(step, strategies = [], options = {}) {
 			graph,
 			results: new Map(cmp.rows.flatMap((r) => r.result ? [[r.strategy, r.result]] : []))
 		});
+		let cornersRoutes;
+		const cornersBase = () => cornersRoutes ??= (cmp.rows.find((r) => r.strategy === "corners" && r.result)?.result ?? asRouter(getStrategy(STRATEGIES, "router", "corners")).route(graph)).routes;
 		cmp.rows.forEach((row, i) => {
 			const strategy = byName.get(row.strategy);
 			const head = {
@@ -13257,9 +15155,26 @@ function screen(step, strategies = [], options = {}) {
 				return;
 			}
 			const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
+			const values = rowValues(step, graph, row, cornersBase);
+			if (shuffles > 0 && row.result) {
+				const router = asRouter(strategy, own[row.strategy]);
+				const f = orderFragility(graph, (g) => router.route(g), {
+					orders: shuffles,
+					seed,
+					base: row.result
+				});
+				Object.assign(values, {
+					"W3.crossings": f.crossings,
+					"W3.detour": f.detour,
+					"W3.inkSaved": f.inkSaved,
+					"W3.ink": f.ink,
+					"W3.changed": f.changed,
+					"W3.poa": f.poa
+				});
+			}
 			const record = {
 				...head,
-				measures: named(rowValues(step, graph, row)),
+				measures: named(values),
 				hard,
 				tolerance: { through: TOLERANCE },
 				deterministic,
@@ -13449,6 +15364,6 @@ function rectScattered(seed, params, set = "xcheck-v1") {
 		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 };
+export { BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BUILT_IN_STRATEGIES, BoundaryWalk, 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, LANE_TRACKS, MEASURES, OUTSIDE_SLACK, Obstacles, PICK, PROPOSED_RULES, ROOM_FAMILIES, ROUTERS, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_WRAPS, 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, benchTracks, bendCount, bendingEnergy, boardGaps, boardUnit, boxExit, boxesOverlap, buildSections, bundleStretch, bundledShare, 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, formatTracks, frechet, g1Defect, g2Defect, gapLaneCounts, 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, laneSeparation, 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, mergeAngle, minHash, modularity, mulberry32, namedObjectives, nearestOnBoundary, nearestSide, nestedGridBoard, nestingFaults, nodeIndex, offsetPolyline, openGaps, optionDefaults, orderChanges, orderFragility, 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, repairResult, repairStrategy, rng, roomDemand, roomLinks, roomOrderFaults, roomStrategies, round3, roundCorners, roundedCurve, routeInStableOrder, routeMeasures, routeStability, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runSuite, sameData, sampleCurve, screen, screenInputs, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, sha256Hex, sharedRouter, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, slackSettings, smoothCurve, splineCurve, splitPoint, stableOrder, stableOrderStrategy, stepSeed, straightCurve, straightRouter, stretchSettings, suiteFronts, sumFaults, summarize, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, toSvgPath, totalTurn, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, withBends, withRepair, withStableOrder };
 
 //# sourceMappingURL=index.js.map