@mark1russell7/highways 0.9.4 → 0.9.6

package/build/index.js

@@ -351,10 +351,20 @@ function portOffset(box, port) {
 		along: port.along
 	});
 }
-/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+/**
+* This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`.
+* It also throws a `RangeError` for a bad `range` of a plug. A bad range has a value that is not finite or is outside 0 to 1, or a start after its end.
+*/
 function checkPort(node, port) {
-	if (port.along === void 0) return;
 	const at = `The plug "${port.id}" of the node "${node.id}"`;
+	if (port.range !== void 0) {
+		const r = port.range;
+		if (!Array.isArray(r) || r.length !== 2 || !r.every((v) => typeof v === "number" && Number.isFinite(v))) throw new RangeError(`${at} has the range ${JSON.stringify(r)}. It must be two finite numbers.`);
+		const [lo, hi] = r;
+		if (lo < 0 || hi > 1) throw new RangeError(`${at} has the range [${lo}, ${hi}]. It must be in the side, from 0 to 1.`);
+		if (lo > hi) throw new RangeError(`${at} has the range [${lo}, ${hi}]. Its start must not be after its end.`);
+	}
+	if (port.along === void 0) return;
 	if (typeof port.along !== "number" || !Number.isFinite(port.along) || port.along < 0 || port.along > 1) throw new RangeError(`${at} has the along value ${String(port.along)}. It must be a finite number from 0 to 1.`);
 	if (port.side === void 0) throw new RangeError(`${at} has an along value and no side. A plug with along needs a side.`);
 	if (port.at !== void 0) throw new RangeError(`${at} has an along value and an at point. Give one of the two.`);
@@ -362,7 +372,7 @@ function checkPort(node, port) {
 /**
 * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
 * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
-* It throws a `RangeError` for a bad `along` (`checkPort`).
+* It throws a `RangeError` for a bad `along` or a bad `range` (`checkPort`).
 */
 function resolvePorts(graph) {
 	let found = false;
@@ -913,6 +923,115 @@ const CASES = [
 		make: () => manyGroupsBoard()
 	}
 ];
+// src/plugs/range.ts
+/** The tolerance of the comparisons of places along a side. */
+const EPS$9 = 1e-9;
+/** This function gives the axis along a side. */
+function alongAxis(side) {
+	return side === "east" || side === "west" ? "y" : "x";
+}
+/** This function gives the port of an end, or `undefined` when the end has no port or the node has no such port. */
+function portOfEnd(node, end) {
+	return end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+}
+/**
+* This function gives the interval of a plug with a range, on the axis along its side, or `undefined` for a port without a range.
+* The interval is the range of the port, without the corner insets of the side.
+* When the range is all in a corner inset, the interval is the range.
+*/
+function rangeInterval(box, side, port, inset = 6) {
+	const range = port?.range;
+	if (range === void 0) return void 0;
+	const along = alongAxis(side);
+	const start = along === "y" ? box.y : box.x;
+	const len = along === "y" ? box.h : box.w;
+	const m = Math.min(inset, len / 4);
+	const lo = start + range[0] * len;
+	const hi = start + range[1] * len;
+	const a = Math.max(lo, start + m);
+	const b = Math.min(hi, start + len - m);
+	return a <= b ? [a, b] : [lo, hi];
+}
+/** This function moves a point of a side into the interval of its range, on the axis along the side. A point of a port without a range stays. */
+function clampToRange(box, side, port, point, inset = 6) {
+	const r = rangeInterval(box, side, port, inset);
+	if (!r) return point;
+	const along = alongAxis(side);
+	const v = Math.max(r[0], Math.min(r[1], point[along]));
+	return along === "y" ? {
+		x: point.x,
+		y: v
+	} : {
+		x: v,
+		y: point.y
+	};
+}
+/**
+* This function places `ideal.length` plugs of one side in their given order. The plug `i` stays in the interval from `lo[i]` to `hi[i]`.
+* Two neighbours are at least `gap` apart. When the intervals are too short for the gap, the gap shrinks evenly to the largest gap that they let.
+* The sum of the squares of the moves from the ideal places is the least.
+*
+* When the order cannot keep each plug in its interval, the plugs take the order of their ideal places in their intervals. Thus the intervals win over the order.
+* The result is in the order of `ideal`.
+*/
+function placeInIntervals(ideal, lo, hi, gap) {
+	const k = ideal.length;
+	if (k === 0) return [];
+	let order = ideal.map((_, i) => i);
+	let most = -Infinity;
+	let broken = false;
+	for (const i of order) {
+		if (hi[i] < most - EPS$9) broken = true;
+		most = Math.max(most, lo[i]);
+	}
+	if (broken) {
+		const c = order.map((i) => Math.max(lo[i], Math.min(hi[i], ideal[i])));
+		order = [...order].sort((a, b) => c[a] - c[b] || a - b);
+	}
+	let s = Math.max(0, gap);
+	for (let i = 1; i < k; i++) {
+		const hiI = hi[order[i]];
+		for (let j = 0; j < i; j++) s = Math.min(s, (hiI - lo[order[j]]) / (i - j));
+	}
+	s = Math.max(0, s);
+	const lower = new Array(k);
+	const upper = new Array(k);
+	let run = -Infinity;
+	for (let i = 0; i < k; i++) lower[i] = run = Math.max(run, lo[order[i]] - i * s);
+	run = Infinity;
+	for (let i = k - 1; i >= 0; i--) upper[i] = run = Math.min(run, hi[order[i]] - i * s);
+	const sum = [];
+	const size = [];
+	const blockLo = [];
+	const blockHi = [];
+	const value = [];
+	const clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+	for (let i = 0; i < k; i++) {
+		sum.push(ideal[order[i]] - i * s);
+		size.push(1);
+		blockLo.push(lower[i]);
+		blockHi.push(upper[i]);
+		value.push(clamp(sum[sum.length - 1], lower[i], upper[i]));
+		while (value.length > 1 && value[value.length - 2] > value[value.length - 1]) {
+			const t = value.length - 1;
+			sum[t - 1] += sum[t];
+			size[t - 1] += size[t];
+			blockLo[t - 1] = blockLo[t];
+			value[t - 1] = clamp(sum[t - 1] / size[t - 1], blockLo[t - 1], blockHi[t - 1]);
+			sum.pop();
+			size.pop();
+			blockLo.pop();
+			blockHi.pop();
+			value.pop();
+		}
+	}
+	const out = new Array(k);
+	let i = 0;
+	value.forEach((v, b) => {
+		for (let j = 0; j < size[b]; j++, i++) out[order[i]] = v + i * s;
+	});
+	return out;
+}
 // src/plugs.ts
 /** The outward normal of each side, in a frame with the y axis down. */
 const SIDE_NORMAL = {
@@ -983,7 +1102,7 @@ function pointOnSide(box, side, toward, inset = 6) {
 }
 /**
 * This function places the plug of one end of an edge. A fixed plug stays at its point. A plug with a side stays on that side.
-* The router places a free plug on the side that faces `toward`.
+* The router places a free plug on the side that faces `toward`. A free plug of a port with a `range` stays in that range (`clampToRange`).
 */
 function placePlug(node, end, toward) {
 	const fixed = fixedPortPoint(node, end);
@@ -993,8 +1112,9 @@ function placePlug(node, end, toward) {
 		normal: SIDE_NORMAL[port?.side ?? nearestSide(node.box, fixed)]
 	};
 	const side = port?.side ?? sideToward(node.box, toward);
+	const point = pointOnSide(node.box, side, toward);
 	return {
-		point: pointOnSide(node.box, side, toward),
+		point: port?.range === void 0 ? point : clampToRange(node.box, side, port, point),
 		normal: SIDE_NORMAL[side]
 	};
 }
@@ -4321,7 +4441,7 @@ const byDataGroup = (node) => {
 	return typeof group === "string" ? group : void 0;
 };
 /** This function gives the bounding box of the boxes of the nodes of the list. */
-function boundsOf(nodes, list) {
+function boundsOf$2(nodes, list) {
 	let x0 = Infinity;
 	let y0 = Infinity;
 	let x1 = -Infinity;
@@ -4364,7 +4484,7 @@ function keyedSections(nodes, options = {}) {
 	return {
 		id: "s",
 		depth: 0,
-		cell: boundsOf(nodes, nodes.map((_, i) => i)),
+		cell: boundsOf$2(nodes, nodes.map((_, i) => i)),
 		nodes: nodes.map((_, i) => i),
 		children
 	};
@@ -4374,7 +4494,7 @@ function group(nodes, id, list, split) {
 	if (!split) return {
 		id,
 		depth: 1,
-		cell: boundsOf(nodes, list),
+		cell: boundsOf$2(nodes, list),
 		nodes: list,
 		children: []
 	};
@@ -4953,6 +5073,7 @@ function isotonic(v) {
 * 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.
 * A plug stays `inset` from the corners of its side, or a quarter of the side when the side is short.
+* A plug of a port with a `range` stays in its range (PORT-RANGE), and the plugs keep their order and the gap (`placeInIntervals`).
 */
 function spacePlugs(ends, gap, inset = 6) {
 	const sides = /* @__PURE__ */ new Map();
@@ -4985,18 +5106,21 @@ function spacePlugs(ends, gap, inset = 6) {
 			side.items.push([
 				i,
 				k,
-				other.point
+				other.point,
+				portOfEnd(node, end)
 			]);
 		}
 	});
 	for (const { node, normal, items } of sides.values()) {
-		if (items.length < 2) continue;
+		const ranged = items.some((x) => x[3]?.range !== void 0);
+		if (items.length < 2 && !ranged) 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]);
+		const ideal = items.map(([i, k]) => ends[i][k].point[along]);
+		const placed = ranged ? spaceInRanges(b, normal, items, ideal, start + m, start + len - m, gap, inset) : justifyPlugs(ideal, start + m, start + len - m, gap, (j) => items[j][2][along]);
 		items.forEach(([i, k], j) => {
 			const old = ends[i][k];
 			ends[i][k] = {
@@ -5013,6 +5137,28 @@ function spacePlugs(ends, gap, inset = 6) {
 	}
 }
 /**
+* This function places the free plugs of one side with ranges (PORT-RANGE). The order is the order of `justifyPlugs`.
+* Each plug stays in the interval of its range, or in the room of the side without a range.
+*/
+function spaceInRanges(box, normal, items, ideal, lo, hi, gap, inset) {
+	const side = sideOfNormal(normal);
+	const along = alongAxis(side);
+	const order = ideal.map((_, i) => i).sort((a, b) => ideal[a] - ideal[b] || items[a][2][along] - items[b][2][along] || a - b);
+	const span = order.map((j) => rangeInterval(box, side, items[j][3], inset) ?? [lo, hi]);
+	const at = placeInIntervals(order.map((j) => ideal[j]), span.map((r) => r[0]), span.map((r) => r[1]), gap);
+	const out = new Array(ideal.length);
+	order.forEach((j, i) => {
+		out[j] = at[i];
+	});
+	return out;
+}
+/** This function gives the side of an outward normal. */
+function sideOfNormal(n) {
+	if (n.x > 0) return "east";
+	if (n.x < 0) return "west";
+	return n.y > 0 ? "south" : "north";
+}
+/**
 * This function gives the plugs of the plug strategy `justify` (WILD-002): the plugs of `facing`, then the gaps of `spacePlugs`.
 * The router `corners` with the option `plugGap` gives the same plugs.
 */
@@ -5048,7 +5194,8 @@ function justifyEnds(input, options = {}) {
 /** 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 port = end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+	const side = 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;
@@ -5056,6 +5203,23 @@ function freeSide(node, end, toward, inset) {
 	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);
+	const range = port?.range === void 0 ? void 0 : rangeInterval(b, side, port, inset);
+	if (range) {
+		const facing = clampToRange(b, side, port, point, inset);
+		return {
+			node,
+			side,
+			normal: SIDE_NORMAL[side],
+			along,
+			at,
+			lo: range[0],
+			hi: range[1],
+			facing: {
+				point: facing,
+				normal: SIDE_NORMAL[side]
+			}
+		};
+	}
 	return {
 		node,
 		side,
@@ -5215,7 +5379,7 @@ function sideEnds(input, options = {}) {
 // src/routers/gutter.ts
 /** The default cost of one bend of the gutter mode. */
 const GUTTER_BEND_COST = 16;
-const EPS$6 = 1e-6;
+const EPS$8 = 1e-6;
 /** The directions of a step: east, south, west and north, with the y axis down. */
 const DX = [
 	1,
@@ -5239,7 +5403,7 @@ const DY = [
 */
 function gutterRoutes(frame, nodes, edges, options = {}) {
 	const bend = options.bendCost ?? 16;
-	const boxes = nodes.map((n) => n.box).filter((b) => b.w > EPS$6 && b.h > EPS$6);
+	const boxes = nodes.map((n) => n.box).filter((b) => b.w > EPS$8 && b.h > EPS$8);
 	const entries = edges.map(entriesOf);
 	const xs = /* @__PURE__ */ new Set();
 	const ys = /* @__PURE__ */ new Set();
@@ -5257,7 +5421,7 @@ function gutterRoutes(frame, nodes, edges, options = {}) {
 		const cuts = [lo, lo + size];
 		for (const b of boxes) for (const v of key === "x" ? [b.x, b.x + b.w] : [b.y, b.y + b.h]) if (v > lo && v < lo + size) cuts.push(v);
 		cuts.sort((a, b) => a - b);
-		for (let i = 1; i < cuts.length; i++) if (cuts[i] - cuts[i - 1] > EPS$6) lines.add((cuts[i] + cuts[i - 1]) / 2);
+		for (let i = 1; i < cuts.length; i++) if (cuts[i] - cuts[i - 1] > EPS$8) lines.add((cuts[i] + cuts[i - 1]) / 2);
 	}
 	edges.forEach((e, i) => {
 		for (const { point, normal } of [{
@@ -5320,19 +5484,19 @@ function stubOnly(e, boxes) {
 	const n = e.plug.normal;
 	let q;
 	if (n.x !== 0) {
-		if (!(p.y > b.y + EPS$6 && p.y < b.y + b.h - EPS$6)) return void 0;
+		if (!(p.y > b.y + EPS$8 && p.y < b.y + b.h - EPS$8)) return void 0;
 		q = {
 			x: n.x > 0 ? b.x + b.w : b.x,
 			y: p.y
 		};
-		if ((q.x - p.x) * n.x > EPS$6) return void 0;
+		if ((q.x - p.x) * n.x > EPS$8) return void 0;
 	} else {
-		if (!(p.x > b.x + EPS$6 && p.x < b.x + b.w - EPS$6)) return void 0;
+		if (!(p.x > b.x + EPS$8 && p.x < b.x + b.w - EPS$8)) return void 0;
 		q = {
 			x: p.x,
 			y: n.y > 0 ? b.y + b.h : b.y
 		};
-		if ((q.y - p.y) * n.y > EPS$6) return void 0;
+		if ((q.y - p.y) * n.y > EPS$8) return void 0;
 	}
 	for (const o of boxes) if (o !== b && blocks(p, q, o)) return void 0;
 	return [p, q];
@@ -5340,11 +5504,11 @@ function stubOnly(e, boxes) {
 /** This function tells if the axis-parallel segment `ab` meets the closed box `o` along a part longer than a tiny length. A segment along a side meets the box. */
 function blocks(a, b, o) {
 	if (a.y === b.y) {
-		if (a.y < o.y - EPS$6 || a.y > o.y + o.h + EPS$6) return false;
-		return Math.min(Math.max(a.x, b.x), o.x + o.w) - Math.max(Math.min(a.x, b.x), o.x) > EPS$6;
+		if (a.y < o.y - EPS$8 || a.y > o.y + o.h + EPS$8) return false;
+		return Math.min(Math.max(a.x, b.x), o.x + o.w) - Math.max(Math.min(a.x, b.x), o.x) > EPS$8;
 	}
-	if (a.x < o.x - EPS$6 || a.x > o.x + o.w + EPS$6) return false;
-	return Math.min(Math.max(a.y, b.y), o.y + o.h) - Math.max(Math.min(a.y, b.y), o.y) > EPS$6;
+	if (a.x < o.x - EPS$8 || a.x > o.x + o.w + EPS$8) return false;
+	return Math.min(Math.max(a.y, b.y), o.y + o.h) - Math.max(Math.min(a.y, b.y), o.y) > EPS$8;
 }
 /** This function gives the direction index of a unit normal: 0 east, 1 south, 2 west, 3 north. */
 function dirOf(n) {
@@ -5363,12 +5527,12 @@ var Grid$1 = class {
 		this.#free = new Uint8Array(xs.length * ys.length);
 		for (let i = 0; i < ys.length; i++) {
 			const y = ys[i];
-			if (y <= frame.y + EPS$6 || y >= frame.y + frame.h - EPS$6) continue;
+			if (y <= frame.y + EPS$8 || y >= frame.y + frame.h - EPS$8) continue;
 			for (let j = 0; j < xs.length; j++) {
 				const x = xs[j];
-				if (x <= frame.x + EPS$6 || x >= frame.x + frame.w - EPS$6) continue;
+				if (x <= frame.x + EPS$8 || x >= frame.x + frame.w - EPS$8) continue;
 				let free = true;
-				for (const b of boxes) if (x >= b.x - EPS$6 && x <= b.x + b.w + EPS$6 && y >= b.y - EPS$6 && y <= b.y + b.h + EPS$6) {
+				for (const b of boxes) if (x >= b.x - EPS$8 && x <= b.x + b.w + EPS$8 && y >= b.y - EPS$8 && y <= b.y + b.h + EPS$8) {
 					free = false;
 					break;
 				}
@@ -5405,11 +5569,11 @@ var Grid$1 = class {
 		const sign = d < 2 ? 1 : -1;
 		let k = -1;
 		if (sign > 0) {
-			for (let m = 0; m < list.length; m++) if (list[m] > v + EPS$6) {
+			for (let m = 0; m < list.length; m++) if (list[m] > v + EPS$8) {
 				k = m;
 				break;
 			}
-		} else for (let m = list.length - 1; m >= 0; m--) if (list[m] < v - EPS$6) {
+		} else for (let m = list.length - 1; m >= 0; m--) if (list[m] < v - EPS$8) {
 			k = m;
 			break;
 		}
@@ -5608,7 +5772,7 @@ function lanes(frame, boxes, edges, entries, routes, laneGap) {
 		const b = legs[j];
 		if (a.route === b.route || a.horizontal !== b.horizontal) continue;
 		if (Math.min(a.s1, b.s1) - Math.max(a.s0, b.s0) <= -laneGap) continue;
-		if (a.across < b.lo - EPS$6 || a.across > b.hi + EPS$6 || b.across < a.lo - EPS$6 || b.across > a.hi + EPS$6) continue;
+		if (a.across < b.lo - EPS$8 || a.across > b.hi + EPS$8 || b.across < a.lo - EPS$8 || b.across > a.hi + EPS$8) continue;
 		parent[root(i)] = root(j);
 	}
 	const groups = /* @__PURE__ */ new Map();
@@ -5648,9 +5812,9 @@ function free(frame, boxes, horizontal, across, s0, s1) {
 			b.x,
 			b.w
 		];
-		if (Math.min(s1, bs + bl) - Math.max(s0, bs) <= EPS$6) continue;
-		if (cs + cl <= across + EPS$6) lo = Math.max(lo, cs + cl);
-		if (cs >= across - EPS$6) hi = Math.min(hi, cs);
+		if (Math.min(s1, bs + bl) - Math.max(s0, bs) <= EPS$8) continue;
+		if (cs + cl <= across + EPS$8) lo = Math.max(lo, cs + cl);
+		if (cs >= across - EPS$8) hi = Math.min(hi, cs);
 	}
 	return [lo, hi];
 }
@@ -5661,8 +5825,8 @@ function want(a, b) {
 		if (inner(sb, sa)) return -tb;
 		return ta === tb ? 0 : Math.sign(ta - tb);
 	};
-	const left = side(a.s0, b.s0, a.t0, b.t0, (x, y) => x > y + EPS$6);
-	const right = side(a.s1, b.s1, a.t1, b.t1, (x, y) => x < y - EPS$6);
+	const left = side(a.s0, b.s0, a.t0, b.t0, (x, y) => x > y + EPS$8);
+	const right = side(a.s1, b.s1, a.t1, b.t1, (x, y) => x < y - EPS$8);
 	if (left !== 0 && right !== 0 && left !== right) return left;
 	return left || right;
 }
@@ -5680,7 +5844,7 @@ function place(group, laneGap) {
 		const a = group[i];
 		const b = group[j];
 		if (a.pinned && b.pinned) {
-			if (Math.abs(a.across - b.across) <= EPS$6) continue;
+			if (Math.abs(a.across - b.across) <= EPS$8) continue;
 			const [x, y] = a.across < b.across ? [i, j] : [j, i];
 			hard[x].push(y);
 			hardIn[y]++;
@@ -5698,7 +5862,7 @@ function place(group, laneGap) {
 		let best = -1;
 		for (let i = 0; i < n; i++) {
 			if (done[i] || hardIn[i] > 0) continue;
-			if (best < 0 || softIn[i] < softIn[best] || softIn[i] === softIn[best] && group[i].across < group[best].across - EPS$6) best = i;
+			if (best < 0 || softIn[i] < softIn[best] || softIn[i] === softIn[best] && group[i].across < group[best].across - EPS$8) best = i;
 		}
 		done[best] = true;
 		order.push(best);
@@ -5711,7 +5875,7 @@ function place(group, laneGap) {
 		let to = k + 1;
 		for (let m = k + 1; m < order.length; m++) {
 			const b = group[order[m]];
-			if (b.pinned && Math.abs(b.across - a.across) <= EPS$6) order.splice(to++, 0, ...order.splice(m, 1));
+			if (b.pinned && Math.abs(b.across - a.across) <= EPS$8) order.splice(to++, 0, ...order.splice(m, 1));
 		}
 		k = to - 1;
 	}
@@ -5731,7 +5895,7 @@ function place(group, laneGap) {
 			const width = (run.length - 1) * s;
 			const mean = run.reduce((t, r) => t + group[r].across, 0) / run.length;
 			const first = Math.min(Math.max(mean - width / 2, lo + s), hi - s - width);
-			run.forEach((r, m) => at[r] = room > EPS$6 && s > 0 ? first + m * s : group[r].across);
+			run.forEach((r, m) => at[r] = room > EPS$8 && s > 0 ? first + m * s : group[r].across);
 		}
 		if (k < n) at[i] = group[i].across;
 		start = k + 1;
@@ -5741,7 +5905,7 @@ function place(group, laneGap) {
 }
 // src/routers/frames.ts
 /** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
-const EPS$5 = 1e-6;
+const EPS$7 = 1e-6;
 /**
 * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
 * the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
@@ -5866,7 +6030,7 @@ function makeRoom$1(f, chain, children, byId, inset, options) {
 	const margin = options.margin ?? 5;
 	const bounds = shrink(f.box, inset);
 	const nodes = roomNodes(f, chain, children, byId, bounds, options);
-	const w = shrink(bounds, -(margin / 2 + EPS$5));
+	const w = shrink(bounds, -(margin / 2 + EPS$7));
 	const t = 2 * margin + 1;
 	const walls = [
 		{
@@ -6225,14 +6389,14 @@ const LEVEL_LINK_DEFAULTS = Object.freeze({
 	plugInset: 6,
 	throughCost: 8
 });
-const EPS$4 = 1e-6;
+const EPS$6 = 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.
 * A way of two points or more keeps two points: its first point and its last point.
 * Two items that touch can get a link of zero length, and such a link keeps an end on each item.
 */
-function tidy(p) {
+function tidy$1(p) {
 	const out = tidyPoints(p);
 	return out.length === 1 && p.length > 1 ? [p[0], p[p.length - 1]] : out;
 }
@@ -6240,15 +6404,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$4) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$6) 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$4 * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$6 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$4) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$6) continue;
 		out.push(q);
 	}
 	return out;
@@ -6390,7 +6554,7 @@ function fewerFar(ways, s, t, way, cost, limit) {
 	const far = cost * ways.size;
 	const clipped = clip(ways.soft().path(center(s.box), center(t.box), (n) => n === s || n === t ? 0 : near.has(n) ? ways.size : far), s.box, t.box);
 	if (!clipped) return way;
-	const soft = tidy(pullThrough(ways, clipped, s, t));
+	const soft = tidy$1(pullThrough(ways, clipped, s, t));
 	if (goesOutAndBack(soft) && !goesOutAndBack(way)) return way;
 	if (detour(soft) > limit) return way;
 	return boxesThrough(ways, soft, s, t, near).far < before.far ? soft : way;
@@ -6621,7 +6785,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$4);
+	return out.filter(([a, b]) => b - a > EPS$6);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -6707,7 +6871,7 @@ function quickWay(ways, e) {
 	const near = Math.min(dist(e.ps.point, e.a), dist(e.pt.point, e.b));
 	const pad = Math.max(0, Math.min(ways.margin / 2, near - 1));
 	const legs = square(e.a, e.b, ways.obstacles, pad, axisOf(e.ps.normal), axisOf(e.pt.normal));
-	return legs && tidy([
+	return legs && tidy$1([
 		e.ps.point,
 		e.a,
 		...legs,
@@ -6720,7 +6884,7 @@ function quickWay(ways, e) {
 */
 function pulled(ways, ps, path, pt) {
 	const legs = squarePull(path, ways.obstacles, ways.margin / 2, axisOf(ps.normal), axisOf(pt.normal));
-	return tidy([
+	return tidy$1([
 		ps.point,
 		...legs,
 		pt.point
@@ -6753,7 +6917,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$4 ? "x" : Math.abs(end.x - before.x) < EPS$4 ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$6 ? "x" : Math.abs(end.x - before.x) < EPS$6 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -6763,7 +6927,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$4 || Math.abs(a.y - b.y) < EPS$4) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$6 || Math.abs(a.y - b.y) < EPS$6) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -8154,7 +8318,8 @@ function sharedRouter(options, negotiation, hooks) {
 						seq: way,
 						ids: way.map((p, i) => i === 0 || i === way.length - 1 ? endId(p) : index.get(p))
 					};
-				}
+				},
+				width: (i, j) => widthOf(i, j)
 			};
 			const sorted = orderWays(all, options.order ?? "span", graph);
 			const order = hooks?.order ? hooks.order(sorted, search) : sorted;
@@ -8931,6 +9096,1020 @@ const annealingStrategy = defineStrategy({
 		rule: byCollection
 	}).route(graph)
 });
+// src/routers/canals/index.ts
+/** The default options of the router `canals`. */
+const CANAL_DEFAULTS = Object.freeze({
+	mu: 2,
+	steps: 60,
+	decay: 1,
+	minMembers: 3
+});
+/** The declarations of the options of the router `canals` (NAT-004). */
+const CANAL_SCHEMA = {
+	mu: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .5,
+		marks: [
+			1,
+			2,
+			3
+		],
+		default: 2,
+		describe: "The exponent of the flux in the growth of a conductance. A value above 1 gives a tree."
+	},
+	steps: {
+		type: "integer",
+		min: 30,
+		max: 150,
+		step: 10,
+		marks: [
+			30,
+			60,
+			150
+		],
+		default: 60,
+		describe: "The largest number of updates of the conductances."
+	},
+	decay: {
+		type: "number",
+		min: .5,
+		max: 2,
+		step: .25,
+		marks: [
+			.5,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The decay of a conductance."
+	},
+	minMembers: {
+		type: "integer",
+		min: 2,
+		max: 8,
+		step: 1,
+		marks: [
+			2,
+			3,
+			5,
+			8
+		],
+		default: 3,
+		describe: "A hub has this number of edges of one key or more."
+	}
+};
+/** The time step of one update of the conductances. */
+const DT = .5;
+/** The gain of a conductance in the cost of a link: a link with the conductance `D` costs `d / (1 + GAIN × D)`. */
+const GAIN = 4;
+/** The cost share of a link that another way of the key uses, as the default `discount` of `shared`. */
+const SHARE = .5;
+/** The updates with no change of a way, after which the updates stop. */
+const PATIENCE = 3;
+/**
+* This function gives `x^mu` for `x` from 0 to 1 and `mu` in steps of 0.5, with only `*` and `Math.sqrt`.
+* These operations are exact to the last bit on each platform, so a decision does not depend on the engine.
+*/
+function halfPower(x, mu) {
+	const twice = Math.max(2, Math.min(6, Math.round(mu * 2)));
+	let out = 1;
+	for (let i = 0; i < Math.floor(twice / 2); i++) out *= x;
+	return twice % 2 === 1 ? out * Math.sqrt(x) : out;
+}
+/**
+* This function gives the hubs of the ways. In each key, the node with the most ends is a hub when it has `minMembers` edges or more.
+* Its edges leave the key, and the next hub of the key comes from the edges that stay. A tie goes to the smaller node id.
+* An edge with no key is in no hub.
+*/
+function canalHubs(ways, minMembers) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const w of ways) {
+		if (!w.found || w.ids.length < 2 || w.key.startsWith("\0")) continue;
+		const list = byKey.get(w.key);
+		if (list) list.push(w);
+		else byKey.set(w.key, [w]);
+	}
+	const out = [];
+	for (const key of [...byKey.keys()].sort()) {
+		let left = byKey.get(key);
+		for (;;) {
+			const count = /* @__PURE__ */ new Map();
+			for (const w of left) for (const n of /* @__PURE__ */ new Set([w.edge.source.node, w.edge.target.node])) count.set(n, (count.get(n) ?? 0) + 1);
+			let node;
+			let most = 0;
+			for (const [n, c] of count) if (c > most || c === most && node !== void 0 && n < node) [node, most] = [n, c];
+			if (node === void 0 || most < Math.max(2, minMembers)) break;
+			const hub = node;
+			const members = left.filter((w) => w.edge.source.node === hub || w.edge.target.node === hub);
+			out.push({
+				node: hub,
+				key,
+				ways: [...members].sort((a, b) => a.edge.id < b.edge.id ? -1 : a.edge.id > b.edge.id ? 1 : 0)
+			});
+			left = left.filter((w) => !members.includes(w));
+		}
+	}
+	return out;
+}
+/**
+* This function grows a feeder tree to each hub (NAT-004, after the canalization of Sachs 1981 and Mitchison 1980).
+* Each member edge is a source of one unit of flux, and the hub is the sink. The flux of a link is the share of the members whose ways use it.
+* At each update, each conductance changes by `DT × (flux^mu - decay × D)`, and each member finds its way again with the cost `d / (1 + GAIN × D)`.
+* A link that another way of the key uses costs half, as in `shared`.
+* With `mu` above 1, a link with more flux grows faster, so the ways gather into one tree. The updates stop after `steps`, or when no way changes for 3 updates.
+*/
+function canalWays(ways, search, options = {}) {
+	const o = {
+		...CANAL_DEFAULTS,
+		...options
+	};
+	const n = search.corners;
+	const linksOf = (w) => {
+		const out = /* @__PURE__ */ new Set();
+		for (let i = 1; i < w.ids.length; i++) if (w.ids[i - 1] < n && w.ids[i] < n) out.add(search.link(w.ids[i - 1], w.ids[i]));
+		return [...out];
+	};
+	const usage = /* @__PURE__ */ new Map();
+	const use = (w, add) => {
+		let m = usage.get(w.key);
+		if (!m) usage.set(w.key, m = /* @__PURE__ */ new Map());
+		for (const k of linksOf(w)) m.set(k, (m.get(k) ?? 0) + add);
+	};
+	for (const w of ways) if (w.found) use(w, 1);
+	for (const hub of canalHubs(ways, Math.floor(o.minMembers))) {
+		const members = hub.ways;
+		const used = usage.get(hub.key);
+		const conductance = /* @__PURE__ */ new Map();
+		let calm = 0;
+		for (let step = 0; step < Math.max(1, Math.floor(o.steps)); step++) {
+			const flux = /* @__PURE__ */ new Map();
+			for (const w of members) {
+				const seen = /* @__PURE__ */ new Set();
+				for (let i = 1; i < w.ids.length; i++) {
+					const a = w.ids[i - 1];
+					const b = w.ids[i];
+					if (a >= n || b >= n) continue;
+					const k = search.link(a, b);
+					if (seen.has(k)) continue;
+					seen.add(k);
+					flux.set(k, (flux.get(k) ?? 0) + 1);
+				}
+			}
+			for (const k of /* @__PURE__ */ new Set([...conductance.keys(), ...flux.keys()])) {
+				const phi = (flux.get(k) ?? 0) / members.length;
+				const d = conductance.get(k) ?? 0;
+				const next = d + DT * (halfPower(phi, o.mu) - o.decay * d);
+				if (next > 1e-6) conductance.set(k, next);
+				else conductance.delete(k);
+			}
+			let top = 0;
+			for (const d of conductance.values()) top = Math.max(top, d);
+			const floor = SHARE / (1 + GAIN * top);
+			let changed = 0;
+			for (const w of members) {
+				use(w, -1);
+				const next = search.find(w, (i, j, d) => {
+					const k = search.link(i, j);
+					return ((used.get(k) ?? 0) > 0 ? SHARE * d : d) / (1 + GAIN * (conductance.get(k) ?? 0));
+				}, floor);
+				if (next) {
+					if (next.ids.length !== w.ids.length || next.ids.some((id, i) => id !== w.ids[i])) changed++;
+					w.seq = next.seq;
+					w.ids = next.ids;
+				}
+				use(w, 1);
+			}
+			calm = changed === 0 ? calm + 1 : 0;
+			if (calm >= PATIENCE) break;
+		}
+	}
+}
+/**
+* This function makes the router `canals` (NAT-004). It is the router `shared`, then the feeder trees of `canalWays` to the hubs of each key.
+* The runs and the bundles come from the ways after the trees.
+*/
+function canalRouter(options) {
+	const o = {
+		...CANAL_DEFAULTS,
+		...options
+	};
+	return sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	}, void 0, { refine: (ways, search) => canalWays(ways, search, o) });
+}
+/**
+* The router strategy `canals` (NAT-004), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+* A screen module or a consumer adds it to a registry.
+*/
+const canalStrategy = defineStrategy({
+	step: "router",
+	name: "canals",
+	describe: "Canalization feeder trees (NAT-004). The members of a hub are sources of flux, and the links with more flux get cheaper until the ways make one tree.",
+	defaults: { ...CANAL_DEFAULTS },
+	schema: CANAL_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => canalRouter({
+		...o,
+		name: "canals",
+		rule: byCollection
+	}).route(graph)
+});
+// src/bench/quality.ts
+/** The clearance stops at this distance. */
+const CLEARANCE_CAP = 40;
+const TIGHT = 4;
+const EXACT_CROSSINGS$1 = 2e4;
+const SAMPLE$1 = 2e3;
+const key$1 = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
+/** This function measures the quality of a result. */
+function measureQuality(graph, result) {
+	const byId = nodeIndex(graph);
+	const nodes = new Grid(180);
+	for (const n of graph.nodes) nodes.add(n, n.box);
+	const segs = [];
+	const seen = /* @__PURE__ */ new Set();
+	let bends = 0;
+	let infl = 0;
+	let clear = 0;
+	let tight = 0;
+	let detour = 0;
+	let detourN = 0;
+	let angle = 0;
+	let angleN = 0;
+	for (const r of result.routes) {
+		const p = r.points;
+		for (let i = 1; i < p.length; i++) {
+			const ka = key$1(p[i - 1]);
+			const kb = key$1(p[i]);
+			if (ka === kb) continue;
+			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+			if (seen.has(k)) continue;
+			seen.add(k);
+			segs.push([p[i - 1], p[i]]);
+		}
+		bends += bendCount(p);
+		infl += inflectionCount(p);
+		const ends = endNodes(graph, byId, r.edge);
+		let c = 40;
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			nodes.querySegment(a, b, c, (n) => {
+				if (n !== ends.source && n !== ends.target) c = Math.min(c, segmentBoxDistance(a, b, n.box));
+			});
+		}
+		clear += c;
+		if (c < TIGHT) tight++;
+		if (p.length >= 2) {
+			const d = dist(p[0], p[p.length - 1]);
+			if (d > 1) {
+				detour += polylineLength(p) / d;
+				detourN++;
+			}
+			for (const [at, next, node] of [[
+				p[0],
+				p[1],
+				ends.source
+			], [
+				p[p.length - 1],
+				p[p.length - 2],
+				ends.target
+			]]) {
+				if (!node) continue;
+				const a = sideAngle(node.box, at, next);
+				if (a !== void 0) {
+					angle += a;
+					angleN++;
+				}
+			}
+		}
+	}
+	const n = Math.max(1, result.routes.length);
+	let ink = 0;
+	for (const [a, b] of segs) ink += dist(a, b);
+	const [crossings, crossingsEstimated] = countCrossings(segs);
+	return {
+		ink,
+		crossings,
+		crossingsEstimated,
+		bends: bends / n,
+		inflections: infl / n,
+		clearance: clear / n,
+		tight: tight / n,
+		detour: detourN ? detour / detourN : 1,
+		plugAngle: angleN ? angle / angleN : 0
+	};
+}
+function endNodes(graph, byId, edgeId) {
+	const e = edgeIndex(graph).get(edgeId);
+	return {
+		source: e && byId.get(e.source.node),
+		target: e && byId.get(e.target.node)
+	};
+}
+const edgeIndexes = /* @__PURE__ */ new WeakMap();
+function edgeIndex(graph) {
+	let m = edgeIndexes.get(graph);
+	if (!m) {
+		m = /* @__PURE__ */ new Map();
+		for (const e of graph.edges) m.set(e.id, e);
+		edgeIndexes.set(graph, m);
+	}
+	return m;
+}
+/**
+* This function gives an angle in degrees: the angle between the segment from `at` to `next` and the outward normal.
+* The normal is the normal of the side of the box nearest to `at`. A route that starts inside the box (an interior route) gives no angle.
+*/
+function sideAngle(box, at, next) {
+	const d = [
+		[
+			Math.abs(at.y - box.y),
+			0,
+			-1
+		],
+		[
+			Math.abs(at.x - (box.x + box.w)),
+			1,
+			0
+		],
+		[
+			Math.abs(at.y - (box.y + box.h)),
+			0,
+			1
+		],
+		[
+			Math.abs(at.x - box.x),
+			-1,
+			0
+		]
+	].sort((a, b) => a[0] - b[0])[0];
+	if (d[0] > 1) return void 0;
+	const vx = next.x - at.x;
+	const vy = next.y - at.y;
+	const l = Math.hypot(vx, vy);
+	if (l === 0) return void 0;
+	const cos = Math.max(-1, Math.min(1, (vx * d[1] + vy * d[2]) / l));
+	return Math.acos(cos) * 180 / Math.PI;
+}
+/**
+* This function counts the crossings of a set of segments with a grid of buckets.
+* Above 20 000 segments, it counts the crossings of a seeded sample of 2 000 segments and scales the count.
+*/
+function countCrossings(segs) {
+	if (segs.length < 2) return [0, false];
+	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
+	const grid = new Grid(Math.max(20, len));
+	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
+	const exact = segs.length <= EXACT_CROSSINGS$1;
+	const R = rng(segs.length);
+	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE$1 }, () => Math.floor(R() * segs.length));
+	let count = 0;
+	for (const i of pick) {
+		const [a, b] = segs[i];
+		grid.querySegment(a, b, 0, (j) => {
+			if (exact && j <= i) return;
+			if (j === i) return;
+			const [c, d] = segs[j];
+			if (segmentsCross(a, b, c, d)) count++;
+		});
+	}
+	return exact ? [count, false] : [Math.round(count * segs.length / (2 * pick.length)), true];
+}
+/** This function measures how much the routes changed between two results. */
+function measureStability(before, after) {
+	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
+	let sum = 0;
+	let max = 0;
+	let moved = 0;
+	let n = 0;
+	for (const r of after.routes) {
+		const p = prev.get(r.edge);
+		if (!p) continue;
+		const f = frechet(p, r.points);
+		sum += f;
+		max = Math.max(max, f);
+		if (f > 1) moved++;
+		n++;
+	}
+	return {
+		mean: n ? sum / n : 0,
+		max,
+		moved: n ? moved / n : 0
+	};
+}
+// src/routers/adam/index.ts
+/** The default options of the router `adam`. */
+const ADAM_DEFAULTS = Object.freeze({
+	eta: .1,
+	samples: 8,
+	steps: 200,
+	seed: 1,
+	clearance: 8
+});
+/** The declarations of the options of the router `adam` (RULE-020). */
+const ADAM_SCHEMA = {
+	eta: {
+		type: "number",
+		min: .01,
+		max: 1,
+		step: .01,
+		marks: [
+			.01,
+			.1,
+			1
+		],
+		default: .1,
+		describe: "The first step size, in units of the clearance. It falls to a tenth at the last step."
+	},
+	samples: {
+		type: "integer",
+		min: 4,
+		max: 32,
+		step: 1,
+		marks: [
+			4,
+			8,
+			16,
+			32
+		],
+		default: 8,
+		describe: "The number of other legs that each leg samples at each step."
+	},
+	steps: {
+		type: "integer",
+		min: 100,
+		max: 2e3,
+		step: 100,
+		marks: [
+			100,
+			200,
+			500,
+			2e3
+		],
+		default: 200,
+		describe: "The number of steps: the budget of the search."
+	},
+	seed: {
+		type: "integer",
+		min: 0,
+		max: 1e6,
+		step: 1,
+		marks: [
+			1,
+			2,
+			3
+		],
+		default: 1,
+		describe: "The seed of the samples. The same seed gives the same routes."
+	},
+	clearance: {
+		type: "number",
+		min: 4,
+		max: 32,
+		step: 1,
+		marks: [
+			4,
+			8,
+			16,
+			32
+		],
+		default: 8,
+		describe: "A leg nearer than this distance to another leg or to a box gets a push."
+	}
+};
+/** The moment factors of Adam (Kingma and Ba 2015), as the record gives them. */
+const BETA1 = .9;
+const BETA2 = .999;
+const EPS$5 = 1e-8;
+/** The weight of the term that holds a leg near its first place. */
+const HOLD = .05;
+/** This function gives the point of the segment `ab` nearest to `p`. */
+function nearestOn(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const l2 = dx * dx + dy * dy;
+	const t = l2 > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2)) : 0;
+	return {
+		x: a.x + t * dx,
+		y: a.y + t * dy
+	};
+}
+/** This function gives the point of a box nearest to `p`. A point in the box gives the nearest point of its border. */
+function nearestOfBox(p, b) {
+	const qx = Math.max(b.x, Math.min(b.x + b.w, p.x));
+	const qy = Math.max(b.y, Math.min(b.y + b.h, p.y));
+	if (qx !== p.x || qy !== p.y) return {
+		x: qx,
+		y: qy
+	};
+	const sides = [
+		p.x - b.x,
+		b.x + b.w - p.x,
+		p.y - b.y,
+		b.y + b.h - p.y
+	];
+	const m = Math.min(...sides);
+	if (m === sides[0]) return {
+		x: b.x,
+		y: p.y
+	};
+	if (m === sides[1]) return {
+		x: b.x + b.w,
+		y: p.y
+	};
+	if (m === sides[2]) return {
+		x: p.x,
+		y: b.y
+	};
+	return {
+		x: p.x,
+		y: b.y + b.h
+	};
+}
+/** This function gives the crossings of the route `a` with itself and with the routes of `others`. It skips the route with the index `skip`. */
+function crossingsOf(a, others, skip) {
+	const [ax0, ay0, ax1, ay1] = boundsOf$1(a);
+	let n = 0;
+	for (let i = 1; i < a.length; i++) for (let k = i + 2; k < a.length; k++) if (segmentsCross(a[i - 1], a[i], a[k - 1], a[k])) n++;
+	others.forEach((b, j) => {
+		if (j === skip) return;
+		const [bx0, by0, bx1, by1] = boundsOf$1(b);
+		if (bx0 > ax1 || bx1 < ax0 || by0 > ay1 || by1 < ay0) return;
+		for (let i = 1; i < a.length; i++) for (let k = 1; k < b.length; k++) if (segmentsCross(a[i - 1], a[i], b[k - 1], b[k])) n++;
+	});
+	return n;
+}
+/** The bounds of each polyline, once for each polyline object. */
+const BOUNDS = /* @__PURE__ */ new WeakMap();
+/** This function gives the bounds of a polyline: the least x and y, and the largest x and y. */
+function boundsOf$1(p) {
+	let b = BOUNDS.get(p);
+	if (b) return b;
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const q of p) {
+		x0 = Math.min(x0, q.x);
+		y0 = Math.min(y0, q.y);
+		x1 = Math.max(x1, q.x);
+		y1 = Math.max(y1, q.y);
+	}
+	b = [
+		x0,
+		y0,
+		x1,
+		y1
+	];
+	BOUNDS.set(p, b);
+	return b;
+}
+/**
+* This function moves the free legs of the routes of `result` with Adam (RULE-020, after Kingma and Ba 2015, and the SGD layouts of Zheng, Pawar and Goodman 2019).
+* A leg is free when its two points are inside its route, and no other route, run or trunk holds them. The variable of a leg is a shift along its normal.
+* The energy of a leg is `Σ (1 - d / c)²` over a seeded sample of `samples` other legs nearer than `c`. The near boxes add the same term times 4.
+* A term `0.05 × (t / c)²` holds each leg near its first place. The step size falls from `eta` to a tenth of it, with only `+`, `*` and `/`.
+* A moved route goes back to its first points when it has more crossings than before, or a break of a hard rule.
+* When the output still has more crossings than the routes of `shared`, it is the routes of `shared`.
+*/
+function adamRoutes(input, result, options = {}) {
+	const o = {
+		...ADAM_DEFAULTS,
+		...options
+	};
+	const c = Math.max(1e-6, o.clearance);
+	const graph = outerGraph(input);
+	const first = result.routes.map((r) => r.points);
+	const pinned = /* @__PURE__ */ new Set();
+	const keyOf = (p) => `${p.x},${p.y}`;
+	for (const run of result.runs ?? []) for (const p of run.points) pinned.add(keyOf(p));
+	for (const b of result.bundles ?? []) for (const p of b.trunk) pinned.add(keyOf(p));
+	const owners = /* @__PURE__ */ new Map();
+	first.forEach((pts, route) => {
+		for (const p of pts) {
+			const k = keyOf(p);
+			const o = owners.get(k);
+			if (o === void 0) owners.set(k, route);
+			else if (o !== route) pinned.add(k);
+		}
+	});
+	const boxes = graph.nodes.map((n) => n.box);
+	const legs = [];
+	first.forEach((pts, route) => {
+		for (let k = 1; k + 2 < pts.length; k++) {
+			const a = pts[k];
+			const b = pts[k + 1];
+			if (pinned.has(keyOf(a)) || pinned.has(keyOf(b))) continue;
+			const dx = b.x - a.x;
+			const dy = b.y - a.y;
+			const len = Math.sqrt(dx * dx + dy * dy);
+			if (len <= 1e-9) continue;
+			const reach = 3 * c;
+			const near = boxes.filter((bx) => Math.min(a.x, b.x) - reach <= bx.x + bx.w && Math.max(a.x, b.x) + reach >= bx.x && Math.min(a.y, b.y) - reach <= bx.y + bx.h && Math.max(a.y, b.y) + reach >= bx.y);
+			legs.push({
+				route,
+				k,
+				nx: -dy / len,
+				ny: dx / len,
+				boxes: near
+			});
+		}
+	});
+	if (legs.length === 0) return result;
+	const shift = new Float64Array(legs.length);
+	const m1 = new Float64Array(legs.length);
+	const m2 = new Float64Array(legs.length);
+	const legAt = /* @__PURE__ */ new Map();
+	legs.forEach((l, i) => {
+		for (const k of [l.k, l.k + 1]) {
+			const key = `${l.route}:${k}`;
+			const list = legAt.get(key);
+			if (list) list.push(i);
+			else legAt.set(key, [i]);
+		}
+	});
+	const pointOf = (route, k) => {
+		const p = first[route][k];
+		const list = legAt.get(`${route}:${k}`);
+		if (!list) return p;
+		let x = p.x;
+		let y = p.y;
+		for (const i of list) {
+			x += shift[i] * legs[i].nx;
+			y += shift[i] * legs[i].ny;
+		}
+		return {
+			x,
+			y
+		};
+	};
+	const all = [];
+	first.forEach((pts, route) => {
+		for (let k = 0; k + 1 < pts.length; k++) all.push({
+			route,
+			k
+		});
+	});
+	const random = rng(Math.max(0, Math.floor(o.seed)));
+	const steps = Math.max(1, Math.floor(o.steps));
+	const count = Math.max(1, Math.floor(o.samples));
+	let b1 = 1;
+	let b2 = 1;
+	for (let t = 0; t < steps; t++) {
+		b1 *= BETA1;
+		b2 *= BETA2;
+		const eta = o.eta * c / (1 + 9 * t / Math.max(1, steps - 1));
+		const grads = new Float64Array(legs.length);
+		legs.forEach((l, i) => {
+			const a = pointOf(l.route, l.k);
+			const b = pointOf(l.route, l.k + 1);
+			const mid = {
+				x: (a.x + b.x) / 2,
+				y: (a.y + b.y) / 2
+			};
+			let g = 2 * HOLD * shift[i] / (c * c);
+			for (let s = 0; s < count; s++) {
+				const other = all[Math.floor(random() * all.length)];
+				if (other.route === l.route) continue;
+				const q = nearestOn(mid, pointOf(other.route, other.k), pointOf(other.route, other.k + 1));
+				const dx = mid.x - q.x;
+				const dy = mid.y - q.y;
+				const d = Math.sqrt(dx * dx + dy * dy);
+				if (d >= c || d <= 1e-9) continue;
+				g += -2 * (1 - d / c) / c * ((l.nx * dx + l.ny * dy) / d);
+			}
+			for (const bx of l.boxes) for (const p of [
+				a,
+				mid,
+				b
+			]) {
+				const q = nearestOfBox(p, bx);
+				const inside = p.x >= bx.x && p.x <= bx.x + bx.w && p.y >= bx.y && p.y <= bx.y + bx.h;
+				const dx = (inside ? q.x - p.x : p.x - q.x) || 0;
+				const dy = (inside ? q.y - p.y : p.y - q.y) || 0;
+				const d0 = Math.sqrt(dx * dx + dy * dy);
+				if (d0 <= 1e-9) continue;
+				const d = inside ? -d0 : d0;
+				if (d >= c) continue;
+				g += -8 * (1 - d / c) / c * ((l.nx * dx + l.ny * dy) / d0);
+			}
+			grads[i] = g;
+		});
+		for (let i = 0; i < legs.length; i++) {
+			const g = grads[i];
+			m1[i] = BETA1 * m1[i] + .09999999999999998 * g;
+			m2[i] = BETA2 * m2[i] + .0010000000000000009 * g * g;
+			const mh = m1[i] / (1 - b1);
+			const vh = m2[i] / (1 - b2);
+			shift[i] = Math.max(-2 * c, Math.min(2 * c, shift[i] - eta * mh / (Math.sqrt(vh) + EPS$5)));
+		}
+	}
+	const moved = new Set(legs.map((l) => l.route));
+	const points = first.map((pts, route) => moved.has(route) ? pts.map((_, k) => pointOf(route, k)) : pts);
+	for (let round = 0; round < 8; round++) {
+		let back = 0;
+		for (const route of moved) {
+			if (points[route] === first[route] || crossingsOf(points[route], points, route) <= crossingsOf(first[route], points, route)) continue;
+			points[route] = first[route];
+			back++;
+		}
+		if (back === 0) break;
+	}
+	const build = (pts) => ({
+		...result,
+		routes: result.routes.map((r, i) => pts[i] === r.points ? r : {
+			...r,
+			points: pts[i]
+		})
+	});
+	let out = build(points);
+	for (let round = 0; round < 3; round++) {
+		const faulty = new Set(checkProperties(input, out, 1e6).map((v) => v.edge));
+		const fix = result.routes.map((r, i) => faulty.has(r.edge) && points[i] !== first[i] ? i : -1).filter((i) => i >= 0);
+		if (fix.length === 0) break;
+		for (const i of fix) points[i] = first[i];
+		out = build(points);
+	}
+	if (checkProperties(input, out, 1).length > checkProperties(input, result, 1).length) return result;
+	return measureQuality(input, out).crossings > measureQuality(input, result).crossings ? result : out;
+}
+/**
+* This function makes the router `adam` (RULE-020). It is the router `shared`, then the steps of Adam of `adamRoutes`.
+* The runs and the bundles of `shared` stay, because no point of a run or of a trunk moves.
+*/
+function adamRouter(options) {
+	const o = {
+		...ADAM_DEFAULTS,
+		...options
+	};
+	const base = sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	});
+	return {
+		name: o.name,
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes },
+		route: (graph) => adamRoutes(graph, base.route(graph), o)
+	};
+}
+/**
+* The router strategy `adam` (RULE-020), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+* A screen module or a consumer adds it to a registry.
+*/
+const adamStrategy = defineStrategy({
+	step: "router",
+	name: "adam",
+	describe: "Adam with a seeded sample of pairs (RULE-020). The free legs of the routes of `shared` move along their normals, away from near legs and boxes.",
+	defaults: { ...ADAM_DEFAULTS },
+	schema: ADAM_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => adamRouter({
+		...o,
+		name: "adam",
+		rule: byCollection
+	}).route(graph)
+});
+// src/routers/reroute/index.ts
+/** The sine of 1 degree, as a literal. A literal gives the same bits on each platform, so a decision does not depend on `Math.sin`. */
+const SIN_1 = .01745240643728351;
+/** The default options of the router `reroute`. */
+const REROUTE_DEFAULTS = Object.freeze({
+	alpha: 1,
+	beta: .5,
+	gamma: .5,
+	tau: .25,
+	rounds: 2,
+	q: .15,
+	clearance: 16
+});
+/** The declarations of the options of the router `reroute` (RULE-044). */
+const REROUTE_SCHEMA = {
+	alpha: {
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05,
+		marks: [
+			0,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The price of a link in a narrow channel."
+	},
+	beta: {
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05,
+		marks: [
+			0,
+			.5,
+			1
+		],
+		default: .5,
+		describe: "The price of each edge of another key on a link."
+	},
+	gamma: {
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05,
+		marks: [
+			0,
+			.5,
+			1
+		],
+		default: .5,
+		describe: "The discount of a link that an edge of the same key uses."
+	},
+	tau: {
+		type: "number",
+		min: 0,
+		max: 2,
+		step: .05,
+		marks: [
+			0,
+			.25,
+			1
+		],
+		default: .25,
+		describe: "The price of a turn, in units of the clearance."
+	},
+	rounds: {
+		type: "integer",
+		min: 1,
+		max: 5,
+		step: 1,
+		marks: [
+			1,
+			2,
+			3,
+			5
+		],
+		default: 2,
+		describe: "The number of rounds of rip-up and reroute."
+	},
+	q: {
+		type: "number",
+		min: .05,
+		max: .3,
+		step: .05,
+		marks: [
+			.05,
+			.15,
+			.3
+		],
+		default: .15,
+		describe: "The share of the edges that each round rips up: the edges with the largest price over their direct length."
+	},
+	clearance: {
+		type: "number",
+		min: 4,
+		max: 64,
+		step: 1,
+		marks: [
+			8,
+			16,
+			32
+		],
+		default: 16,
+		describe: "A channel narrower than this width gets the price alpha."
+	}
+};
+/** This function gives the number of turns of a way: the points where the direction changes by more than 1 degree. */
+function turnsOf(seq) {
+	let turns = 0;
+	for (let i = 1; i + 1 < seq.length; i++) {
+		const a = seq[i - 1];
+		const b = seq[i];
+		const c = seq[i + 1];
+		const ux = b.x - a.x;
+		const uy = b.y - a.y;
+		const vx = c.x - b.x;
+		const vy = c.y - b.y;
+		const lu = Math.sqrt(ux * ux + uy * uy);
+		const lv = Math.sqrt(vx * vx + vy * vy);
+		if (lu <= 1e-9 || lv <= 1e-9) continue;
+		if (Math.abs(ux * vy - uy * vx) > SIN_1 * lu * lv || ux * vx + uy * vy < 0) turns++;
+	}
+	return turns;
+}
+/**
+* This function rips up and reroutes the ways of `shared` (RULE-044, after the rip-up and reroute of PathFinder, McMurchie 1995).
+* The price factor of a link is `max(0.05, 1 + alpha × narrow + beta × others - gamma × same)`.
+* `narrow` is `max(0, 1 - width / clearance)`. `others` counts the edges of the other keys on the link.
+* `same` is 1 when an edge of the same key uses the link.
+* The price of a way is the sum of the price factor times the length of each link, plus `tau × clearance` for each turn.
+* Each round takes the share `q` of the ways with the largest price over their direct length. Each one gets a new search with the prices of the links.
+* The new way stays only when its price is lower. The search has no state for the turns, so only the comparison reads `tau`.
+*/
+function rerouteWays(ways, search, options = {}) {
+	const o = {
+		...REROUTE_DEFAULTS,
+		...options
+	};
+	const n = search.corners;
+	const use = /* @__PURE__ */ new Map();
+	const linksOf = (w) => {
+		const out = [];
+		for (let i = 1; i < w.ids.length; i++) {
+			const a = w.ids[i - 1];
+			const b = w.ids[i];
+			if (a < n && b < n) out.push(search.link(a, b));
+		}
+		return out;
+	};
+	const change = (w, by) => {
+		for (const k of linksOf(w)) {
+			let m = use.get(k);
+			if (!m) use.set(k, m = /* @__PURE__ */ new Map());
+			const next = (m.get(w.key) ?? 0) + by;
+			if (next > 0) m.set(w.key, next);
+			else m.delete(w.key);
+		}
+	};
+	const found = ways.filter((w) => w.found && w.ids.length >= 2);
+	for (const w of found) change(w, 1);
+	const factor = (i, j, key) => {
+		const m = use.get(search.link(i, j));
+		let others = 0;
+		let same = 0;
+		for (const [k, c] of m ?? []) if (k === key) same = 1;
+		else others += c;
+		const narrow = o.alpha > 0 ? Math.max(0, 1 - search.width(i, j) / o.clearance) : 0;
+		return Math.max(.05, 1 + o.alpha * narrow + o.beta * others - o.gamma * same);
+	};
+	const priceOf = (seq, ids, key) => {
+		let p = 0;
+		for (let i = 1; i < seq.length; i++) {
+			const a = ids[i - 1];
+			const b = ids[i];
+			const d = dist(seq[i - 1], seq[i]);
+			p += a < n && b < n ? d * factor(a, b, key) : d;
+		}
+		return p + o.tau * o.clearance * turnsOf(seq);
+	};
+	const floor = Math.max(.05, 1 - o.gamma);
+	const count = (share) => Math.max(1, Math.round(share * found.length));
+	for (let round = 0; round < Math.max(1, Math.floor(o.rounds)); round++) {
+		const ranked = found.map((w) => ({
+			w,
+			score: priceOf(w.seq, w.ids, w.key) / Math.max(1e-9, dist(w.ps.point, w.pt.point))
+		})).sort((a, b) => b.score - a.score || (a.w.edge.id < b.w.edge.id ? -1 : a.w.edge.id > b.w.edge.id ? 1 : 0));
+		let moved = 0;
+		for (const { w } of ranked.slice(0, count(Math.min(.3, Math.max(.05, o.q))))) {
+			change(w, -1);
+			const before = priceOf(w.seq, w.ids, w.key);
+			const next = search.find(w, (i, j, d) => d * factor(i, j, w.key), floor);
+			if (next && priceOf(next.seq, next.ids, w.key) < before - 1e-9) {
+				w.seq = next.seq;
+				w.ids = next.ids;
+				moved++;
+			}
+			change(w, 1);
+		}
+		if (moved === 0) break;
+	}
+}
+/**
+* This function makes the router `reroute` (RULE-044). It is the router `shared`, then the rounds of rip-up and reroute of `rerouteWays`.
+* The runs and the bundles come from the ways after the rounds.
+*/
+function rerouteRouter(options) {
+	const o = {
+		...REROUTE_DEFAULTS,
+		...options
+	};
+	return sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	}, void 0, { refine: (ways, search) => rerouteWays(ways, search, o) });
+}
+/**
+* The router strategy `reroute` (RULE-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+* A screen module or a consumer adds it to a registry.
+*/
+const rerouteStrategy = defineStrategy({
+	step: "router",
+	name: "reroute",
+	describe: "Rule prices and rip-up (RULE-044). The ways of `shared` with the largest prices of narrow channels, other keys and turns get a new search.",
+	defaults: { ...REROUTE_DEFAULTS },
+	schema: REROUTE_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => rerouteRouter({
+		...o,
+		name: "reroute",
+		rule: byCollection
+	}).route(graph)
+});
 // src/routers/tight/index.ts
 /** The values of `TightFirst`. */
 const TIGHT_FIRSTS = Object.freeze(["tight", "loose"]);
@@ -9201,7 +10380,7 @@ function jogLength(r, shift) {
 	return 2 * r * Math.sin(Math.acos(1 - d / (2 * r)));
 }
 /** This function gives the legs of the route of each edge, with the lanes and the offset of the lane on each leg. */
-function legsOf$1(graph, spacing, maxWidth) {
+function legsOf$2(graph, spacing, maxWidth) {
 	const byId = new Map(graph.segments.map((s) => [s.id, s]));
 	return graph.paths.map((path) => {
 		const legs = [];
@@ -9318,7 +10497,7 @@ function bendGrowth(items, links, gaps, bends, snap) {
 		source: { node: l.source },
 		target: { node: l.target }
 	})));
-	const short = shortLegs(legsOf$1(segmentsOf(bends.router.route({
+	const short = shortLegs(legsOf$2(segmentsOf(bends.router.route({
 		nodes: items,
 		edges
 	})), spacing, maxWidth), minRadius);
@@ -9689,8 +10868,8 @@ const LANE_TRACKS = [
 	"left-edge",
 	"free"
 ];
-const EPS$3 = 1e-6;
-const ROUNDS = 8;
+const EPS$4 = 1e-6;
+const ROUNDS$1 = 8;
 /**
 * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
 * A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
@@ -9714,7 +10893,7 @@ function laneGaps(items, links, options) {
 	})));
 	const counts = [];
 	for (const g of boardGaps(items, options.snap)) {
-		if (g.width <= EPS$3) continue;
+		if (g.width <= EPS$4) continue;
 		const across = g.axis;
 		const along = g.axis === "x" ? "y" : "x";
 		const lo = g.at - g.width;
@@ -9725,8 +10904,8 @@ function laneGaps(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$3 || a[across] <= lo + EPS$3 || a[across] >= hi - EPS$3) continue;
-				if (Math.abs(a[along] - b[along]) <= EPS$3) continue;
+				if (Math.abs(a[across] - b[across]) > EPS$4 || a[across] <= lo + EPS$4 || a[across] >= hi - EPS$4) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS$4) continue;
 				const side = (q, r) => Math.sign(r[across] - q[across]);
 				pieces.push({
 					link: li,
@@ -9802,7 +10981,7 @@ function leftEdgeLanes(list, constrained) {
 		const now = [];
 		let end = -Infinity;
 		for (const i of byStart) {
-			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$3) continue;
+			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$4) continue;
 			now.push(i);
 			end = list[i].hi;
 		}
@@ -9825,15 +11004,15 @@ function density(list) {
 	}
 	return most;
 }
-const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$3;
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$4;
 /**
 * 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$3 && y < Q.hi - EPS$3) c++;
-	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$3 && y < P.hi - EPS$3) c++;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$4 && y < Q.hi - EPS$4) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$4 && y < P.hi - EPS$4) c++;
 	return c;
 }
 /** This function gives the pieces of one gap in lane order, from the near side to the far side. */
@@ -9846,7 +11025,7 @@ function orderPieces(pieces, order) {
 	const index = new Map(list.map((P, i) => [P, i]));
 	const c = list.map((P) => list.map((Q) => P !== Q && overlaps(P, Q) ? cost$1(P, Q) : 0));
 	const at = (P, Q) => c[index.get(P)][index.get(Q)];
-	for (let round = 0; round < ROUNDS; round++) {
+	for (let round = 0; round < ROUNDS$1; round++) {
 		let better = false;
 		for (let i = 0; i < n; i++) {
 			const x = list[i];
@@ -10037,17 +11216,10 @@ function facingEnds(input) {
 	}
 	return out;
 }
-// src/plugs/spread/index.ts
+// src/plugs/walls.ts
 /**
-* The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
-* The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+* The walls of the plug strategies `spread`, `leaders` and `assign`: one side of one node, its room, and the order of its far ends.
 */
-/** The defaults of the plug strategy `spread`. */
-const SPREAD_DEFAULTS = Object.freeze({
-	plugGap: 8,
-	inset: 6,
-	rounds: 2
-});
 /** This function gives the axis along a side. */
 function alongOf(side) {
 	return side === "east" || side === "west" ? "y" : "x";
@@ -10096,6 +11268,30 @@ function keyOf$1(box, side, far) {
 	if (out >= 0) return p;
 	return along >= 0 ? 2 - p : -2 - p;
 }
+// src/plugs/spread/index.ts
+/**
+* The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
+* The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+*/
+/** The defaults of the plug strategy `spread`. */
+const SPREAD_DEFAULTS = Object.freeze({
+	plugGap: 8,
+	inset: 6,
+	rounds: 2
+});
+/**
+* This function gives the sort key of a far point for a po-leader (EDA-041): its place on the axis along the wall.
+* A far point behind the wall gets the key of `keyOf` with a large shift, so it goes to an end of the wall.
+*/
+function poKeyOf(box, side, far) {
+	const c = center(box);
+	const n = SIDE_NORMAL[side];
+	const out = (far.x - c.x) * n.x + (far.y - c.y) * n.y;
+	const along = alongOf(side) === "y" ? far.y : far.x;
+	if (out > 0) return along;
+	const k = keyOf$1(box, side, far);
+	return k >= 0 ? 0xe8d4a51000 + k : -0xe8d4a51000 + k;
+}
 /**
 * This function places `ideal.length` plugs in their given order on the segment from `lo` to `hi`. Two neighbours are at least `gap` apart.
 * The gap shrinks evenly when the segment is too short. The sum of the squares of the moves from the ideal places is the least.
@@ -10113,7 +11309,7 @@ function placeInOrder(ideal, lo, hi, gap) {
 * Each slot goes into the part of its ideal place, and the parts keep the order of the slots. In each part, two plugs and a plug and a fixed plug are at least `gap` apart.
 * The gap of a part shrinks evenly when the part is too short.
 */
-function placeWall(slots, fixed, lo, hi, gap) {
+function placeWall(slots, fixed, lo, hi, gap, idealOf = (s) => s.ideal) {
 	const cuts = [...new Set(fixed.filter((f) => f > lo - 1e-9 && f < hi + 1e-9))].sort((a, b) => a - b);
 	const ends = [
 		lo,
@@ -10124,10 +11320,11 @@ function placeWall(slots, fixed, lo, hi, gap) {
 	let part = 0;
 	for (const s of slots) {
 		let p = 0;
-		while (p < cuts.length && s.ideal > cuts[p]) p++;
+		while (p < cuts.length && idealOf(s) > cuts[p]) p++;
 		part = Math.max(part, p);
 		parts[part].push(s);
 	}
+	const ranged = slots.some((s) => s.range !== void 0);
 	parts.forEach((list, p) => {
 		if (list.length === 0) return;
 		const a = ends[p];
@@ -10138,7 +11335,22 @@ function placeWall(slots, fixed, lo, hi, gap) {
 		const s = steps > 0 ? Math.max(0, Math.min(gap, (b - a) / steps)) : gap;
 		const lower = a + fa * s;
 		const upper = Math.max(lower, b - fb * s);
-		const at = placeInOrder(list.map((x) => x.ideal), lower, upper, s);
+		if (ranged) {
+			const span = list.map((x) => {
+				if (!x.range) return [lower, upper];
+				const lo = Math.max(lower, x.range[0]);
+				const hi = Math.min(upper, x.range[1]);
+				if (lo <= hi) return [lo, hi];
+				const v = x.range[1] < lower ? lower : upper;
+				return [v, v];
+			});
+			const at = placeInIntervals(list.map((x) => idealOf(x)), span.map((r) => r[0]), span.map((r) => r[1]), s);
+			list.forEach((x, i) => {
+				x.at = at[i];
+			});
+			return;
+		}
+		const at = placeInOrder(list.map((x) => idealOf(x)), lower, upper, s);
 		list.forEach((x, i) => {
 			x.at = at[i];
 		});
@@ -10152,6 +11364,13 @@ function placeWall(slots, fixed, lo, hi, gap) {
 * The output has one entry for each edge with two known nodes, in the order of the edges.
 */
 function spreadEnds(input, options = {}) {
+	return spreadWith(input, options);
+}
+/**
+* This function does the work of `spreadEnds`, and of the strategy `leaders` with the argument `leader`.
+* Without `leader`, it gives the plugs of `spread`.
+*/
+function spreadWith(input, options = {}, leader) {
 	const { graph } = input;
 	const gap = options.plugGap ?? SPREAD_DEFAULTS.plugGap;
 	const inset = options.inset ?? SPREAD_DEFAULTS.inset;
@@ -10191,12 +11410,14 @@ function spreadEnds(input, options = {}) {
 		if (slots.has(key)) return key;
 		const side = port?.side ?? sideToward(node.box, toward);
 		const ideal = placePlug(node, end, toward).point[alongOf(side)];
+		const range = rangeInterval(node.box, side, port, inset);
 		const slot = {
 			node,
 			side,
 			ideal,
 			rank: [port ? node.ports.indexOf(port) : -1, slots.size],
-			at: ideal
+			at: ideal,
+			...range ? { range } : {}
 		};
 		slots.set(key, slot);
 		wallOf(node, side).slots.push(slot);
@@ -10229,11 +11450,15 @@ function spreadEnds(input, options = {}) {
 	const order = /* @__PURE__ */ new Map();
 	for (let round = 0; round <= rounds; round++) for (const wall of walls.values()) {
 		const [lo, hi] = roomOf(wall.node.box, wall.side, inset);
-		const keys = new Map(wall.slots.map((s) => [s, keyOf$1(wall.node.box, wall.side, resolve(s.far).point)]));
+		const key = leader === "po" ? poKeyOf : keyOf$1;
+		const keys = new Map(wall.slots.map((s) => [s, key(wall.node.box, wall.side, resolve(s.far).point)]));
 		const tie = (a, b) => round === 0 ? a.rank[0] - b.rank[0] || a.rank[1] - b.rank[1] : order.get(a) - order.get(b);
 		const sorted = [...wall.slots].sort((a, b) => keys.get(a) - keys.get(b) || tie(a, b));
 		sorted.forEach((s, i) => order.set(s, i));
-		placeWall(sorted, wall.fixed, lo, hi, gap);
+		if (leader === "opo") {
+			const even = new Map(sorted.map((s, i) => [s, lo + (i + .5) * (hi - lo) / sorted.length]));
+			placeWall(sorted, wall.fixed, lo, hi, gap, (s) => even.get(s));
+		} else placeWall(sorted, wall.fixed, lo, hi, gap);
 	}
 	return ends.map((x) => ({
 		edge: x.edge,
@@ -10241,6 +11466,497 @@ function spreadEnds(input, options = {}) {
 		target: resolve(x.target)
 	}));
 }
+// src/plugs/assign/index.ts
+/**
+* The plug strategy `assign` (PLUG-ASSIGN): the plugs of each wall go to the intervals of their ends, with a least gap.
+* An interval is the range of the port (PORT-RANGE), or the room of the wall. The assignment is exact for the count of the ends in their intervals.
+*/
+/** The defaults of the plug strategy `assign`. */
+const ASSIGN_DEFAULTS = Object.freeze({
+	plugGap: 8,
+	inset: 6
+});
+/** The tolerance of the comparisons of places along a wall. */
+const EPS$3 = 1e-9;
+/** This function gives the index of the first value of the sorted list `list` that is `v` or more. */
+function lowerBound(list, v) {
+	let a = 0;
+	let b = list.length;
+	while (a < b) {
+		const mid = a + b >> 1;
+		if (list[mid] < v) a = mid + 1;
+		else b = mid;
+	}
+	return a;
+}
+/**
+* This function moves the place `p` out of the zones of the fixed plugs: the open intervals of the width `2·s` around each fixed plug.
+* The list `fixed` is sorted. The place only moves up.
+*/
+function pushOut(p, fixed, s) {
+	for (const f of fixed) if (p > f - s + EPS$3 && p < f + s - EPS$3) p = f + s;
+	return p;
+}
+/**
+* This function gives the gap of a wall with `n` plugs: `gap`, or the largest gap that lets all the plugs go in the room.
+* The plugs keep the gap to the fixed plugs too.
+*/
+function wallGap(n, fixed, lo, hi, gap) {
+	if (n <= 1) return gap;
+	if (fixed.length === 0) return Math.max(0, Math.min(gap, (hi - lo) / (n - 1)));
+	const fits = (s) => {
+		let p = lo;
+		for (let c = 0; c < n; c++) {
+			p = pushOut(p, fixed, s);
+			if (p > hi + EPS$3) return false;
+			p += s;
+		}
+		return true;
+	};
+	if (fits(gap)) return gap;
+	let a = 0;
+	let b = gap;
+	for (let i = 0; i < 60; i++) {
+		const mid = (a + b) / 2;
+		if (fits(mid)) a = mid;
+		else b = mid;
+	}
+	return Math.max(0, a - 1e-7);
+}
+/**
+* This function gives the plan of the ends of one wall in the order of their keys, with no crossing at the wall.
+* The plan has the most ends in their intervals that this order lets. The answer is exact for this order: a table of the least last place
+* for each count of ends in their intervals.
+*/
+function keyOrderPlan(order, win, fixed, lo, hi, s) {
+	const n = order.length;
+	const nf = fixed.length;
+	const at = (i, j, c) => (i * (nf + 1) + j) * (n + 1) + c;
+	const best = new Float64Array((n + 1) * (nf + 1) * (n + 1)).fill(Infinity);
+	const step = new Int8Array(best.length);
+	best[at(0, 0, 0)] = -Infinity;
+	const relax = (k, v, how) => {
+		if (v < best[k]) {
+			best[k] = v;
+			step[k] = how;
+		}
+	};
+	for (let i = 0; i <= n; i++) for (let j = 0; j <= nf; j++) for (let c = 0; c <= i; c++) {
+		const v = best[at(i, j, c)];
+		if (v === Infinity) continue;
+		const next = v === -Infinity ? -Infinity : v + s;
+		if (j < nf && (v === -Infinity || v + s <= fixed[j] + EPS$3)) relax(at(i, j + 1, c), fixed[j], 0);
+		if (i < n) {
+			const w = win[order[i]];
+			if (w) {
+				const p = Math.max(w[0], next);
+				if (p <= w[1] + EPS$3) relax(at(i + 1, j, c + 1), p, 1);
+			}
+			const q = Math.max(lo, next);
+			if (q <= hi + EPS$3) relax(at(i + 1, j, c), q, 2);
+		}
+	}
+	let c = n;
+	while (c >= 0 && best[at(n, nf, c)] === Infinity) c--;
+	if (c < 0) return void 0;
+	const items = [];
+	let i = n;
+	let j = nf;
+	while (i > 0 || j > 0) {
+		const k = at(i, j, c);
+		const how = step[k];
+		if (how === 0) items.push({
+			end: -1,
+			anchored: true,
+			at: fixed[--j]
+		});
+		else {
+			items.push({
+				end: order[--i],
+				anchored: how === 1,
+				at: best[k]
+			});
+			if (how === 1) c--;
+		}
+	}
+	return items.reverse();
+}
+/**
+* This function gives the most ends of a wall that can have their plug in their interval, in any order. It also gives one plan with that count.
+* Each end without its plug in its interval still gets a plug in the room of the wall: a free plug.
+*
+* The plan comes from two facts. First, a plan can move each plug down until it touches its interval, the room, a fixed zone or the plug before it.
+* Thus each plug is at a start place plus a whole number of gaps. Second, a swap of two plugs makes the last plug of the plan the end with the latest interval end.
+* Then the ends with an interval start up to its place are before it, and the others after it. This split gives a table over the ends and two places (the recursion `count`).
+* The free plugs have the room as interval and the latest end. Thus they split the wall into parts, and a second table chains the parts.
+*/
+function bestPlan(order, win, ideals, fixed, lo, hi, s) {
+	const n = order.length;
+	const jobs = order.filter((e) => win[e] !== void 0).sort((a, b) => win[a][1] - win[b][1] || win[a][0] - win[b][0] || a - b);
+	const r = jobs.length;
+	const allowed = (t) => t >= lo - EPS$3 && t <= hi + EPS$3 && fixed.every((f) => t <= f - s + EPS$3 || t >= f + s - EPS$3);
+	const starts = [
+		lo,
+		...jobs.map((e) => win[e][0]),
+		...fixed.map((f) => f + s)
+	];
+	const raw = [];
+	for (const b of starts) for (let q = 0; q <= n; q++) {
+		const t = b + q * s;
+		if (t > hi + EPS$3) break;
+		if (allowed(t)) raw.push(t);
+		if (s === 0) break;
+	}
+	raw.sort((a, b) => a - b);
+	const T = [];
+	for (const t of raw) if (T.length === 0 || t - T[T.length - 1] > EPS$3) T.push(t);
+	const m = T.length;
+	const id = (k, ui, vi) => (k * (m + 2) + ui + 1) * (m + 2) + vi + 1;
+	const memo = /* @__PURE__ */ new Map();
+	const pick = /* @__PURE__ */ new Map();
+	const count = (k, ui, vi) => {
+		if (k === 0) return 0;
+		const key = id(k, ui, vi);
+		const got = memo.get(key);
+		if (got !== void 0) return got;
+		const [a, b] = win[jobs[k - 1]];
+		const u = ui < 0 ? -Infinity : T[ui];
+		const v = vi >= m ? Infinity : T[vi];
+		let most = count(k - 1, ui, vi);
+		let choice = -1;
+		if (a > u + EPS$3 && a <= v + EPS$3) {
+			const from = Math.max(a, ui < 0 ? lo : u + s);
+			const to = Math.min(b, vi >= m ? hi : v - s);
+			for (let ti = lowerBound(T, from - EPS$3); ti < m && T[ti] <= to + EPS$3; ti++) {
+				const got2 = 1 + count(k - 1, ui, ti) + count(k - 1, ti, vi);
+				if (got2 > most) {
+					most = got2;
+					choice = ti;
+				}
+			}
+		}
+		memo.set(key, most);
+		if (choice >= 0) pick.set(key, choice);
+		return most;
+	};
+	let total = r === n && count(r, -1, m) === n ? n : -1;
+	let bestQ = 0;
+	let bestI = -1;
+	const chain = [];
+	const back = [];
+	for (let q = 1; q <= n; q++) {
+		const cur = new Float64Array(m).fill(-Infinity);
+		const from = new Int32Array(m).fill(-1);
+		for (let i = 0; i < m; i++) {
+			if (q === 1) {
+				cur[i] = count(r, -1, i);
+				continue;
+			}
+			const prev = chain[q - 2];
+			for (let h = 0; h < i; h++) {
+				if (prev[h] === -Infinity || T[i] - T[h] < s - EPS$3) continue;
+				const v = prev[h] + count(r, h, i);
+				if (v > cur[i]) {
+					cur[i] = v;
+					from[i] = h;
+				}
+			}
+		}
+		chain.push(cur);
+		back.push(from);
+		for (let i = 0; i < m; i++) {
+			if (cur[i] === -Infinity) continue;
+			const a = cur[i] + count(r, i, m);
+			if (a + q >= n && a > total) {
+				total = a;
+				bestQ = q;
+				bestI = i;
+			}
+		}
+	}
+	const placed = /* @__PURE__ */ new Map();
+	const place = (k, ui, vi) => {
+		if (k === 0) return;
+		const t = pick.get(id(k, ui, vi));
+		if (t === void 0) return place(k - 1, ui, vi);
+		placed.set(jobs[k - 1], T[t]);
+		place(k - 1, ui, t);
+		place(k - 1, t, vi);
+	};
+	const free = [];
+	let ui = bestI;
+	for (let q = bestQ; q >= 1; q--) {
+		free.push(T[ui]);
+		const h = back[q - 1][ui];
+		place(r, h, ui);
+		ui = h;
+	}
+	if (bestQ === 0) place(r, -1, m);
+	else place(r, bestI, m);
+	free.reverse();
+	const rest = order.filter((e) => !placed.has(e));
+	const slots = assignInOrder(rest, free);
+	const items = [];
+	for (const [e, p] of placed) items.push({
+		end: e,
+		anchored: true,
+		at: p
+	});
+	rest.forEach((e, i) => items.push({
+		end: e,
+		anchored: false,
+		at: slots[i]
+	}));
+	for (const f of fixed) items.push({
+		end: -1,
+		anchored: true,
+		at: f
+	});
+	return items.sort((a, b) => a.at - b.at || (a.end < 0 ? -1 : b.end < 0 ? 1 : order.indexOf(a.end) - order.indexOf(b.end)));
+	/** This function gives each end of `list` one of the sorted places `free`, in order. The sum of the squares of the moves from the ideal places is the least. */
+	function assignInOrder(list, places) {
+		const a = list.length;
+		const b = places.length;
+		const cost = (i, j) => (places[j] - ideals[list[i]]) ** 2;
+		const g = Array.from({ length: a + 1 }, () => new Float64Array(b + 1).fill(Infinity));
+		for (let j = 0; j <= b; j++) g[0][j] = 0;
+		for (let i = 1; i <= a; i++) for (let j = i; j <= b; j++) g[i][j] = Math.min(g[i][j - 1], g[i - 1][j - 1] + cost(i - 1, j - 1));
+		const out = new Array(a);
+		let j = b;
+		for (let i = a; i >= 1; i--) {
+			while (j > i && g[i][j - 1] === g[i][j]) j--;
+			out[i - 1] = places[j - 1];
+			j--;
+		}
+		return out;
+	}
+}
+/**
+* This function gives the plan of one wall (PLUG-ASSIGN). Each end has an interval on the axis along the wall. The plugs keep at least `gap` between two of them,
+* and between a plug and a fixed plug at a place of `fixed`. When the room is too short for all the plugs, the gap shrinks evenly. The plan has three goals, in this order:
+* 1. the most ends with their plug in their interval (exact).
+* 2. no crossing at the wall: the order of the keys, when that order lets the count of goal 1.
+* 3. the least sum of the squares of the moves from the ideal places, for the order and the ends of goals 1 and 2.
+*
+* An end that cannot get a plug in its interval still gets a plug in the room. When the order of the keys loses ends, the plugs swap their places
+* to come nearer to that order, while each end keeps its interval.
+*/
+function assignWall(ends, room, gap, fixed = []) {
+	const n = ends.length;
+	if (n === 0) return {
+		at: [],
+		anchored: [],
+		gap
+	};
+	const [lo, hi] = room;
+	const pins = [...fixed].sort((a, b) => a - b);
+	let s = wallGap(n, pins, lo, hi, Math.max(0, gap));
+	const win = ends.map((e) => {
+		const a = Math.max(lo, e.lo);
+		const b = Math.min(hi, e.hi);
+		return a <= b + EPS$3 ? [a, Math.max(a, b)] : void 0;
+	});
+	const order = ends.map((_, i) => i).sort((a, b) => ends[a].key - ends[b].key || a - b);
+	let items = keyOrderPlan(order, win, pins, lo, hi, s);
+	if (!items) {
+		s = 0;
+		items = keyOrderPlan(order, win, pins, lo, hi, s);
+	}
+	const inKey = items.filter((x) => x.end >= 0 && x.anchored).length;
+	if (inKey < win.filter((w) => w !== void 0).length && inKey < unionCap(win, pins, lo, hi, s, n)) {
+		const best = bestPlan(order, win, ends.map((e) => e.ideal), pins, lo, hi, s);
+		if (best.filter((x) => x.end >= 0 && x.anchored).length > inKey) items = untangle(best, ends, win);
+	}
+	const span = items.map((x) => x.end < 0 ? [x.at, x.at] : x.anchored ? win[x.end] : [lo, hi]);
+	const placed = placeInIntervals(items.map((x) => x.end < 0 ? x.at : ends[x.end].ideal), span.map((v) => v[0]), span.map((v) => v[1]), s);
+	const at = new Array(n);
+	items.forEach((x, i) => {
+		if (x.end >= 0) at[x.end] = placed[i];
+	});
+	return {
+		at,
+		anchored: ends.map((e, i) => at[i] >= e.lo - 1e-7 && at[i] <= e.hi + 1e-7 && win[i] !== void 0),
+		gap: s
+	};
+}
+/** This function gives the most plugs with the gap `s` in the union of the intervals, out of the fixed zones, and at most `n`. It is a bound of goal 1. */
+function unionCap(win, fixed, lo, hi, s, n) {
+	const parts = win.filter((w) => w !== void 0).sort((a, b) => a[0] - b[0]);
+	let count = 0;
+	let p = -Infinity;
+	for (const [a, b] of parts) {
+		let v = Math.max(a, p, lo);
+		for (;;) {
+			v = pushOut(v, fixed, s);
+			if (v > b + EPS$3 || v > hi + EPS$3 || count >= n) break;
+			count++;
+			p = v + s;
+			v = p;
+			if (s === 0) return n;
+		}
+	}
+	return count;
+}
+/**
+* This function swaps the places of two neighbours of a plan when their keys are in the wrong order, and each end keeps its interval.
+* Thus the plan comes nearer to the order of the keys. Each swap removes one inversion, so the loop ends.
+*/
+function untangle(items, ends, win) {
+	const own = items.filter((x) => x.end >= 0);
+	const ok = (x, p) => !x.anchored || p >= win[x.end][0] - EPS$3 && p <= win[x.end][1] + EPS$3;
+	for (let changed = true, rounds = 0; changed && rounds <= own.length * own.length; rounds++) {
+		changed = false;
+		for (let i = 0; i + 1 < own.length; i++) {
+			const x = own[i];
+			const y = own[i + 1];
+			if (ends[x.end].key <= ends[y.end].key) continue;
+			if (!ok(x, y.at) || !ok(y, x.at)) continue;
+			const t = x.at;
+			x.at = y.at;
+			y.at = t;
+			own[i] = y;
+			own[i + 1] = x;
+			changed = true;
+		}
+	}
+	return items.sort((a, b) => a.at - b.at || (a.end < 0 ? -1 : b.end < 0 ? 1 : ends[a.end].key - ends[b.end].key));
+}
+/**
+* This function gives the plugs of the plug strategy `assign` (PLUG-ASSIGN). A fixed plug stays at its point, and a plug with a side stays on that side.
+* Each free plug goes on the side that faces the other end (`sideToward`). Each end of a wall has an interval: the range of its port, or the room of the wall.
+* Then `assignWall` places the plugs of each wall, with at least `plugGap` between two of them. The ends of one port share one plug.
+*
+* The output has one entry for each edge with two known nodes, in the order of the edges.
+*/
+function assignEnds(input, options = {}) {
+	const { graph } = input;
+	const gap = options.plugGap ?? ASSIGN_DEFAULTS.plugGap;
+	const inset = options.inset ?? ASSIGN_DEFAULTS.inset;
+	const byId = nodeIndex(graph);
+	const slots = /* @__PURE__ */ new Map();
+	const walls = /* @__PURE__ */ new Map();
+	const wallOf = (node, side) => {
+		const key = JSON.stringify([node.id, side]);
+		let wall = walls.get(key);
+		if (!wall) {
+			const fixed = [];
+			for (const p of node.ports ?? []) {
+				const at = portOffset(node.box, p);
+				if (at === void 0) continue;
+				const point = {
+					x: node.box.x + at.x,
+					y: node.box.y + at.y
+				};
+				if ((p.side ?? nearestSide(node.box, point)) === side) fixed.push(point[alongOf(side)]);
+			}
+			walls.set(key, wall = {
+				node,
+				side,
+				slots: [],
+				fixed
+			});
+		}
+		return wall;
+	};
+	const plugOf = (node, end, far) => {
+		const toward = center(far.box);
+		const port = end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+		if (port && portOffset(node.box, port) !== void 0) return placePlug(node, end, toward);
+		const key = port ? JSON.stringify([node.id, port.id]) : JSON.stringify([node.id, slots.size]);
+		if (slots.has(key)) return key;
+		const side = port?.side ?? sideToward(node.box, toward);
+		const ideal = placePlug(node, end, toward).point[alongOf(side)];
+		const range = rangeInterval(node.box, side, port, inset);
+		const slot = {
+			node,
+			side,
+			ideal,
+			at: ideal,
+			...range ? { range } : {}
+		};
+		slots.set(key, slot);
+		wallOf(node, side).slots.push(slot);
+		return key;
+	};
+	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 source = plugOf(s, e.source, t);
+		const target = plugOf(t, e.target, s);
+		for (const [own, far] of [[source, target], [target, source]]) {
+			const slot = typeof own === "string" ? slots.get(own) : void 0;
+			if (slot && slot.far === void 0) slot.far = far;
+		}
+		ends.push({
+			edge: e.id,
+			source,
+			target
+		});
+	}
+	const farPoint = (s) => {
+		const far = s.far;
+		if (typeof far !== "string") return far.point;
+		const f = slots.get(far);
+		return pointAt$1(f.node.box, f.side, f.ideal);
+	};
+	for (const wall of walls.values()) {
+		const room = roomOf(wall.node.box, wall.side, inset);
+		const plan = assignWall(wall.slots.map((s) => ({
+			lo: s.range?.[0] ?? room[0],
+			hi: s.range?.[1] ?? room[1],
+			ideal: s.ideal,
+			key: keyOf$1(wall.node.box, wall.side, farPoint(s))
+		})), room, gap, wall.fixed);
+		wall.slots.forEach((s, i) => {
+			s.at = plan.at[i];
+		});
+	}
+	const resolve = (p) => {
+		if (typeof p !== "string") return p;
+		const s = slots.get(p);
+		return {
+			point: pointAt$1(s.node.box, s.side, s.at),
+			normal: SIDE_NORMAL[s.side]
+		};
+	};
+	return ends.map((x) => ({
+		edge: x.edge,
+		source: resolve(x.source),
+		target: resolve(x.target)
+	}));
+}
+// src/plugs/leaders/index.ts
+/** The values of `LeaderType`. */
+const LEADER_TYPES = Object.freeze([
+	"s",
+	"po",
+	"opo"
+]);
+/** The defaults of the plug strategy `leaders`. */
+const LEADER_DEFAULTS = Object.freeze({
+	leader: "po",
+	slotSpacing: 8,
+	inset: SPREAD_DEFAULTS.inset,
+	rounds: SPREAD_DEFAULTS.rounds
+});
+/**
+* This function gives the plugs of the plug strategy `leaders` (EDA-041, after Bekos 2007). A fixed plug stays at its point, and a plug with a side stays on that side.
+* Each free plug goes on the side that faces the other end. The plugs of each wall keep at least `slotSpacing` between two of them.
+* The type of leader sets their order and their places. The output has one entry for each edge with two known nodes, in the order of the edges.
+*/
+function leaderEnds(input, options = {}) {
+	const o = {
+		...LEADER_DEFAULTS,
+		...options
+	};
+	return spreadWith(input, {
+		plugGap: o.slotSpacing,
+		inset: o.inset,
+		rounds: o.rounds
+	}, o.leader === "s" ? void 0 : o.leader);
+}
 // src/highways/model.ts
 /** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
 function pointAt(line, at) {
@@ -12794,7 +14510,7 @@ function adjustedRandIndex(a, b) {
 	return top === expected ? 1 : (index - expected) / (top - expected);
 }
 // src/bench/measures/routes.ts
-const key$1 = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
+const key = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
 /**
 * This function gives the drawn segments of the routes: one segment for each distinct pair of ends.
 * A segment that several routes share is one drawn segment, as in `measureQuality`.
@@ -12805,8 +14521,8 @@ function drawnSegments(routes) {
 	for (const r of routes) {
 		const p = r.points;
 		for (let i = 1; i < p.length; i++) {
-			const ka = key$1(p[i - 1]);
-			const kb = key$1(p[i]);
+			const ka = key(p[i - 1]);
+			const kb = key(p[i]);
 			if (ka === kb) continue;
 			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
 			if (seen.has(k)) continue;
@@ -12818,8 +14534,8 @@ function drawnSegments(routes) {
 }
 /** This function gives the key of the drawn segment between two points. Two routes share a segment when they give the same key. */
 function segmentKey(a, b) {
-	const ka = key$1(a);
-	const kb = key$1(b);
+	const ka = key(a);
+	const kb = key(b);
 	if (ka === kb) return void 0;
 	return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
 }
@@ -12832,8 +14548,8 @@ function boardUnit(graph) {
 	const u = quantile(graph.nodes.map((n) => Math.min(n.box.w, n.box.h)), .5);
 	return u > 0 ? u : 1;
 }
-const EXACT_CROSSINGS$1 = 2e4;
-const SAMPLE$1 = 2e3;
+const EXACT_CROSSINGS = 2e4;
+const SAMPLE = 2e3;
 /** This function gives the angle between two segments, in degrees from 0 to 90. */
 function crossingAngle(a, b, c, d) {
 	const ux = b.x - a.x;
@@ -12859,9 +14575,9 @@ function crossingAngles(segs) {
 	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
 	const grid = new Grid(Math.max(20, len));
 	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
-	const exact = segs.length <= EXACT_CROSSINGS$1;
+	const exact = segs.length <= EXACT_CROSSINGS;
 	const R = rng(segs.length);
-	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE$1 }, () => Math.floor(R() * segs.length));
+	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE }, () => Math.floor(R() * segs.length));
 	let count = 0;
 	let sum = 0;
 	let min = 90;
@@ -17988,6 +19704,271 @@ function kneePlan(input, o) {
 	}
 	return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
 }
+// src/highways/balance/index.ts
+/**
+* The highway strategy `balance` (EDA-017): the stretch of each edge of a bundle stays near a target.
+* A Lagrange price for each edge grows while its stretch is above the target, and the price moves the exit of the edge forward.
+*/
+/** The values of `BalanceEnd`. */
+const BALANCE_ENDS = Object.freeze([
+	"exit",
+	"entry",
+	"both"
+]);
+/** The default options of the strategy `balance`. */
+const BALANCE_DEFAULTS = Object.freeze({
+	tau: 1.2,
+	iterations: 5,
+	end: "exit",
+	from: "shared-ways"
+});
+/** The margin of the way finder of `follow`. A ride shorter than this length leaves the plan. */
+const MARGIN = 5;
+/** This function gives the length of the route of each edge of a plan after `follow`. */
+function routeLengths(graph, plan) {
+	return new Map(follow(graph, plan).routes.map((r) => [r.edge, polylineLength(r.points)]));
+}
+/**
+* This function gives the plan of the highway strategy `balance` (EDA-017, after the Lagrange relaxation of the stretch).
+* The stretch of an edge is its route on the plan over its route alone, as the gate `stretch` measures it.
+* At each update, an edge with a stretch above `tau` adds `stretch - tau` to its price. Each of its rides keeps the share `1 - price` of its first length.
+* A ride shorter than the margin leaves the plan. The updates stop when no edge is above `tau`.
+*/
+function balancePlan(input, options = {}) {
+	const o = {
+		...BALANCE_DEFAULTS,
+		...options
+	};
+	const graph = outerGraph(input.graph);
+	return balanceOf(graph, basePlan({
+		...input,
+		graph
+	}, o.from), o);
+}
+/** This function balances the plan `first` of the graph, as `balancePlan` does. It reads all the options except `from`. */
+function balanceOf(graph, first, options = {}) {
+	const o = {
+		...BALANCE_DEFAULTS,
+		...options
+	};
+	const riders = new Set(first.highways.flatMap((h) => h.members.map((m) => m.edge)));
+	if (riders.size === 0) return first;
+	const sub = {
+		nodes: graph.nodes,
+		edges: graph.edges.filter((e) => riders.has(e.id))
+	};
+	const alone = routeLengths(sub, { highways: [] });
+	const price = /* @__PURE__ */ new Map();
+	let plan = first;
+	for (let k = 0; k < Math.max(1, Math.floor(o.iterations)); k++) {
+		const along = routeLengths(sub, plan);
+		let over = false;
+		for (const [edge, length] of along) {
+			const base = alone.get(edge) ?? 0;
+			if (base <= 1e-9) continue;
+			const stretch = length / base;
+			if (stretch <= o.tau + 1e-9) continue;
+			price.set(edge, (price.get(edge) ?? 0) + stretch - o.tau);
+			over = true;
+		}
+		if (!over) break;
+		plan = tidyPlan({ highways: first.highways.map((h) => ({
+			...h,
+			members: h.members.flatMap((m) => {
+				const keep = 1 - Math.min(1, price.get(m.edge) ?? 0);
+				if (keep >= 1) return [m];
+				const span = m.off - m.on;
+				const cut = (1 - keep) * span;
+				const on = o.end === "entry" ? m.on + cut : o.end === "both" ? m.on + cut / 2 : m.on;
+				const off = o.end === "exit" ? m.off - cut : o.end === "both" ? m.off - cut / 2 : m.off;
+				if (lengthBetween(h.spine, Math.min(on, off), Math.max(on, off)) < MARGIN) return [];
+				return [memberAt(h.spine, m.edge, on, off, m.seq)];
+			})
+		})) });
+		if (plan.highways.length === 0) break;
+	}
+	return plan;
+}
+// src/highways/manifolds/index.ts
+/**
+* The highway strategy `manifolds` (WILD-036): a header for a fan from one node to a row of nodes.
+* The header lies in the gap before the row, the taps leave it at right angles, and the feed joins it from the node.
+*/
+/** The values of `ManifoldSide`. */
+const MANIFOLD_SIDES = Object.freeze(["near", "far"]);
+/** The default options of the strategy `manifolds`. */
+const MANIFOLD_DEFAULTS = Object.freeze({
+	kMin: 3,
+	band: 1,
+	side: "near",
+	detour: 1.5,
+	from: "shared-ways"
+});
+/** This function gives the median of the values, or 0 when there is none. */
+function median$1(values) {
+	if (values.length === 0) return 0;
+	const s = [...values].sort((a, b) => a - b);
+	return s[Math.floor(s.length / 2)];
+}
+/** This function compares two texts in the order of their code units. */
+function byId(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+* This function gives the manifolds that the strategy can make from one feed node, for one axis of the header.
+* The far centers go in bands across the axis. A band with `kMin` taps or more, wholly on one side of the feed node, is a candidate.
+*/
+function candidatesOf(feed, taps, axis, band, o, margin) {
+	const across = axis === "x" ? "y" : "x";
+	const size = axis === "x" ? "h" : "w";
+	const sorted = [...taps].sort((a, b) => center(a.far.box)[across] - center(b.far.box)[across] || byId(a.edge, b.edge));
+	const out = [];
+	const lo = feed.box[across];
+	const hi = lo + feed.box[size];
+	const share = o.side === "near" ? 1 / 3 : 2 / 3;
+	for (let i = 0; i < sorted.length;) {
+		let j = i;
+		const first = center(sorted[i].far.box)[across];
+		while (j + 1 < sorted.length && center(sorted[j + 1].far.box)[across] - first <= band) j++;
+		const row = sorted.slice(i, j + 1);
+		i = j + 1;
+		if (row.length < o.kMin) continue;
+		const top = Math.min(...row.map((t) => t.far.box[across]));
+		const bottom = Math.max(...row.map((t) => t.far.box[across] + t.far.box[size]));
+		if (hi + 2 * margin <= top) out.push({
+			feed,
+			axis,
+			at: top - share * (top - hi),
+			taps: row
+		});
+		else if (bottom + 2 * margin <= lo) out.push({
+			feed,
+			axis,
+			at: bottom + share * (lo - bottom),
+			taps: row
+		});
+	}
+	return out;
+}
+/**
+* This function gives the plan of the highway strategy `manifolds` (WILD-036, after the headers of pipes and of bus bars).
+* A fan of `kMin` edges or more from one node to a row of nodes gets a straight header in the gap before the row.
+* Each edge of the fan joins the header at the feed point, in line with the center of the node. It leaves the header at its tap, in line with the center of its far node.
+* A tap whose way is more than `detour` times the direct line leaves the manifold. Each edge is on one manifold at most. The other edges keep the plan `from`.
+*/
+function manifoldPlan(input, options = {}) {
+	const o = {
+		...MANIFOLD_DEFAULTS,
+		...options
+	};
+	const graph = outerGraph(input.graph);
+	const nodes = nodeIndex(graph);
+	const margin = 5;
+	const bandOf = {
+		x: o.band * median$1(graph.nodes.map((n) => n.box.h)),
+		y: o.band * median$1(graph.nodes.map((n) => n.box.w))
+	};
+	const fans = /* @__PURE__ */ new Map();
+	const add = (id, tap) => {
+		const list = fans.get(id);
+		if (list) list.push(tap);
+		else fans.set(id, [tap]);
+	};
+	for (const e of graph.edges) {
+		const s = nodes.get(e.source.node);
+		const t = nodes.get(e.target.node);
+		if (!s || !t || s === t) continue;
+		add(s.id, {
+			edge: e.id,
+			far: t,
+			out: true
+		});
+		add(t.id, {
+			edge: e.id,
+			far: s,
+			out: false
+		});
+	}
+	const all = [];
+	for (const [id, taps] of fans) {
+		if (taps.length < o.kMin) continue;
+		const feed = nodes.get(id);
+		for (const axis of ["x", "y"]) all.push(...candidatesOf(feed, taps, axis, bandOf[axis], o, margin));
+	}
+	all.sort((a, b) => b.taps.length - a.taps.length || byId(a.feed.id, b.feed.id) || byId(a.axis, b.axis) || a.at - b.at);
+	const used = /* @__PURE__ */ new Set();
+	const lines = [];
+	for (const c of all) {
+		const fc = center(c.feed.box);
+		const feedPoint = c.axis === "x" ? {
+			x: fc.x,
+			y: c.at
+		} : {
+			x: c.at,
+			y: fc.y
+		};
+		const tapOf = (t) => {
+			const tc = center(t.far.box);
+			return c.axis === "x" ? {
+				x: tc.x,
+				y: c.at
+			} : {
+				x: c.at,
+				y: tc.y
+			};
+		};
+		const taps = c.taps.filter((t) => {
+			if (used.has(t.edge)) return false;
+			const tc = center(t.far.box);
+			return dist(fc, feedPoint) + dist(feedPoint, tapOf(t)) + dist(tapOf(t), tc) <= o.detour * dist(fc, tc);
+		});
+		if (taps.length < o.kMin) continue;
+		const along = [feedPoint, ...taps.map(tapOf)].map((p) => p[c.axis]);
+		const lo = Math.min(...along);
+		const hi = Math.max(...along);
+		const a = c.axis === "x" ? {
+			x: lo,
+			y: c.at
+		} : {
+			x: c.at,
+			y: lo
+		};
+		const b = c.axis === "x" ? {
+			x: hi,
+			y: c.at
+		} : {
+			x: c.at,
+			y: hi
+		};
+		for (const t of taps) used.add(t.edge);
+		lines.push({
+			key: `manifold:${c.feed.id}:${c.axis}`,
+			a,
+			b,
+			members: taps.map((t) => t.out ? {
+				edge: t.edge,
+				from: feedPoint,
+				to: tapOf(t),
+				at: .5
+			} : {
+				edge: t.edge,
+				from: tapOf(t),
+				to: feedPoint,
+				at: .5
+			})
+		});
+	}
+	const manifolds = snapPlan({ graph }, lines, {
+		minSize: Math.max(2, o.kMin),
+		direct: true
+	});
+	const riding = new Set(manifolds.highways.flatMap((h) => h.members.map((m) => m.edge)));
+	const base = keepMembers(basePlan({
+		...input,
+		graph
+	}, o.from), (_, m) => !riding.has(m.edge));
+	return tidyPlan({ highways: [...manifolds.highways, ...base.highways] });
+}
 // src/highways/bronchial/index.ts
 /** The values of `BronchialSplit`. */
 const BRONCHIAL_SPLITS = Object.freeze([
@@ -21226,6 +23207,151 @@ function venationLevels(input, options) {
 		links: venationLinks(level.items, level.links, options)
 	});
 }
+// src/levels/detail/index.ts
+/**
+* The level strategy `detail` (WILD-016 with EDA-038): the level of detail of the bundles of each zoom level.
+* Two legs of level links that are closer on the screen than `pxMin` pixels become one stroke, with a width that grows with the count.
+*/
+/** The values of `WidthScale`. */
+const WIDTH_SCALES = Object.freeze([
+	"linear",
+	"sqrt",
+	"log"
+]);
+/** The default options of the level strategy `detail`. */
+const DETAIL_DEFAULTS = Object.freeze({
+	pxMin: 3,
+	minCount: 2,
+	w0: 1.5,
+	widthScale: "log"
+});
+/**
+* This function gives the width of a stroke of `count` edges, in pixels (WILD-016). With `log`, it is `w0 × (1 + log2(count))`.
+* With `sqrt`, it is `w0 × sqrt(count)`. With `linear`, it is `w0 × count`.
+*/
+function detailWidth(count, o = DETAIL_DEFAULTS) {
+	const c = Math.max(1, count);
+	if (o.widthScale === "linear") return o.w0 * c;
+	if (o.widthScale === "sqrt") return o.w0 * Math.sqrt(c);
+	return o.w0 * (1 + Math.log2(c));
+}
+/** This function gives the inner legs of the links that are parallel to an axis. The first and the last leg of a link touch its items, so they stay. */
+function legsOf$1(links) {
+	const out = [];
+	links.forEach((l, link) => {
+		const p = l.points;
+		for (let at = 1; at + 2 < p.length; at++) {
+			const a = p[at];
+			const b = p[at + 1];
+			if (Math.abs(a.y - b.y) <= 1e-9 && Math.abs(a.x - b.x) > 1e-9) out.push({
+				link,
+				at,
+				axis: "x",
+				across: a.y,
+				lo: Math.min(a.x, b.x),
+				hi: Math.max(a.x, b.x),
+				count: l.count
+			});
+			else if (Math.abs(a.x - b.x) <= 1e-9 && Math.abs(a.y - b.y) > 1e-9) out.push({
+				link,
+				at,
+				axis: "y",
+				across: a.x,
+				lo: Math.min(a.y, b.y),
+				hi: Math.max(a.y, b.y),
+				count: l.count
+			});
+		}
+	});
+	return out;
+}
+/** This function takes out the repeated points and the points in the middle of a straight run. The first and the last point stay. */
+function tidy(p) {
+	const out = [];
+	for (const q of p) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(last.x - q.x) <= 1e-9 && Math.abs(last.y - q.y) <= 1e-9) continue;
+		if (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);
+			const dot = (b.x - a.x) * (q.x - b.x) + (b.y - a.y) * (q.y - b.y);
+			if (Math.abs(cross) <= 1e-9 && dot > 0) out.pop();
+		}
+		out.push(q);
+	}
+	if (out.length < 2 && p.length >= 2) return [p[0], p[p.length - 1]];
+	return out;
+}
+/**
+* This function collapses the legs of the links of one level that are closer than `tol` (WILD-016, EDA-038).
+* The legs of each axis go in clusters along the axis across it. The leg with the largest count of a cluster is its stroke, and each other leg moves onto it.
+* A cluster needs two legs whose projections overlap, and a count of `minCount` or more. A move that puts a leg through the box of an item does not happen.
+*/
+function collapseLinks(items, links, tol, minCount) {
+	if (!(tol > 0)) return [...links];
+	const points = links.map((l) => [...l.points]);
+	const boxes = items.map((i) => i.box);
+	const clear = (a, b) => boxes.every((box) => !segmentHitsBox(a, b, box, .001));
+	for (const axis of ["x", "y"]) {
+		const legs = legsOf$1(links.map((l, i) => ({
+			...l,
+			points: points[i]
+		}))).filter((g) => g.axis === axis).sort((a, b) => a.across - b.across || a.lo - b.lo || a.link - b.link || a.at - b.at);
+		const done = /* @__PURE__ */ new Set();
+		for (const anchor of [...legs].sort((a, b) => b.count - a.count || b.hi - b.lo - (a.hi - a.lo) || a.link - b.link || a.at - b.at)) {
+			if (done.has(anchor)) continue;
+			const near = legs.filter((g) => !done.has(g) && g !== anchor && g.link !== anchor.link && Math.abs(g.across - anchor.across) < tol && Math.min(g.hi, anchor.hi) - Math.max(g.lo, anchor.lo) > 1e-9);
+			if (near.length === 0 || near.reduce((s, g) => s + g.count, anchor.count) < minCount) continue;
+			done.add(anchor);
+			for (const g of near) {
+				done.add(g);
+				const p = points[g.link];
+				const a = p[g.at];
+				const b = p[g.at + 1];
+				if (axis === "x" ? a.y !== g.across || b.y !== g.across : a.x !== g.across || b.x !== g.across) continue;
+				const a2 = axis === "x" ? {
+					x: a.x,
+					y: anchor.across
+				} : {
+					x: anchor.across,
+					y: a.y
+				};
+				const b2 = axis === "x" ? {
+					x: b.x,
+					y: anchor.across
+				} : {
+					x: anchor.across,
+					y: b.y
+				};
+				if (!clear(p[g.at - 1], a2) || !clear(a2, b2) || !clear(b2, p[g.at + 2])) continue;
+				p[g.at] = a2;
+				p[g.at + 1] = b2;
+			}
+		}
+	}
+	return links.map((l, i) => points[i].every((q, k) => q === l.points[k]) ? l : {
+		...l,
+		points: tidy(points[i])
+	});
+}
+/**
+* This function gives the zoom levels of the level strategy `detail` (WILD-016 with EDA-038). The levels and their items are the levels of `depths`.
+* A level with groups first shows at the scale `itemAt / size`, with `size` its median item (`pickLevel`). At that scale, `pxMin` pixels are `pxMin × size / itemAt` units.
+* The links of the level collapse their legs that are closer than that length (`collapseLinks`). The last level stays as in `depths`.
+*/
+function detailLevels(input, options) {
+	const levels = depthLevels(input, options);
+	const sizes = itemSizes(levels);
+	return levels.map((level, i) => {
+		if (i === levels.length - 1) return level;
+		const tol = options.pxMin * sizes[i] / PICK.itemAt;
+		return {
+			...level,
+			links: collapseLinks(level.items, level.links, tol, options.minCount)
+		};
+	});
+}
 // src/strategies/options.ts
 /** The number of values of a sweep on a range when the call and the declaration give no number. */
 const SWEEP_COUNT = 5;
@@ -21491,190 +23617,6 @@ function runPipeline(graph, options) {
 		result: asRouter(options.router, routerOptions).route(board)
 	};
 }
-// src/bench/quality.ts
-/** The clearance stops at this distance. */
-const CLEARANCE_CAP = 40;
-const TIGHT = 4;
-const EXACT_CROSSINGS = 2e4;
-const SAMPLE = 2e3;
-const key = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
-/** This function measures the quality of a result. */
-function measureQuality(graph, result) {
-	const byId = nodeIndex(graph);
-	const nodes = new Grid(180);
-	for (const n of graph.nodes) nodes.add(n, n.box);
-	const segs = [];
-	const seen = /* @__PURE__ */ new Set();
-	let bends = 0;
-	let infl = 0;
-	let clear = 0;
-	let tight = 0;
-	let detour = 0;
-	let detourN = 0;
-	let angle = 0;
-	let angleN = 0;
-	for (const r of result.routes) {
-		const p = r.points;
-		for (let i = 1; i < p.length; i++) {
-			const ka = key(p[i - 1]);
-			const kb = key(p[i]);
-			if (ka === kb) continue;
-			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
-			if (seen.has(k)) continue;
-			seen.add(k);
-			segs.push([p[i - 1], p[i]]);
-		}
-		bends += bendCount(p);
-		infl += inflectionCount(p);
-		const ends = endNodes(graph, byId, r.edge);
-		let c = 40;
-		for (let i = 1; i < p.length; i++) {
-			const a = p[i - 1];
-			const b = p[i];
-			nodes.querySegment(a, b, c, (n) => {
-				if (n !== ends.source && n !== ends.target) c = Math.min(c, segmentBoxDistance(a, b, n.box));
-			});
-		}
-		clear += c;
-		if (c < TIGHT) tight++;
-		if (p.length >= 2) {
-			const d = dist(p[0], p[p.length - 1]);
-			if (d > 1) {
-				detour += polylineLength(p) / d;
-				detourN++;
-			}
-			for (const [at, next, node] of [[
-				p[0],
-				p[1],
-				ends.source
-			], [
-				p[p.length - 1],
-				p[p.length - 2],
-				ends.target
-			]]) {
-				if (!node) continue;
-				const a = sideAngle(node.box, at, next);
-				if (a !== void 0) {
-					angle += a;
-					angleN++;
-				}
-			}
-		}
-	}
-	const n = Math.max(1, result.routes.length);
-	let ink = 0;
-	for (const [a, b] of segs) ink += dist(a, b);
-	const [crossings, crossingsEstimated] = countCrossings(segs);
-	return {
-		ink,
-		crossings,
-		crossingsEstimated,
-		bends: bends / n,
-		inflections: infl / n,
-		clearance: clear / n,
-		tight: tight / n,
-		detour: detourN ? detour / detourN : 1,
-		plugAngle: angleN ? angle / angleN : 0
-	};
-}
-function endNodes(graph, byId, edgeId) {
-	const e = edgeIndex(graph).get(edgeId);
-	return {
-		source: e && byId.get(e.source.node),
-		target: e && byId.get(e.target.node)
-	};
-}
-const edgeIndexes = /* @__PURE__ */ new WeakMap();
-function edgeIndex(graph) {
-	let m = edgeIndexes.get(graph);
-	if (!m) {
-		m = /* @__PURE__ */ new Map();
-		for (const e of graph.edges) m.set(e.id, e);
-		edgeIndexes.set(graph, m);
-	}
-	return m;
-}
-/**
-* This function gives an angle in degrees: the angle between the segment from `at` to `next` and the outward normal.
-* The normal is the normal of the side of the box nearest to `at`. A route that starts inside the box (an interior route) gives no angle.
-*/
-function sideAngle(box, at, next) {
-	const d = [
-		[
-			Math.abs(at.y - box.y),
-			0,
-			-1
-		],
-		[
-			Math.abs(at.x - (box.x + box.w)),
-			1,
-			0
-		],
-		[
-			Math.abs(at.y - (box.y + box.h)),
-			0,
-			1
-		],
-		[
-			Math.abs(at.x - box.x),
-			-1,
-			0
-		]
-	].sort((a, b) => a[0] - b[0])[0];
-	if (d[0] > 1) return void 0;
-	const vx = next.x - at.x;
-	const vy = next.y - at.y;
-	const l = Math.hypot(vx, vy);
-	if (l === 0) return void 0;
-	const cos = Math.max(-1, Math.min(1, (vx * d[1] + vy * d[2]) / l));
-	return Math.acos(cos) * 180 / Math.PI;
-}
-/**
-* This function counts the crossings of a set of segments with a grid of buckets.
-* Above 20 000 segments, it counts the crossings of a seeded sample of 2 000 segments and scales the count.
-*/
-function countCrossings(segs) {
-	if (segs.length < 2) return [0, false];
-	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
-	const grid = new Grid(Math.max(20, len));
-	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
-	const exact = segs.length <= EXACT_CROSSINGS;
-	const R = rng(segs.length);
-	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE }, () => Math.floor(R() * segs.length));
-	let count = 0;
-	for (const i of pick) {
-		const [a, b] = segs[i];
-		grid.querySegment(a, b, 0, (j) => {
-			if (exact && j <= i) return;
-			if (j === i) return;
-			const [c, d] = segs[j];
-			if (segmentsCross(a, b, c, d)) count++;
-		});
-	}
-	return exact ? [count, false] : [Math.round(count * segs.length / (2 * pick.length)), true];
-}
-/** This function measures how much the routes changed between two results. */
-function measureStability(before, after) {
-	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
-	let sum = 0;
-	let max = 0;
-	let moved = 0;
-	let n = 0;
-	for (const r of after.routes) {
-		const p = prev.get(r.edge);
-		if (!p) continue;
-		const f = frechet(p, r.points);
-		sum += f;
-		max = Math.max(max, f);
-		if (f > 1) moved++;
-		n++;
-	}
-	return {
-		mean: n ? sum / n : 0,
-		max,
-		moved: n ? moved / n : 0
-	};
-}
 // src/whole/portfolio/index.ts
 /** The clock in milliseconds. */
 const clock = () => globalThis.performance?.now() ?? Date.now();
@@ -21761,6 +23703,916 @@ function measuresOf(graph, result) {
 		ink: inkSaved(result.routes)
 	};
 }
+// src/whole/curriculum/index.ts
+/** The values of `CurriculumOrder`. */
+const CURRICULUM_ORDERS = Object.freeze([
+	"R1-R12-R2",
+	"R12-R1-R2",
+	"R1-R2-R12"
+]);
+/** The default options of the strategy `curriculum`. */
+const CURRICULUM_DEFAULTS = Object.freeze({
+	order: "R1-R12-R2",
+	passes: 1,
+	settings: 3,
+	detour: 2
+});
+/** Two legs closer than this distance count for the lane separation (R12), as in the screen. */
+const NEAR = 4;
+/** This function gives the shape of a route. */
+function shapeOf(route) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const p of route.points) {
+		x0 = Math.min(x0, p.x);
+		y0 = Math.min(y0, p.y);
+		x1 = Math.max(x1, p.x);
+		y1 = Math.max(y1, p.y);
+	}
+	return {
+		route,
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+/** The sine of 5 degrees, as a literal. A literal gives the same bits on each platform, so a decision does not depend on `Math.sin`. */
+const SIN_5 = .08715574274765817;
+/** The constants of the arc sine of fdlibm (`e_asin.c`). */
+const PIO2_HI = 1.5707963267948966;
+const PIO2_LO = 6123233995736766e-32;
+const PIO4_HI = .7853981633974483;
+const PS = [
+	.16666666666666666,
+	-.3255658186224009,
+	.20121253213486293,
+	-.04005553450067941,
+	.0007915349942898145,
+	3479331075960212e-20
+];
+const QS = [
+	-2.403394911734414,
+	2.0209457602335057,
+	-.6882839716054533,
+	.07703815055590194
+];
+const WORDS = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+/** This function gives the rational part `p / q` of the arc sine of fdlibm at `t`. */
+function asinRatio(t) {
+	return [t * (PS[0] + t * (PS[1] + t * (PS[2] + t * (PS[3] + t * (PS[4] + t * PS[5]))))), 1 + t * (QS[0] + t * (QS[1] + t * (QS[2] + t * QS[3])))];
+}
+/**
+* This function gives the arc sine of `x` in radians, from -1 to 1. It is the algorithm of fdlibm, with only `+`, `*`, `/` and `Math.sqrt`.
+* These operations are exact to the last bit on each platform, so the result does not depend on the engine.
+*/
+function arcsin(x) {
+	const ax = Math.abs(x);
+	if (Number.isNaN(x) || ax > 1) return NaN;
+	if (ax === 1) return x * PIO2_HI + x * PIO2_LO;
+	if (ax < .5) {
+		if (ax < 2 ** -27) return x;
+		const [p, q] = asinRatio(x * x);
+		return x + x * (p / q);
+	}
+	const t = (1 - ax) * .5;
+	const [p, q] = asinRatio(t);
+	const s = Math.sqrt(t);
+	let r;
+	WORDS.setFloat64(0, ax);
+	if (WORDS.getUint32(0) >= 1072640819) r = PIO2_HI - (2 * (s + s * (p / q)) - PIO2_LO);
+	else {
+		WORDS.setFloat64(0, s);
+		WORDS.setUint32(4, 0);
+		const w = WORDS.getFloat64(0);
+		const c = (t - w * w) / (s + w);
+		const pp = 2 * s * (p / q) - (PIO2_LO - 2 * c);
+		const qq = PIO4_HI - 2 * w;
+		r = PIO4_HI - (pp - qq);
+	}
+	return x > 0 ? r : -r;
+}
+/** This function gives the distance between the segments `ab` and `cd`, when they do not cross. */
+function segmentGap(a, b, c, d) {
+	const at = (p, u, v) => {
+		const dx = v.x - u.x;
+		const dy = v.y - u.y;
+		const l2 = dx * dx + dy * dy;
+		const t = l2 > 0 ? Math.max(0, Math.min(1, ((p.x - u.x) * dx + (p.y - u.y) * dy) / l2)) : 0;
+		const ex = p.x - u.x - t * dx;
+		const ey = p.y - u.y - t * dy;
+		return Math.sqrt(ex * ex + ey * ey);
+	};
+	return Math.min(at(a, c, d), at(b, c, d), at(c, a, b), at(d, a, b));
+}
+/**
+* This function gives the costs of the rules between two routes. R1 is the number of crossings.
+* R2 is the sum of `1 - θ / 90` over the crossings. θ is the crossing angle in degrees.
+* R12 is the overlap of the legs of `a` and `b` that are within 5 degrees of parallel. The two legs are nearer than 4 units.
+*/
+function pairCosts(a, b) {
+	let r1 = 0;
+	let r2 = 0;
+	let r12 = 0;
+	for (let i = 1; i < a.length; i++) {
+		const p = a[i - 1];
+		const q = a[i];
+		const ux = q.x - p.x;
+		const uy = q.y - p.y;
+		const lu = Math.sqrt(ux * ux + uy * uy);
+		if (lu <= 1e-9) continue;
+		for (let j = 1; j < b.length; j++) {
+			const r = b[j - 1];
+			const s = b[j];
+			const vx = s.x - r.x;
+			const vy = s.y - r.y;
+			const lv = Math.sqrt(vx * vx + vy * vy);
+			if (lv <= 1e-9) continue;
+			if (segmentsCross(p, q, r, s)) {
+				r1++;
+				const angle = arcsin(Math.min(1, Math.abs(ux * vy - uy * vx) / (lu * lv))) * 180 / Math.PI;
+				r2 += 1 - angle / 90;
+				continue;
+			}
+			if (Math.abs(ux * vy - uy * vx) > SIN_5 * lu * lv) continue;
+			const t0 = ((r.x - p.x) * ux + (r.y - p.y) * uy) / lu;
+			const t1 = ((s.x - p.x) * ux + (s.y - p.y) * uy) / lu;
+			const overlap = Math.min(lu, Math.max(t0, t1)) - Math.max(0, Math.min(t0, t1));
+			if (overlap > 1e-9 && segmentGap(p, q, r, s) < NEAR) r12 += overlap;
+		}
+	}
+	return {
+		R1: r1,
+		R2: r2,
+		R12: r12
+	};
+}
+/** This function gives the detour of a route: its length over the distance between its ends. */
+function detourOf$1(points) {
+	const span = dist(points[0], points[points.length - 1]);
+	return span > 1e-9 ? polylineLength(points) / span : 1;
+}
+/**
+* This function runs the whole strategy `curriculum` (RULE-048, after curriculum learning, Bengio 2009). The record has no energy solver yet (RULE-019).
+* Thus a pool of routes of fixed settings takes its place. Each edge can take its route from any setting of the pool.
+* The first answer is the first setting. Each stage adds one rule, in the order `order`. A pass of a stage visits the edges, the worst first.
+* An edge takes the route of the pool with the least cost of the new rule. That cost is lower, and the earlier rules do not get worse.
+* A route with a break of a hard rule is not in the pool. The output has the routes alone, with no runs, bundles or levels.
+*/
+function curriculum(graph, list, options = {}) {
+	const o = {
+		...CURRICULUM_DEFAULTS,
+		...options
+	};
+	const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+	const pool = /* @__PURE__ */ new Map();
+	let first;
+	for (const s of list.slice(0, count)) {
+		const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+		if (limit !== void 0 && graph.nodes.length > limit) continue;
+		const output = runPipeline(graph, s.pipeline);
+		first ??= output;
+		const faulty = new Set(checkProperties(output.graph, output.result, 1e6).map((v) => v.edge));
+		for (const r of output.result.routes) {
+			if (faulty.has(r.edge) || r.points.length < 2) continue;
+			const list2 = pool.get(r.edge);
+			if (list2) list2.push(r);
+			else pool.set(r.edge, [r]);
+		}
+	}
+	if (!first) return runPipeline(graph, list[0].pipeline);
+	const rules = o.order.split("-");
+	const current = new Map(first.result.routes.map((r) => [r.edge, shapeOf(r)]));
+	for (const [edge, shape] of current) {
+		const own = pool.get(edge);
+		if (own && !own.includes(shape.route)) current.set(edge, shapeOf(own[0]));
+	}
+	const costOf = (edge, s) => {
+		const sum = {
+			R1: 0,
+			R2: 0,
+			R12: 0
+		};
+		for (const [other, t] of current) {
+			if (other === edge || t.x0 > s.x1 + NEAR || t.x1 < s.x0 - NEAR || t.y0 > s.y1 + NEAR || t.y1 < s.y0 - NEAR) continue;
+			const c = pairCosts(s.route.points, t.route.points);
+			sum.R1 += c.R1;
+			sum.R2 += c.R2;
+			sum.R12 += c.R12;
+		}
+		return sum;
+	};
+	const edges = [...current.keys()];
+	for (let stage = 0; stage < rules.length; stage++) {
+		const rule = rules[stage];
+		const earlier = rules.slice(0, stage);
+		for (let pass = 0; pass < Math.max(1, Math.floor(o.passes)); pass++) {
+			const costs = new Map(edges.map((e) => [e, costOf(e, current.get(e))]));
+			const order = [...edges].sort((a, b) => costs.get(b)[rule] - costs.get(a)[rule] || (a < b ? -1 : a > b ? 1 : 0));
+			let moved = 0;
+			for (const edge of order) {
+				const now = current.get(edge);
+				const base = costOf(edge, now);
+				if (base[rule] <= 1e-9) continue;
+				const cap = Math.max(o.detour, detourOf$1(now.route.points));
+				let best;
+				for (const r of pool.get(edge) ?? []) {
+					if (r === now.route || detourOf$1(r.points) > cap + 1e-9) continue;
+					const shape = shapeOf(r);
+					const c = costOf(edge, shape);
+					if (c[rule] >= base[rule] - 1e-9 || earlier.some((k) => c[k] > base[k] + 1e-9)) continue;
+					if (!best || c[rule] < best.cost - 1e-9) best = {
+						shape,
+						cost: c[rule]
+					};
+				}
+				if (best) {
+					current.set(edge, best.shape);
+					moved++;
+				}
+			}
+			if (moved === 0) break;
+		}
+	}
+	const routes = first.result.routes.map((r) => current.get(r.edge)?.route ?? r);
+	return {
+		graph: first.graph,
+		result: { routes }
+	};
+}
+// src/highways/slots/index.ts
+/**
+* The highway strategy `slots` (RULE-047): a pull of each route toward the lane slots of the highway skeleton.
+* An edge whose first route runs near a trunk of the plan joins that trunk when the pull is larger than its detour.
+*/
+/** The values of `SlotKeys`. */
+const SLOT_KEYS = Object.freeze(["same", "any"]);
+/** The default options of the strategy `slots`. */
+const SLOT_DEFAULTS = Object.freeze({
+	pull: 2,
+	reach: 24,
+	laneSpacing: 4,
+	maxStretch: 1.25,
+	keys: "same",
+	from: "shared-ways"
+});
+/** This function gives points along a polyline, one at each `step` of length, and the last point. */
+function samplesOf$1(points, step) {
+	const out = [];
+	if (points.length === 0) return out;
+	out.push({
+		p: points[0],
+		arc: 0
+	});
+	let walked = 0;
+	let next = step;
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		const len = dist(a, b);
+		while (len > 0 && next <= walked + len) {
+			const u = (next - walked) / len;
+			out.push({
+				p: {
+					x: a.x + (b.x - a.x) * u,
+					y: a.y + (b.y - a.y) * u
+				},
+				arc: next
+			});
+			next += step;
+		}
+		walked += len;
+	}
+	if (walked > out[out.length - 1].arc + 1e-9) out.push({
+		p: points[points.length - 1],
+		arc: walked
+	});
+	return out;
+}
+/**
+* This function gives the best join of one route to the trunk `h`, or `undefined`.
+* The longest row of samples nearer than `reach` to the spine is the part of the route that the trunk pulls.
+* The slot of the new lane is at `laneSpacing × (lanes + 1) / 2` from the spine. The weight is `w(d) = max(0, 1 - d / r)`.
+*/
+function slotJoin(route, h, index, o) {
+	const step = Math.max(2, o.reach / 4);
+	const samples = samplesOf$1(route, step);
+	const offset = o.laneSpacing * (h.lanes.length + 1) / 2;
+	let best;
+	let start = -1;
+	const near = samples.map((s) => {
+		const at = nearestPlace(h.spine, s.p);
+		return {
+			at,
+			d: dist(s.p, pointAt(h.spine, at))
+		};
+	});
+	for (let i = 0; i <= samples.length; i++) {
+		const inside = i < samples.length && near[i].d < o.reach;
+		if (inside && start < 0) start = i;
+		if (!inside && start >= 0) {
+			if (!best || samples[i - 1].arc - samples[start].arc > samples[best.to].arc - samples[best.from].arc) best = {
+				from: start,
+				to: i - 1
+			};
+			start = -1;
+		}
+	}
+	if (!best || best.to <= best.from) return void 0;
+	const on = near[best.from].at;
+	const off = near[best.to].at;
+	const ride = lengthBetween(h.spine, Math.min(on, off), Math.max(on, off));
+	if (ride < 2 * o.reach || Math.abs(on - off) < 1e-9) return void 0;
+	let pull = 0;
+	for (let i = best.from; i <= best.to; i++) {
+		const d = near[i].d;
+		const w = Math.max(0, 1 - d / o.reach);
+		const gap = d - offset;
+		pull += w * gap * gap;
+	}
+	pull = o.pull * pull * step / (o.reach * o.reach);
+	const arc = samples[best.to].arc - samples[best.from].arc;
+	const detour = near[best.from].d + near[best.to].d + ride - arc;
+	return {
+		highway: index,
+		on,
+		off,
+		pull,
+		detour
+	};
+}
+/**
+* This function gives the plan of the highway strategy `slots` (RULE-047, after the pull of force-directed edge bundling, Holten and van Wijk 2009).
+* The trunks are the highways of the plan `from`. Each edge outside the plan gets a pull toward the slot of a new lane of a trunk near its first route.
+* The energy of the pull is `E = k Σ w(d_i) ‖x_i - slot_i‖²` over the samples of the route, with `w(d) = max(0, 1 - d / r)`.
+* The edge joins the trunk when the pull is larger than the length that the join adds, and the stretch stays under `maxStretch`.
+* The edge takes the trunk with the largest gain, on the outer lane. An edge that does not fit stays off the trunks.
+*/
+function slotPlan(input, options = {}) {
+	const o = {
+		...SLOT_DEFAULTS,
+		...options
+	};
+	const graph = outerGraph(input.graph);
+	return slotsOf(graph, basePlan({
+		...input,
+		graph
+	}, o.from), firstRoutes({
+		...input,
+		graph
+	}), o);
+}
+/** This function adds the joins of `slotPlan` to the plan `first` of the graph. It reads all the options except `from`. A join that breaks a hard rule after `follow` leaves the plan. */
+function slotsOf(graph, first, routes, options = {}) {
+	const o = {
+		...SLOT_DEFAULTS,
+		...options
+	};
+	if (first.highways.length === 0) return first;
+	const riders = new Set(first.highways.flatMap((h) => h.members.map((m) => m.edge)));
+	const added = first.highways.map(() => []);
+	const edges = [...graph.edges].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+	for (const e of edges) {
+		if (riders.has(e.id)) continue;
+		const route = routes.get(e.id);
+		if (!route || route.length < 2) continue;
+		const length = polylineLength(route);
+		if (length <= 1e-9) continue;
+		const key = byCollection(e);
+		let best;
+		first.highways.forEach((h, i) => {
+			if (o.keys === "same" && (key === void 0 || h.key !== key)) return;
+			const j = slotJoin(route, h, i, o);
+			if (!j || j.pull <= j.detour || (length + Math.max(0, j.detour)) / length > o.maxStretch + 1e-9) return;
+			if (!best || j.pull - j.detour > best.pull - best.detour + 1e-9) best = j;
+		});
+		if (best) added[best.highway].push({
+			edge: e.id,
+			on: best.on,
+			off: best.off
+		});
+	}
+	const build = () => tidyPlan({ highways: first.highways.map((h, i) => {
+		const more = added[i];
+		if (more.length === 0) return h;
+		return {
+			...h,
+			lanes: [...h.lanes, ...more.map((m) => m.edge)],
+			members: [...h.members, ...more.map((m) => memberAt(h.spine, m.edge, m.on, m.off, 0))]
+		};
+	}) });
+	const before = new Set(checkProperties(graph, follow(graph, first), 1e6).flatMap((v) => v.edge === void 0 ? [] : [v.edge]));
+	for (let round = 0; round < 4; round++) {
+		if (added.every((list) => list.length === 0)) return first;
+		const plan = build();
+		const faulty = new Set(checkProperties(graph, follow(graph, plan), 1e6).flatMap((v) => v.edge === void 0 ? [] : [v.edge]));
+		const joined = new Set(added.flatMap((list) => list.map((m) => m.edge)));
+		const others = [...faulty].filter((e) => !joined.has(e) && !before.has(e));
+		if (![...faulty].some((e) => joined.has(e)) && others.length === 0) return plan;
+		first.highways.forEach((h, i) => {
+			const hit = others.some((e) => h.members.some((m) => m.edge === e));
+			added[i] = hit ? [] : added[i].filter((m) => !faulty.has(m.edge));
+		});
+	}
+	return first;
+}
+// src/whole/preferences/index.ts
+/** The features of one route, in order: crossings (R1), angle cost (R2), lane overlap (R12) over 20, detour minus 1 (R5), and bends over 2. */
+const PREFERENCE_FEATURES = Object.freeze([
+	"R1",
+	"R2",
+	"R12",
+	"R5",
+	"bends"
+]);
+/** The scale of the lane overlap in the features, in units of length. */
+const OVERLAP_SCALE = 20;
+/**
+* The weights of the made-up panel that labels the made-up pairs, in the order of `PREFERENCE_FEATURES`.
+* The order comes from the studies of the readers of graphs: the crossings count most, then the bends and the length, then the angle (Purchase 1997, Ware, Purchase, Colpoys and McGill 2002).
+* The numbers are made up. They do not come from the screen or from a board.
+*/
+const PREFERENCE_PANEL = Object.freeze([
+	3,
+	.75,
+	.5,
+	1.5,
+	1
+]);
+/** The default options of the strategy `preferences`. */
+const PREFERENCE_DEFAULTS = Object.freeze({
+	l2: .01,
+	passes: 1,
+	settings: 3,
+	detour: 2
+});
+/**
+* This function gives a smooth step from 0 to 1, a stand-in for the logistic function with only `+`, `*`, `/` and `Math.abs`.
+* It is `0.5 + 0.5 z / (1 + |z|)`. These operations are exact to the last bit on each platform.
+*/
+function softStep(z) {
+	return .5 + .5 * z / (1 + Math.abs(z));
+}
+/** This function gives a made-up feature vector of one route. */
+function madeUpFeatures(random) {
+	return [
+		Math.floor(random() * 5),
+		random() * 2,
+		random() * 2,
+		random(),
+		Math.floor(random() * 7) / 2
+	];
+}
+/** This function gives a noise with a mean of 0 and a spread of approximately 0.6: the sum of three uniform values. */
+function noise(random) {
+	return (random() + random() + random() - 1.5) * 1.2;
+}
+/** This function gives the utility of a feature vector for the weights `w`. A larger utility is better. */
+function utility(w, f) {
+	let u = 0;
+	for (let i = 0; i < f.length; i++) u -= w[i] * f[i];
+	return u;
+}
+/**
+* This function gives `count` made-up pairs, with the labels of the made-up panel `PREFERENCE_PANEL` and a noise.
+* The pairs come from the seed alone. They do not come from a board.
+*/
+function madeUpPairs(count, seed) {
+	const random = rng(seed);
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const a = madeUpFeatures(random);
+		const b = madeUpFeatures(random);
+		out.push({
+			a,
+			b,
+			first: utility(PREFERENCE_PANEL, a) - utility(PREFERENCE_PANEL, b) + noise(random) > 0 ? 1 : 0
+		});
+	}
+	return out;
+}
+/** This function gives the share of the pairs where the weights `w` prefer the same route as the panel. */
+function agreementOf(w, pairs) {
+	if (pairs.length === 0) return 0;
+	let n = 0;
+	for (const p of pairs) if ((utility(w, p.a) > utility(w, p.b) ? 1 : 0) === p.first) n++;
+	return n / pairs.length;
+}
+/** The fits of earlier calls, by their options. */
+const FITS = /* @__PURE__ */ new Map();
+/**
+* This function fits the weights of the rules to made-up pairs (RULE-038, a Bradley-Terry model, after Bradley and Terry 1952).
+* The probability that a reader prefers `a` to `b` is `softStep(u(a) - u(b))`, with `u(x) = -w · f(x)`. The fit takes 400 steps of the gradient of the score.
+* An L2 term `l2 × |w|²` keeps the weights small. A weight below 0 becomes 0. The weights are scaled so that their sum is the number of features.
+* The held-out pairs come from the seed plus 7919. The pairs do not come from the screen or from a board.
+*/
+function fitPreferences(options = {}) {
+	const o = {
+		l2: .01,
+		seed: 1,
+		pairs: 200,
+		...options
+	};
+	const key = JSON.stringify(o);
+	const known = FITS.get(key);
+	if (known) return known;
+	const pairs = madeUpPairs(Math.max(1, Math.floor(o.pairs)), o.seed);
+	const n = PREFERENCE_FEATURES.length;
+	const w = new Array(n).fill(1);
+	const rate = .5;
+	for (let step = 0; step < 400; step++) {
+		const grad = new Array(n).fill(0);
+		for (const p of pairs) {
+			const d = p.b.map((v, i) => v - p.a[i]);
+			let z = 0;
+			for (let i = 0; i < n; i++) z += w[i] * d[i];
+			const e = softStep(z) - p.first;
+			for (let i = 0; i < n; i++) grad[i] += e * d[i] / pairs.length;
+		}
+		for (let i = 0; i < n; i++) w[i] = Math.max(0, w[i] - rate * (grad[i] + 2 * o.l2 * w[i]));
+	}
+	const sum = w.reduce((s, v) => s + v, 0);
+	const weights = sum > 1e-12 ? w.map((v) => v * n / sum) : w.map(() => 1);
+	const model = {
+		weights,
+		agreement: agreementOf(weights, madeUpPairs(50, o.seed + 7919)),
+		source: `${Math.floor(o.pairs)} made-up pairs of seed ${o.seed}, labelled by the made-up panel PREFERENCE_PANEL with a noise`
+	};
+	FITS.set(key, model);
+	return model;
+}
+/** This function gives the detour of a route: its length over the distance between its ends. */
+function detourOf(points) {
+	const span = dist(points[0], points[points.length - 1]);
+	return span > 1e-9 ? polylineLength(points) / span : 1;
+}
+/**
+* This function runs the whole strategy `preferences` (RULE-038). It fits the weights of the rules to made-up pairs (`fitPreferences`).
+* Each edge can take its route from any setting of the pool. The first answer is the first setting.
+* A pass visits the edges in order. An edge takes the route of the pool with the least weighted cost, when that cost is lower than the cost of its route.
+* The cost is the weighted sum of the features of the route against the routes of the other edges. A route with a break of a hard rule is not in the pool.
+* The output has the routes alone, with no runs, bundles or levels.
+*/
+function preferences(graph, list, options = {}) {
+	const o = {
+		...PREFERENCE_DEFAULTS,
+		...options
+	};
+	const w = fitPreferences({ l2: o.l2 }).weights;
+	const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+	const pool = /* @__PURE__ */ new Map();
+	let first;
+	for (const s of list.slice(0, count)) {
+		const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+		if (limit !== void 0 && graph.nodes.length > limit) continue;
+		const output = runPipeline(graph, s.pipeline);
+		first ??= output;
+		const faulty = new Set(checkProperties(output.graph, output.result, 1e6).map((v) => v.edge));
+		for (const r of output.result.routes) {
+			if (faulty.has(r.edge) || r.points.length < 2) continue;
+			const own = pool.get(r.edge);
+			if (own) own.push(r);
+			else pool.set(r.edge, [r]);
+		}
+	}
+	if (!first) return runPipeline(graph, list[0].pipeline);
+	const shapeOf = (route) => {
+		let x0 = Infinity;
+		let y0 = Infinity;
+		let x1 = -Infinity;
+		let y1 = -Infinity;
+		for (const p of route.points) {
+			x0 = Math.min(x0, p.x);
+			y0 = Math.min(y0, p.y);
+			x1 = Math.max(x1, p.x);
+			y1 = Math.max(y1, p.y);
+		}
+		return {
+			route,
+			x0,
+			y0,
+			x1,
+			y1,
+			own: w[3] * (detourOf(route.points) - 1) + w[4] * turnsOf(route.points) / 2
+		};
+	};
+	const current = new Map(first.result.routes.map((r) => [r.edge, shapeOf(r)]));
+	for (const [edge, shape] of current) {
+		const own = pool.get(edge);
+		if (own && !own.includes(shape.route)) current.set(edge, shapeOf(own[0]));
+	}
+	const near = 4;
+	const costOf = (edge, s) => {
+		let sum = s.own;
+		for (const [other, t] of current) {
+			if (other === edge || t.x0 > s.x1 + near || t.x1 < s.x0 - near || t.y0 > s.y1 + near || t.y1 < s.y0 - near) continue;
+			const c = pairCosts(s.route.points, t.route.points);
+			sum += w[0] * c.R1 + w[1] * c.R2 + w[2] * c.R12 / OVERLAP_SCALE;
+		}
+		return sum;
+	};
+	const edges = [...current.keys()];
+	for (let pass = 0; pass < Math.max(1, Math.floor(o.passes)); pass++) {
+		let moved = 0;
+		for (const edge of edges) {
+			const now = current.get(edge);
+			const base = costOf(edge, now);
+			const cap = Math.max(o.detour, detourOf(now.route.points));
+			let best;
+			for (const r of pool.get(edge) ?? []) {
+				if (r === now.route || detourOf(r.points) > cap + 1e-9) continue;
+				const shape = shapeOf(r);
+				const c = costOf(edge, shape);
+				if (c < (best?.cost ?? base) - 1e-9) best = {
+					shape,
+					cost: c
+				};
+			}
+			if (best) {
+				current.set(edge, best.shape);
+				moved++;
+			}
+		}
+		if (moved === 0) break;
+	}
+	const routes = first.result.routes.map((r) => current.get(r.edge)?.route ?? r);
+	return {
+		graph: first.graph,
+		result: { routes }
+	};
+}
+// src/whole/fireflies/index.ts
+/** The values of `SwarmSearch`. */
+const SWARM_SEARCHES = Object.freeze(["firefly", "bees"]);
+/** The default options of the strategy `fireflies`. */
+const FIREFLY_DEFAULTS = Object.freeze({
+	search: "firefly",
+	budget: 12,
+	colony: 6,
+	gamma: 1,
+	alpha: .2,
+	limit: 10,
+	seed: 1
+});
+/** The attraction of a firefly at the distance 0, as the record gives it. */
+const BETA0 = 1;
+/** The largest number of rounds of a search. A round with no new setting still counts. */
+const ROUNDS = 60;
+/**
+* This function gives the attraction of a firefly at the distance `r`: `BETA0 / (1 + u + u² / 2)` with `u = gamma × r²`.
+* It is a rational stand-in for `BETA0 × exp(-u)`, with only `+`, `*` and `/`, so it is exact to the last bit on each platform.
+*/
+function attraction(gamma, r2) {
+	const u = gamma * r2;
+	return BETA0 / (1 + u + u * u / 2);
+}
+/** This function gives the setting of a point of the unit square, on the grid of the search. */
+function settingAt(x, y) {
+	const i = Math.max(0, Math.min(19, Math.round(x * 19)));
+	const j = Math.max(0, Math.min(7, Math.round(y * 7)));
+	return {
+		discount: (i + 1) / 20,
+		margin: 3 + j
+	};
+}
+/** The point of the unit square of the defaults of `shared`: the discount 0.5 and the margin 5. */
+const HOME = [9 / 19, 2 / 7];
+/**
+* This function gives the score of an output on its board. A lower score is better.
+* The score is `crossings / edges + (median detour - 1) - ink saved`. A break of a hard rule gives `Infinity`.
+*/
+function swarmScore(output) {
+	if (checkProperties(output.graph, output.result, 1).length > 0) return Infinity;
+	const edges = Math.max(1, output.result.routes.length);
+	return measureQuality(output.graph, output.result).crossings / edges + (detourSpread(output.result.routes).median - 1) - inkSaved(output.result.routes);
+}
+/**
+* This function runs the whole strategy `fireflies` (NAT-047, after the firefly algorithm of Yang 2008 and the bee colony of Karaboga 2005).
+* It searches the options `discount` and `margin` of the router `router` on the board, on a grid of 20 × 8 settings.
+* The first firefly or food source is the default setting, so the score of the output is not worse than the score of the default.
+* A firefly moves toward each brighter one by `attraction(gamma, r²)` of the distance, plus a seeded step of size `alpha`.
+* A bee tries `v = x + phi (x - x_k)` in one dimension, and a scout takes a new seeded place after `limit` tries with no gain.
+* The search stops after `budget` different settings, or after 60 rounds. It reads only the board and the outputs of its own settings.
+*/
+function fireflies(graph, router, options = {}) {
+	const o = {
+		...FIREFLY_DEFAULTS,
+		...options
+	};
+	const budget = Math.max(1, Math.floor(o.budget));
+	const random = rng(Math.max(0, Math.floor(o.seed)));
+	const known = /* @__PURE__ */ new Map();
+	const entries = [];
+	const score = (x, y) => {
+		const setting = settingAt(x, y);
+		const key = `${setting.discount}:${setting.margin}`;
+		const seen = known.get(key);
+		if (seen) return seen.score;
+		if (entries.length >= budget) return Infinity;
+		const output = runPipeline(graph, {
+			router,
+			routerOptions: { ...setting }
+		});
+		const entry = {
+			setting,
+			score: swarmScore(output),
+			output
+		};
+		known.set(key, entry);
+		entries.push(entry);
+		return entry.score;
+	};
+	const clamp = (v) => Math.max(0, Math.min(1, v));
+	const colony = Math.max(2, Math.min(20, Math.floor(o.colony)));
+	const xs = [[HOME[0], HOME[1]]];
+	while (xs.length < colony) xs.push([random(), random()]);
+	const fs = xs.map(([x, y]) => score(x, y));
+	if (o.search === "firefly") for (let round = 0; round < ROUNDS && entries.length < budget; round++) for (let i = 0; i < colony; i++) for (let j = 0; j < colony; j++) {
+		if (!(fs[j] < fs[i])) continue;
+		const dx = xs[j][0] - xs[i][0];
+		const dy = xs[j][1] - xs[i][1];
+		const b = attraction(o.gamma, dx * dx + dy * dy);
+		xs[i] = [clamp(xs[i][0] + b * dx + o.alpha * (random() - .5)), clamp(xs[i][1] + b * dy + o.alpha * (random() - .5))];
+		fs[i] = score(xs[i][0], xs[i][1]);
+	}
+	else {
+		const trials = new Array(colony).fill(0);
+		const tryNear = (i) => {
+			let k = Math.floor(random() * (colony - 1));
+			if (k >= i) k++;
+			const d = random() < .5 ? 0 : 1;
+			const phi = 2 * random() - 1;
+			const v = [xs[i][0], xs[i][1]];
+			v[d] = clamp(v[d] + phi * (v[d] - xs[k][d]));
+			const f = score(v[0], v[1]);
+			if (f < fs[i]) {
+				xs[i] = v;
+				fs[i] = f;
+				trials[i] = 0;
+			} else trials[i]++;
+		};
+		for (let round = 0; round < ROUNDS && entries.length < budget; round++) {
+			for (let i = 0; i < colony; i++) tryNear(i);
+			const order = xs.map((_, i) => i).sort((a, b) => fs[a] - fs[b] || a - b);
+			for (let r = 0; r < colony; r++) {
+				const pick = order[Math.min(colony - 1, Math.floor(random() * random() * colony))];
+				tryNear(pick);
+			}
+			const worn = trials.findIndex((t, i) => t > o.limit && fs[i] !== Math.min(...fs));
+			if (worn >= 0) {
+				xs[worn] = [random(), random()];
+				fs[worn] = score(xs[worn][0], xs[worn][1]);
+				trials[worn] = 0;
+			}
+		}
+	}
+	let best = entries[0];
+	for (const e of entries) if (e.score < best.score - 1e-12) best = e;
+	return {
+		output: best.output,
+		best: best.setting,
+		entries
+	};
+}
+// src/whole/tracing/index.ts
+/** The values of `TracingQuantile`. */
+const TRACING_QUANTILES = Object.freeze([
+	"q50",
+	"q95",
+	"mean"
+]);
+/** The default weights of the tracing load, as the record gives them. */
+const TRACING_WEIGHTS = Object.freeze({
+	crossing: 1,
+	merge: 2,
+	bend: .5
+});
+/** The default options of the strategy `tracing`. */
+const TRACING_DEFAULTS = Object.freeze({
+	...TRACING_WEIGHTS,
+	settings: 4,
+	quantile: "q95"
+});
+/** The bounds of a polyline: the least x and y, and the largest x and y. */
+function boundsOf(p) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const q of p) {
+		x0 = Math.min(x0, q.x);
+		y0 = Math.min(y0, q.y);
+		x1 = Math.max(x1, q.x);
+		y1 = Math.max(y1, q.y);
+	}
+	return [
+		x0,
+		y0,
+		x1,
+		y1
+	];
+}
+/**
+* This function gives the tracing load of each edge of a result (WILD-057, after the tracing tasks of Ware, Purchase, Colpoys and McGill 2002).
+* The load is `T(e) = crossing × crossings + merge × (merges and splits where e is not an outer lane) + bend × bends`.
+* A shared run where the edge is not an outer lane gives one merge and one split. Such a bundle gives one split.
+* A bend is a turn of more than 1 degree. The measure is W4 of MEAS3.
+*/
+function tracingLoads(result, weights = {}) {
+	const w = {
+		...TRACING_WEIGHTS,
+		...weights
+	};
+	const routes = result.routes;
+	const bounds = routes.map((r) => boundsOf(r.points));
+	const crossings = new Array(routes.length).fill(0);
+	for (let i = 0; i < routes.length; i++) {
+		const a = routes[i].points;
+		const [ax0, ay0, ax1, ay1] = bounds[i];
+		for (let j = i + 1; j < routes.length; j++) {
+			const [bx0, by0, bx1, by1] = bounds[j];
+			if (bx0 > ax1 || bx1 < ax0 || by0 > ay1 || by1 < ay0) continue;
+			const b = routes[j].points;
+			let n = 0;
+			for (let p = 1; p < a.length; p++) for (let q = 1; q < b.length; q++) if (segmentsCross(a[p - 1], a[p], b[q - 1], b[q])) n++;
+			crossings[i] += n;
+			crossings[j] += n;
+		}
+	}
+	const choices = /* @__PURE__ */ new Map();
+	const inner = (edges, add) => {
+		if (edges.length < 3) return;
+		for (const e of edges.slice(1, -1)) choices.set(e, (choices.get(e) ?? 0) + add);
+	};
+	for (const run of result.runs ?? []) inner(run.edges, 2);
+	for (const b of result.bundles ?? []) inner(b.edges, 1);
+	const out = /* @__PURE__ */ new Map();
+	routes.forEach((r, i) => out.set(r.edge, w.crossing * crossings[i] + w.merge * (choices.get(r.edge) ?? 0) + w.bend * turnsOf(r.points)));
+	return out;
+}
+/** This function gives a value of a list of loads: the median, the quantile 0.95 by the nearest rank, or the mean. An empty list gives 0. */
+function tracingValue(loads, quantile) {
+	const list = [...loads].sort((a, b) => a - b);
+	if (list.length === 0) return 0;
+	if (quantile === "mean") return list.reduce((s, v) => s + v, 0) / list.length;
+	const q = quantile === "q50" ? .5 : .95;
+	return list[Math.min(list.length - 1, Math.max(0, Math.ceil(q * list.length) - 1))];
+}
+/**
+* This function runs the whole strategy `tracing` (WILD-057). It runs the first `settings` settings of `list` on the board.
+* A setting with a break of a hard rule, or above its node limit, does not count. The setting with the least tracing load wins.
+* A tie goes to the least median load, then to the earlier setting. It reads only the board and the outputs of its own settings.
+*/
+function tracing(graph, list, options = {}) {
+	const o = {
+		...TRACING_DEFAULTS,
+		...options
+	};
+	const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+	const entries = [];
+	const outputs = [];
+	let fallback;
+	for (const s of list.slice(0, count)) {
+		const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+		if (limit !== void 0 && graph.nodes.length > limit) continue;
+		const output = runPipeline(graph, s.pipeline);
+		fallback ??= {
+			name: s.name,
+			output
+		};
+		if (checkProperties(output.graph, output.result, 1).length > 0) continue;
+		const loads = [...tracingLoads(output.result, o).values()];
+		entries.push({
+			name: s.name,
+			value: tracingValue(loads, o.quantile),
+			median: tracingValue(loads, "q50")
+		});
+		outputs.push(output);
+	}
+	if (entries.length === 0) {
+		const first = fallback ?? {
+			name: list[0].name,
+			output: runPipeline(graph, list[0].pipeline)
+		};
+		return {
+			output: first.output,
+			pick: first.name,
+			entries
+		};
+	}
+	let best = 0;
+	entries.forEach((e, i) => {
+		const b = entries[best];
+		if (e.value < b.value - 1e-9 || Math.abs(e.value - b.value) <= 1e-9 && e.median < b.median - 1e-9) best = i;
+	});
+	return {
+		output: outputs[best],
+		pick: entries[best].name,
+		entries
+	};
+}
 // src/strategies/schemas.ts
 /** The options of the way finder (`WayOptions`), for each router that goes around the nodes. */
 const WAY_SCHEMA = {
@@ -24722,6 +27574,25 @@ const SPREAD_SCHEMA = {
 		describe: "The passes that sort each wall again by the new places of the far ends."
 	}
 };
+/** The declarations of the options of the plug strategy `assign` (PLUG-ASSIGN). */
+const ASSIGN_SCHEMA = {
+	plugGap: {
+		type: "number",
+		min: 0,
+		max: 24,
+		step: 1,
+		default: 8,
+		describe: "The least gap between two plugs of one wall. On a short wall, the gap shrinks evenly."
+	},
+	inset: {
+		type: "number",
+		min: 0,
+		max: 12,
+		step: 1,
+		default: 6,
+		describe: "A plug stays this far from the corners of its wall."
+	}
+};
 /** The declarations of the options of the whole strategy `pipeline`. */
 const PIPELINE_SCHEMA = {
 	router: {
@@ -25333,6 +28204,501 @@ const BOARD_PORTFOLIO_SCHEMA = {
 		describe: "The time budget in seconds. The value 0 sets no budget."
 	}
 };
+/** The declarations of the options of the highway strategy `balance` (EDA-017). */
+const BALANCE_SCHEMA = {
+	tau: {
+		type: "number",
+		min: 1.1,
+		max: 2,
+		step: .05,
+		marks: [
+			1.1,
+			1.2,
+			1.5,
+			2
+		],
+		default: 1.2,
+		describe: "The target of the stretch of an edge: its route on the plan over its route alone."
+	},
+	iterations: {
+		type: "integer",
+		min: 5,
+		max: 30,
+		step: 1,
+		marks: [
+			5,
+			10,
+			30
+		],
+		default: 5,
+		describe: "The number of updates of the prices."
+	},
+	end: {
+		type: "enum",
+		values: [
+			"exit",
+			"entry",
+			"both"
+		],
+		default: "exit",
+		describe: "The end of a ride that the price moves: the exit, the entry, or both by half."
+	},
+	from: {
+		...HIGHWAY_BASE,
+		default: "shared-ways"
+	}
+};
+/** The declarations of the options of the highway strategy `manifolds` (WILD-036). */
+const MANIFOLD_SCHEMA = {
+	kMin: {
+		type: "integer",
+		min: 3,
+		max: 8,
+		step: 1,
+		marks: [
+			3,
+			4,
+			6,
+			8
+		],
+		default: 3,
+		describe: "A manifold has this number of taps or more."
+	},
+	band: {
+		type: "number",
+		min: .5,
+		max: 2,
+		step: .25,
+		marks: [
+			.5,
+			1,
+			2
+		],
+		default: 1,
+		describe: "The nodes of one row have centers in a band of this many median box heights."
+	},
+	side: {
+		type: "enum",
+		values: ["near", "far"],
+		default: "near",
+		describe: "The place of the header in the gap before the row: near the row, or near the feed node."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "A tap stays on the manifold only when its way is this many times the direct line or less."
+	},
+	from: {
+		...HIGHWAY_BASE,
+		default: "shared-ways"
+	}
+};
+/** The declarations of the options of the highway strategy `slots` (RULE-047). */
+const SLOT_SCHEMA = {
+	pull: {
+		type: "number",
+		min: .25,
+		max: 8,
+		step: .25,
+		marks: [
+			.5,
+			1,
+			2,
+			4,
+			8
+		],
+		default: 2,
+		describe: "The weight of the pull toward the slot of a new lane."
+	},
+	reach: {
+		type: "number",
+		min: 8,
+		max: 64,
+		step: 4,
+		marks: [
+			8,
+			16,
+			24,
+			48,
+			64
+		],
+		default: 24,
+		describe: "A route point farther than this distance from a trunk gets no pull."
+	},
+	laneSpacing: {
+		type: "number",
+		min: 2,
+		max: 8,
+		step: 1,
+		marks: [
+			2,
+			4,
+			8
+		],
+		default: 4,
+		describe: "The distance between two lanes of a trunk."
+	},
+	maxStretch: {
+		type: "number",
+		min: 1.05,
+		max: 2,
+		step: .05,
+		marks: [
+			1.1,
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.25,
+		describe: "The largest new length of a route over its first length after it joins a trunk."
+	},
+	keys: {
+		type: "enum",
+		values: ["same", "any"],
+		default: "same",
+		describe: "The edges that can join a trunk: only the edges with the key of the trunk, or each edge."
+	},
+	from: {
+		...HIGHWAY_BASE,
+		default: "shared-ways"
+	}
+};
+/** The declarations of the options of the plug strategy `leaders` (EDA-041). */
+const LEADER_SCHEMA = {
+	leader: {
+		type: "enum",
+		values: [
+			"s",
+			"po",
+			"opo"
+		],
+		default: "po",
+		describe: "The type of leader: the order of the angles, the order along the wall, or even places."
+	},
+	slotSpacing: {
+		type: "number",
+		min: 2,
+		max: 8,
+		step: 1,
+		marks: [
+			2,
+			4,
+			8
+		],
+		default: 8,
+		describe: "The least gap between two plugs of one wall."
+	},
+	inset: SPREAD_SCHEMA.inset,
+	rounds: {
+		type: "integer",
+		min: 0,
+		max: 4,
+		step: 1,
+		default: 2,
+		describe: "The passes that sort each wall again by the new places of the far ends."
+	}
+};
+/** The declarations of the options of the level strategy `detail` (WILD-016 with EDA-038): the options of `depths`, and the limits of the collapse. */
+const DETAIL_SCHEMA = {
+	...DEPTHS_SCHEMA,
+	pxMin: {
+		type: "number",
+		min: .5,
+		max: 4,
+		step: .5,
+		marks: [
+			1,
+			2,
+			3,
+			4
+		],
+		default: 3,
+		describe: "Two parallel legs closer than this number of pixels on the screen become one stroke."
+	},
+	minCount: {
+		type: "integer",
+		min: 2,
+		max: 5,
+		step: 1,
+		default: 2,
+		describe: "A stroke holds this number of edges or more."
+	},
+	w0: {
+		type: "number",
+		min: 1,
+		max: 4,
+		step: .5,
+		default: 1.5,
+		describe: "The width of a stroke of one edge, in pixels."
+	},
+	widthScale: {
+		type: "enum",
+		values: [
+			"linear",
+			"sqrt",
+			"log"
+		],
+		default: "log",
+		describe: "The growth of the width of a stroke with its count."
+	}
+};
+/** The declarations of the options of the whole strategy `curriculum` (RULE-048). */
+const CURRICULUM_SCHEMA = {
+	order: {
+		type: "enum",
+		values: [
+			"R1-R12-R2",
+			"R12-R1-R2",
+			"R1-R2-R12"
+		],
+		default: "R1-R12-R2",
+		describe: "The order in which the stages add the rules."
+	},
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 3,
+		step: 1,
+		default: 1,
+		describe: "The number of passes over the edges in each stage."
+	},
+	settings: {
+		type: "integer",
+		min: 2,
+		max: 3,
+		step: 1,
+		default: 3,
+		describe: "The number of settings in the pool of routes, from the start of its list."
+	},
+	detour: {
+		type: "number",
+		min: 1.5,
+		max: 4,
+		step: .25,
+		marks: [
+			1.5,
+			2,
+			3
+		],
+		default: 2,
+		describe: "A new route has a detour of at most this value, or of its old route."
+	}
+};
+/** The declarations of the options of the whole strategy `preferences` (RULE-038). */
+const PREFERENCE_SCHEMA = {
+	l2: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01,
+		marks: [
+			0,
+			.01,
+			.1,
+			1
+		],
+		default: .01,
+		describe: "The weight of the L2 term of the fit of the weights to the made-up pairs."
+	},
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 3,
+		step: 1,
+		default: 1,
+		describe: "The number of passes over the edges."
+	},
+	settings: {
+		type: "integer",
+		min: 2,
+		max: 3,
+		step: 1,
+		default: 3,
+		describe: "The number of settings in the pool of routes, from the start of its list."
+	},
+	detour: {
+		type: "number",
+		min: 1.5,
+		max: 4,
+		step: .25,
+		marks: [
+			1.5,
+			2,
+			3
+		],
+		default: 2,
+		describe: "A new route has a detour of at most this value, or of its old route."
+	}
+};
+/** The declarations of the options of the whole strategy `fireflies` (NAT-047). */
+const FIREFLY_SCHEMA = {
+	search: {
+		type: "enum",
+		values: ["firefly", "bees"],
+		default: "firefly",
+		describe: "The search: the firefly algorithm, or the artificial bee colony."
+	},
+	budget: {
+		type: "integer",
+		min: 4,
+		max: 40,
+		step: 1,
+		marks: [
+			4,
+			12,
+			20,
+			40
+		],
+		default: 12,
+		describe: "The largest number of different settings that the search routes."
+	},
+	colony: {
+		type: "integer",
+		min: 4,
+		max: 20,
+		step: 1,
+		marks: [
+			4,
+			6,
+			10,
+			20
+		],
+		default: 6,
+		describe: "The number of fireflies or food sources."
+	},
+	gamma: {
+		type: "number",
+		min: .01,
+		max: 10,
+		step: .01,
+		scale: "log",
+		marks: [
+			.01,
+			.1,
+			1,
+			10
+		],
+		default: 1,
+		describe: "The absorption of the light of a firefly."
+	},
+	alpha: {
+		type: "number",
+		min: .01,
+		max: .5,
+		step: .01,
+		marks: [
+			.01,
+			.1,
+			.2,
+			.5
+		],
+		default: .2,
+		describe: "The size of the random step of a firefly, as a share of the range."
+	},
+	limit: {
+		type: "integer",
+		min: 10,
+		max: 100,
+		step: 10,
+		marks: [
+			10,
+			50,
+			100
+		],
+		default: 10,
+		describe: "A scout bee leaves a food source after this number of tries with no gain."
+	},
+	seed: {
+		type: "integer",
+		min: 0,
+		max: 1e6,
+		step: 1,
+		marks: [
+			1,
+			2,
+			3
+		],
+		default: 1,
+		describe: "The seed of the search. The same seed gives the same routes."
+	}
+};
+/** The declarations of the options of the whole strategy `tracing` (WILD-057). */
+const TRACING_SCHEMA = {
+	crossing: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			1,
+			2,
+			4
+		],
+		default: 1,
+		describe: "The weight of a crossing in the tracing load."
+	},
+	merge: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			1,
+			2,
+			4
+		],
+		default: 2,
+		describe: "The weight of a merge or a split where the edge is not an outer lane."
+	},
+	bend: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [
+			0,
+			.5,
+			1,
+			4
+		],
+		default: .5,
+		describe: "The weight of a bend in the tracing load."
+	},
+	settings: {
+		type: "integer",
+		min: 1,
+		max: 12,
+		step: 1,
+		marks: [
+			1,
+			4,
+			8,
+			12
+		],
+		default: 4,
+		describe: "The number of settings that the strategy tries, from the start of its list."
+	},
+	quantile: {
+		type: "enum",
+		values: [
+			"q50",
+			"q95",
+			"mean"
+		],
+		default: "q95",
+		describe: "The value of the loads of the edges that the pick reads."
+	}
+};
 // src/strategies/builtins.ts
 /** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
 function routerStrategy(name, describe, maxNodes, defaults, make, schema) {
@@ -26084,6 +29450,33 @@ const highwayStrategies = Object.freeze({
 		maxNodes: 1e4,
 		run: (input, o) => bronchialPlan(input, o)
 	}),
+	balance: defineStrategy({
+		step: "highway",
+		name: "balance",
+		describe: "Stretch balance in a bundle (EDA-017). A price for each edge grows while its stretch is above the target, and the price moves its exit forward.",
+		defaults: { ...BALANCE_DEFAULTS },
+		schema: BALANCE_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => balancePlan(input, o)
+	}),
+	manifolds: defineStrategy({
+		step: "highway",
+		name: "manifolds",
+		describe: "Manifolds for a fan to a row (WILD-036). A straight header in the gap before the row, with taps at right angles and one feed from the node.",
+		defaults: { ...MANIFOLD_DEFAULTS },
+		schema: MANIFOLD_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => manifoldPlan(input, o)
+	}),
+	slots: defineStrategy({
+		step: "highway",
+		name: "slots",
+		describe: "A pull toward the lane slots of the trunks (RULE-047). An edge near a trunk joins it on a new lane when the pull is larger than its detour.",
+		defaults: { ...SLOT_DEFAULTS },
+		schema: SLOT_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => slotPlan(input, o)
+	}),
 	"corridors+breakeven": gateStrategy(corridors, breakEvenGate),
 	"corridors+stretch": gateStrategy(corridors, stretchGate),
 	"corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -26127,6 +29520,22 @@ const plugStrategies = Object.freeze({
 		defaults: { ...SPREAD_DEFAULTS },
 		schema: SPREAD_SCHEMA,
 		run: (input, o) => spreadEnds(input, o)
+	}),
+	leaders: defineStrategy({
+		step: "plugs",
+		name: "leaders",
+		describe: "Boundary leaders as plug stubs (EDA-041). The plugs of each wall take the order of po-leaders with no crossing, and keep a least gap.",
+		defaults: { ...LEADER_DEFAULTS },
+		schema: LEADER_SCHEMA,
+		run: (input, o) => leaderEnds(input, o)
+	}),
+	assign: defineStrategy({
+		step: "plugs",
+		name: "assign",
+		describe: "PLUG-ASSIGN. The plugs of each wall go into the ranges of their ports with a minimum gap. The most ends are in their range, then the order of the far ends.",
+		defaults: { ...ASSIGN_DEFAULTS },
+		schema: ASSIGN_SCHEMA,
+		run: (input, o) => assignEnds(input, o)
 	})
 });
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
@@ -26146,6 +29555,14 @@ const levelStrategies = Object.freeze({
 		defaults: { ...VENATION_DEFAULTS },
 		schema: VENATION_SCHEMA,
 		run: (input, o) => venationLevels(input, o)
+	}),
+	detail: defineStrategy({
+		step: "levels",
+		name: "detail",
+		describe: "The level of detail of the bundles (WILD-016 with EDA-038). Legs of level links closer than a few pixels at the scale of their level become one stroke.",
+		defaults: { ...DETAIL_DEFAULTS },
+		schema: DETAIL_SCHEMA,
+		run: (input, o) => detailLevels(input, o)
 	})
 });
 /**
@@ -26177,6 +29594,18 @@ const BOARD_PORTFOLIO_SETTINGS = Object.freeze([...[
 	}
 }))].map((s) => Object.freeze(s)));
 /**
+* The pool of routes of the whole strategy `curriculum` (RULE-048), in order: the routers of the base of the screen. The first one gives the first answer.
+* The option `settings` takes the first ones.
+*/
+const CURRICULUM_POOL = Object.freeze([
+	"corners",
+	"shared",
+	"trunks"
+].map((name) => Object.freeze({
+	name,
+	pipeline: { router: routerStrategies[name] }
+})));
+/**
 * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
 * Without options, it routes the graph with the router `corners`.
 */
@@ -26196,6 +29625,38 @@ const wholeStrategies = Object.freeze({
 		defaults: { ...BOARD_PORTFOLIO_DEFAULTS },
 		schema: BOARD_PORTFOLIO_SCHEMA,
 		run: (graph, o) => boardPortfolio(graph, BOARD_PORTFOLIO_SETTINGS, o).output
+	}),
+	curriculum: defineStrategy({
+		step: "whole",
+		name: "curriculum",
+		describe: "A curriculum of rules (RULE-048). Each stage adds one rule, and each edge takes the route of a pool that improves it with no loss on the earlier rules.",
+		defaults: { ...CURRICULUM_DEFAULTS },
+		schema: CURRICULUM_SCHEMA,
+		run: (graph, o) => curriculum(graph, CURRICULUM_POOL, o)
+	}),
+	preferences: defineStrategy({
+		step: "whole",
+		name: "preferences",
+		describe: "Rule weights from preferences (RULE-038). A fit to made-up pairs gives the weights, and each edge takes the route of a pool with the least weighted cost.",
+		defaults: { ...PREFERENCE_DEFAULTS },
+		schema: PREFERENCE_SCHEMA,
+		run: (graph, o) => preferences(graph, CURRICULUM_POOL, o)
+	}),
+	fireflies: defineStrategy({
+		step: "whole",
+		name: "fireflies",
+		describe: "Firefly and bee searches (NAT-047). A seeded swarm searches the discount and the margin of `shared` on the board, within a budget of settings.",
+		defaults: { ...FIREFLY_DEFAULTS },
+		schema: FIREFLY_SCHEMA,
+		run: (graph, o) => fireflies(graph, routerStrategies.shared, o).output
+	}),
+	tracing: defineStrategy({
+		step: "whole",
+		name: "tracing",
+		describe: "The least tracing load (WILD-057). The pipeline tries a fixed list of settings, and the least load of crossings, merges and bends on one edge wins.",
+		defaults: { ...TRACING_DEFAULTS },
+		schema: TRACING_SCHEMA,
+		run: (graph, o) => tracing(graph, BOARD_PORTFOLIO_SETTINGS, o).output
 	})
 });
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
@@ -26221,6 +29682,42 @@ function sideOf(plug, node) {
 	for (const [side, n] of Object.entries(SIDE_NORMAL)) if (n.x === plug.normal.x && n.y === plug.normal.y) return side;
 	return nearestSide(node.box, plug.point);
 }
+/**
+* This function moves the new fixed ports of a side of a node into their ranges (PORT-RANGE). It does this when one port is out of its range.
+* The ports of the side keep their order, and two of them keep at least `gap` (`placeInIntervals`). A side with each port in its range does not change.
+*/
+function keepInRanges(node, ports, gap, inset) {
+	const bySide = /* @__PURE__ */ new Map();
+	for (const p of ports.values()) {
+		const list = bySide.get(p.side);
+		if (list) list.push(p);
+		else bySide.set(p.side, [p]);
+	}
+	const box = node.box;
+	for (const [side, list] of bySide) {
+		const along = alongAxis(side);
+		const v = (p) => p.at[along] + (along === "y" ? box.y : box.x);
+		if (!list.some((p) => {
+			const r = rangeInterval(box, side, p, inset);
+			return r !== void 0 && (v(p) < r[0] - 1e-6 || v(p) > r[1] + 1e-6);
+		})) continue;
+		const start = along === "y" ? box.y : box.x;
+		const len = along === "y" ? box.h : box.w;
+		const sorted = [...list].sort((a, b) => v(a) - v(b));
+		const span = sorted.map((p) => rangeInterval(box, side, p, inset) ?? [start, start + len]);
+		const at = placeInIntervals(sorted.map(v), span.map((r) => r[0]), span.map((r) => r[1]), gap);
+		sorted.forEach((p, i) => {
+			const point = {
+				...p.at,
+				[along]: at[i] - start
+			};
+			ports.set(p.id, {
+				...p,
+				at: point
+			});
+		});
+	}
+}
 /** This function gives an id that no port of the node has, from `base`. */
 function freeId(taken, base) {
 	let id = base;
@@ -26235,6 +29732,7 @@ function freeId(taken, base) {
 *
 * The rule sees the graph of `corners`: the plugs of `resolvePorts`, without the inner edges of the frames.
 * The rule is a strategy of the step `plugs`, or the name of one in the registry.
+* A new fixed port with a `range` is in its range (PORT-RANGE). When the rule gives a plug out of the range, the new plugs of that side move into their ranges.
 * The output is a new graph. The function does not change the input.
 */
 function fixPorts(graph, rule, options = {}) {
@@ -26303,6 +29801,16 @@ function fixPorts(graph, rule, options = {}) {
 			target
 		};
 	});
+	const own = strategy.defaults;
+	const given = options.plugOptions ?? {};
+	const num = (a, b, c) => typeof a === "number" ? a : typeof b === "number" ? b : c;
+	const gap = num(given.plugGap, own.plugGap, 0);
+	const inset = num(given.inset, own.inset, 6);
+	const ranges = options.ranges ?? (strategy.name === "assign" ? "rule" : "keep");
+	for (const [id, m] of fixed) {
+		const node = byId.get(id);
+		if (node && ranges === "keep") keepInRanges(node, m, gap, inset);
+	}
 	const nodes = graph.nodes.map((n) => {
 		const m = fixed.get(n.id);
 		const more = added.get(n.id);
@@ -33584,18 +37092,21 @@ const MOVE_NAMES = Object.freeze({
 	search: "searched",
 	interchanges: "networkRoad",
 	knee: "tree",
-	bronchial: "tree"
+	bronchial: "tree",
+	manifolds: "manifold"
 });
 /**
 * The highway strategies that change the plan of another strategy (`from`). Their own move is a change of that plan, so they count no move.
 * The output against the plan `from` tells if they ran.
 */
 const PLAN_CHANGERS = Object.freeze([
+	"balance",
 	"crossbars",
 	"divided",
 	"lanes",
 	"level-links",
 	"meet",
+	"slots",
 	"stubs",
 	"weiszfeld",
 	"zipper"
@@ -35799,6 +39310,6 @@ const sharedStretchStrategy = defineStrategy({
 		name: "shared-stretch"
 	}).route(graph)
 });
-export { AMBIGUITY_GUARD_DEFAULTS, ANNEALING_DEFAULTS, ANNEALING_SCHEMA, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BIPARTITE, BIPARTITE_LAYOUTS, BOARD_PORTFOLIO_DEFAULTS, BOARD_PORTFOLIO_SETTINGS, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, BUILT_IN_STRATEGIES, BoundaryWalk, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, COVERAGE_FAMILIES, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FAN_OUT, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRAME_ROWS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, GUTTER_BEND_COST, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, KNEE_DEFAULTS, KNEE_RULES, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, LOCAL_MESH, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PIPELINE, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_V3, SCREEN_V3_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPARSE_LONG, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, THIN_BARS, TIGHT_DEFAULTS, TIGHT_FIRSTS, TIGHT_SCHEMA, TIGHT_TIES, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, TWO_HUBS, UNEVEN_SIZES, VENATION_BACKBONES, VENATION_DEFAULTS, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, annealWays, annealingRouter, annealingStrategy, arcCurve, areaPlan, aroundBox, asRouter, attractionRouter, attractionStrategy, backboneLinks, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardPortfolio, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, bronchialPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diamondAngle, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, firstLines, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, gutterRoutes, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, kneeOf, kneePlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, makeFixture, makeRoom, manifestHash, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rankShares, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, signTestPower, silhouette, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, splitTargets, spreadEnds, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, tightRouter, tightStrategy, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, venationLevels, venationLinks, waySlacks, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
+export { ADAM_DEFAULTS, ADAM_SCHEMA, AMBIGUITY_GUARD_DEFAULTS, ANNEALING_DEFAULTS, ANNEALING_SCHEMA, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ASSIGN_DEFAULTS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BALANCE_DEFAULTS, BALANCE_ENDS, BIPARTITE, BIPARTITE_LAYOUTS, BOARD_PORTFOLIO_DEFAULTS, BOARD_PORTFOLIO_SETTINGS, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, BUILT_IN_STRATEGIES, BoundaryWalk, CANAL_DEFAULTS, CANAL_SCHEMA, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, COVERAGE_FAMILIES, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURRICULUM_DEFAULTS, CURRICULUM_ORDERS, CURRICULUM_POOL, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DETAIL_DEFAULTS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FAN_OUT, FDEB_DEFAULTS, FIREFLY_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRAME_ROWS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, GUTTER_BEND_COST, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, KNEE_DEFAULTS, KNEE_RULES, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEADER_DEFAULTS, LEADER_TYPES, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, LOCAL_MESH, MANIFOLD_DEFAULTS, MANIFOLD_SIDES, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PIPELINE, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PREFERENCE_DEFAULTS, PREFERENCE_FEATURES, PREFERENCE_PANEL, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, REROUTE_DEFAULTS, REROUTE_SCHEMA, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_V3, SCREEN_V3_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SLOT_DEFAULTS, SLOT_KEYS, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPARSE_LONG, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SWARM_SEARCHES, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, THIN_BARS, TIGHT_DEFAULTS, TIGHT_FIRSTS, TIGHT_SCHEMA, TIGHT_TIES, TINY_UNIFORM, TOLERANCE, TRACING_DEFAULTS, TRACING_QUANTILES, TRACING_WEIGHTS, TRACLUS_DEFAULTS, TRAFFIC_RULES, TWO_HUBS, UNEVEN_SIZES, VENATION_BACKBONES, VENATION_DEFAULTS, WEISZFELD_DEFAULTS, WIDTH_SCALES, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adamRouter, adamRoutes, adamStrategy, adjustedRandIndex, agreementOf, allSections, ambiguity, ambiguityGate, ambiguityPlan, annealWays, annealingRouter, annealingStrategy, arcCurve, arcsin, areaPlan, aroundBox, asRouter, assignEnds, assignWall, attraction, attractionRouter, attractionStrategy, backboneLinks, backtrackOf, balance, balanceOf, balancePlan, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardPortfolio, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, bronchialPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, canalHubs, canalRouter, canalStrategy, canalWays, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, collapseLinks, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curriculum, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detailLevels, detailWidth, detourSpread, diamondAngle, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, fireflies, firstLines, fitPreferences, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, gutterRoutes, halfPower, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, kneeOf, kneePlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leaderEnds, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, madeUpPairs, makeFixture, makeRoom, manifestHash, manifoldPlan, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, pairCosts, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, preferences, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rankShares, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, rerouteRouter, rerouteStrategy, rerouteWays, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, settingAt, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, signTestPower, silhouette, skeletonGroups, skeletonPath, slackSettings, slotJoin, slotPlan, slotsOf, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, softStep, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, splitTargets, spreadEnds, spreadWith, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, swarmScore, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, tightRouter, tightStrategy, toSvgPath, totalTurn, tracePlan, tracing, tracingLoads, tracingValue, traclusPlan, treeCost, treeDepth, trunksRouter, turns, turnsOf, unwrappedName, utf8, venationLevels, venationLinks, waySlacks, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
 
 //# sourceMappingURL=index.js.map