@mark1russell7/highways 0.1.4 → 0.1.5

package/build/index.js

@@ -1510,7 +1510,7 @@ var Obstacles = class {
 	hit(a, b, pad, skip) {
 		let found;
 		this.#grid.someSegment(a, b, pad, (n) => {
-			if (skip?.has(n) || !hits(a, b, n, pad)) return false;
+			if (skip?.has(n) || !hits$1(a, b, n, pad)) return false;
 			found = n;
 			return true;
 		});
@@ -1543,7 +1543,7 @@ var Obstacles = class {
 	}
 };
 /** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
-function hits(a, b, n, pad) {
+function hits$1(a, b, n, pad) {
 	const x = n.box;
 	return segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad);
 }
@@ -1738,7 +1738,7 @@ var CornerGraph = class {
 					if ((full & cone) !== 0) continue;
 				}
 				let blocked = false;
-				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
+				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits$1(p, q, blockers[b], pad);
 				if (blocked) continue;
 				const hit = this.#obstacles.hit(p, q, pad);
 				if (hit !== void 0) blockers.push(hit);
@@ -2625,7 +2625,7 @@ function sumFaults(list) {
 // src/levels.ts
 /** The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through. */
 const TIGHT_MARGIN = 1;
-const EPS = 1e-6;
+const EPS$1 = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
 * and the points where the way turns back on itself.
@@ -2633,15 +2633,15 @@ const EPS = 1e-6;
 function tidy(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		while (out.length >= 2) {
 			const a = out[out.length - 2];
 			const b = out[out.length - 1];
 			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-			if (Math.abs(cross) > EPS * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$1 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		out.push(q);
 	}
 	return out;
@@ -2881,7 +2881,7 @@ function freeSpans(lo, hi, covered) {
 		if (x >= hi) break;
 	}
 	if (x < hi) out.push([x, hi]);
-	return out.filter(([a, b]) => b - a > EPS);
+	return out.filter(([a, b]) => b - a > EPS$1);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -3013,7 +3013,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 		out.push(...step.legs);
 		const end = out[out.length - 1];
 		const before = out[out.length - 2];
-		axis = Math.abs(end.y - before.y) < EPS ? "x" : Math.abs(end.x - before.x) < EPS ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$1 ? "x" : Math.abs(end.x - before.x) < EPS$1 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -3023,7 +3023,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
 */
 function square(a, b, obstacles, pad, from, to) {
-	if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$1 || Math.abs(a.y - b.y) < EPS$1) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -3700,7 +3700,7 @@ function trunksRouter(options) {
 	};
 }
 // src/routers/index.ts
-/** The routers that the benchmark races. */
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 const ROUTERS = [
 	straightRouter,
 	plugsRouter,
@@ -3823,17 +3823,34 @@ function openGaps(items, gaps, snap = DEFAULT_SNAP) {
 * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
 */
 function roomDemand(items, links, options = {}) {
+	const gutter = options.gutter ?? DEFAULT_GUTTER;
+	const snap = options.snap ?? DEFAULT_SNAP;
+	const passes = Math.max(1, Math.floor(options.passes ?? 1));
+	let total = demandOnce(items, links, options);
+	for (let p = 1; p < passes; p++) {
+		const next = demandOnce(openGaps(items, total, snap), links, options);
+		if (next.length !== total.length || next.some((g, i) => g.axis !== total[i].axis)) break;
+		total = total.map((g, i) => ({
+			...g,
+			lanes: Math.max(g.lanes, next[i].lanes),
+			need: g.need + Math.max(0, next[i].need - next[i].width)
+		}));
+	}
+	return capGrowth(items, total, gutter, options.maxGrowth ?? Infinity);
+}
+/** This function gives the demand of one pass, without the limit `maxGrowth`. */
+function demandOnce(items, links, options) {
 	const gutter = options.gutter ?? DEFAULT_GUTTER;
 	const spacing = options.spacing ?? DEFAULT_SPACING;
 	const snap = options.snap ?? DEFAULT_SNAP;
 	const weight = (l) => options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1;
 	const gaps = boardGaps(items, snap);
 	const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
-	return capGrowth(items, gaps.map((g, i) => ({
+	return gaps.map((g, i) => ({
 		...g,
 		lanes: lanes[i],
 		need: Math.max(g.width, gutter + lanes[i] * spacing)
-	})), gutter, options.maxGrowth ?? Infinity);
+	}));
 }
 /** This function gives the demand of the board and the board with each gap open to its need. */
 function makeRoom(items, links, options = {}) {
@@ -4018,6 +4035,141 @@ function capGrowth(items, gaps, gutter, maxGrowth) {
 	}
 	return out;
 }
+// src/room/lanes.ts
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+const LANE_ORDERS = [
+	"links",
+	"ends",
+	"crossings"
+];
+const EPS = 1e-6;
+const ROUNDS = 8;
+/**
+* This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+* A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+* When a move puts a link through more boxes than before, the link keeps its points.
+*/
+function gapLanes(items, links, options = {}) {
+	const spacing = Math.max(0, options.spacing ?? 4);
+	const order = options.order ?? "crossings";
+	const moved = links.map((l) => l.points.map((p) => ({
+		x: p.x,
+		y: p.y
+	})));
+	for (const g of boardGaps(items, options.snap)) {
+		if (g.width <= EPS) continue;
+		const across = g.axis;
+		const along = g.axis === "x" ? "y" : "x";
+		const lo = g.at - g.width;
+		const hi = g.at;
+		const pieces = [];
+		links.forEach((l, li) => {
+			const p = l.points;
+			for (let i = 2; i <= p.length - 2; i++) {
+				const a = p[i - 1];
+				const b = p[i];
+				if (Math.abs(a[across] - b[across]) > EPS || a[across] <= lo + EPS || a[across] >= hi - EPS) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS) continue;
+				const side = (q, r) => Math.sign(r[across] - q[across]);
+				pieces.push({
+					link: li,
+					seg: i,
+					lo: Math.min(a[along], b[along]),
+					hi: Math.max(a[along], b[along]),
+					turns: [[a[along], side(a, p[i - 2])], [b[along], side(b, p[i + 1])]]
+				});
+			}
+		});
+		if (pieces.length === 0) continue;
+		const list = orderPieces(pieces, order);
+		const lane = [];
+		let n = 0;
+		list.forEach((P, i) => {
+			let k = 0;
+			for (let j = 0; j < i; j++) if (overlaps(list[j], P)) k = Math.max(k, lane[j] + 1);
+			lane.push(k);
+			n = Math.max(n, k + 1);
+		});
+		const step = Math.min(spacing, g.width / (n + 1));
+		const mid = (lo + hi) / 2;
+		list.forEach((P, i) => {
+			const v = mid + (lane[i] - (n - 1) / 2) * step;
+			moved[P.link][P.seg - 1][across] = v;
+			moved[P.link][P.seg][across] = v;
+		});
+	}
+	const boxes = new Grid(Math.max(20, meanSide(items)));
+	for (const i of items) boxes.add(i.box, i.box);
+	return links.map((l, i) => hits(boxes, moved[i]) > hits(boxes, l.points) ? l : {
+		...l,
+		points: moved[i]
+	});
+}
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;
+/**
+* This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
+* A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
+*/
+function cost(P, Q) {
+	let c = 0;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS && y < Q.hi - EPS) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS && y < P.hi - EPS) c++;
+	return c;
+}
+/** This function gives the pieces of one gap in lane order, from the near side to the far side. */
+function orderPieces(pieces, order) {
+	if (order === "links") return [...pieces];
+	const sum = (P) => P.turns.reduce((s, [, side]) => s + side, 0);
+	const list = [...pieces].sort((P, Q) => sum(P) - sum(Q) || P.link - Q.link || P.seg - Q.seg);
+	if (order === "ends") return list;
+	const n = list.length;
+	const index = new Map(list.map((P, i) => [P, i]));
+	const c = list.map((P) => list.map((Q) => P !== Q && overlaps(P, Q) ? cost(P, Q) : 0));
+	const at = (P, Q) => c[index.get(P)][index.get(Q)];
+	for (let round = 0; round < ROUNDS; round++) {
+		let better = false;
+		for (let i = 0; i < n; i++) {
+			const x = list[i];
+			let best = 0;
+			let to = i;
+			let d = 0;
+			for (let k = i - 1; k >= 0; k--) {
+				d += at(x, list[k]) - at(list[k], x);
+				if (d < best) [best, to] = [d, k];
+			}
+			d = 0;
+			for (let k = i + 1; k < n; k++) {
+				d += at(list[k], x) - at(x, list[k]);
+				if (d < best) [best, to] = [d, k];
+			}
+			if (to !== i) {
+				list.splice(i, 1);
+				list.splice(to, 0, x);
+				better = true;
+			}
+		}
+		if (!better) break;
+	}
+	return list;
+}
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items) {
+	let s = 0;
+	for (const i of items) s += Math.max(i.box.w, i.box.h);
+	return items.length ? s / items.length : 1;
+}
+/** This function counts the legs of a polyline that go through a box, for each box. */
+function hits(boxes, p) {
+	let n = 0;
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		boxes.querySegment(a, b, 0, (box) => {
+			if (segmentHitsBox(a, b, box)) n++;
+		});
+	}
+	return n;
+}
 // src/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -4306,6 +4458,196 @@ function formatFaults(rows) {
 		})
 	].join("\n");
 }
+// src/strategies/model.ts
+/** The steps that have strategies, in the order of the pipeline. */
+const STEPS = [
+	"router",
+	"curve",
+	"room"
+];
+/**
+* This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+* When the caller gives no option, the definition gets the `defaults` object itself.
+*/
+function defineStrategy(definition) {
+	const { step, name, describe, defaults, maxNodes } = definition;
+	if (name.length === 0) throw new Error(`A strategy of the step "${step}" has no name.`);
+	const strategy = {
+		step,
+		name,
+		describe,
+		defaults: Object.freeze({ ...defaults }),
+		...maxNodes === void 0 ? {} : { maxNodes },
+		run(input, options) {
+			const all = options === void 0 || Object.keys(options).length === 0 ? strategy.defaults : {
+				...strategy.defaults,
+				...options
+			};
+			return definition.run(input, all);
+		}
+	};
+	return Object.freeze(strategy);
+}
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+function createRegistry(strategies) {
+	const out = {
+		router: [],
+		curve: [],
+		room: []
+	};
+	for (const s of strategies) {
+		const list = out[s.step];
+		if (!list) throw new Error(`There is no step "${String(s.step)}". The steps are ${STEPS.join(", ")}.`);
+		if (list.some((t) => t.name === s.name)) throw new Error(`The step "${s.step}" has two strategies with the name "${s.name}".`);
+		list.push(s);
+	}
+	return Object.freeze({
+		router: Object.freeze(out.router),
+		curve: Object.freeze(out.curve),
+		room: Object.freeze(out.room)
+	});
+}
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+function register(registry, ...strategies) {
+	return createRegistry([
+		...registry.router,
+		...registry.curve,
+		...registry.room,
+		...strategies
+	]);
+}
+/** This function gives the strategies of one step of a registry, in order. */
+function listStrategies(registry, step) {
+	return registry[step];
+}
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+function findStrategy(registry, step, name) {
+	return listStrategies(registry, step).find((s) => s.name === name);
+}
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+function getStrategy(registry, step, name) {
+	const s = findStrategy(registry, step, name);
+	if (!s) throw new Error(`There is no ${step} "${name}". The registry has ${listStrategies(registry, step).map((t) => t.name).join(", ")}.`);
+	return s;
+}
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+function asRouter(strategy, options) {
+	return {
+		name: strategy.name,
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		route: (graph) => strategy.run(graph, options)
+	};
+}
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+function routersOf(registry) {
+	return listStrategies(registry, "router").map((s) => asRouter(s));
+}
+// src/strategies/builtins.ts
+/** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
+function routerStrategy(name, describe, maxNodes, defaults, make) {
+	return defineStrategy({
+		step: "router",
+		name,
+		describe,
+		defaults,
+		maxNodes,
+		run: (graph, options) => make({
+			...options,
+			name
+		}).route(graph)
+	});
+}
+/** This function makes a router strategy for a router without options. */
+function fixedRouter(router, describe) {
+	return defineStrategy({
+		step: "router",
+		name: router.name,
+		describe,
+		defaults: {},
+		run: (graph) => router.route(graph)
+	});
+}
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+const routerStrategies = Object.freeze({
+	straight: fixedRouter(straightRouter, "The control. Each edge is one straight line between its plugs."),
+	plugs: fixedRouter(plugsRouter, "Each edge leaves its plug along the normal of the side and follows the curve of the inflection rule. It does not go around the nodes."),
+	corners: routerStrategy("corners", "Each edge goes around the nodes on a shortest path (A*) through a sparse visibility graph of the box corners.", 1e4, {}, cornersRouter),
+	"corners-smooth": routerStrategy("corners-smooth", "The same paths as `corners`. A route in clear view follows the inflection rule, and the other routes get round corners.", 1e4, { smooth: true }, cornersRouter),
+	trunks: routerStrategy("trunks", "A rule puts edges in groups. The edges of a group leave one plug of one node on one trunk. At a split point, each edge goes on to its target.", 1e4, { rule: byCollection }, trunksRouter),
+	shared: routerStrategy("shared", "The edges of one collection share their ways through the corner graph. A link that the group uses already costs half.", 1e4, { rule: byCollection }, sharedRouter),
+	"shared-all": routerStrategy("shared-all", "The same as `shared`, but all edges share their ways.", 1e4, {}, sharedRouter),
+	sections: routerStrategy("sections", "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.", 1e5, {}, sectionsRouter),
+	"sections-tree": routerStrategy("sections-tree", "The same as `sections`, but without the limit of the stretch.", 1e5, { stretch: Infinity }, sectionsRouter)
+});
+/** The context of a curve input, without the keys that have no value. */
+const contextOf = (input) => ({
+	...input.startNormal ? { startNormal: input.startNormal } : {},
+	...input.endNormal ? { endNormal: input.endNormal } : {},
+	...input.space ? { space: input.space } : {}
+});
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+const curveStrategies = Object.freeze({
+	straight: defineStrategy({
+		step: "curve",
+		name: "straight",
+		describe: "The polyline as it is.",
+		defaults: {},
+		run: (input) => straightCurve(input.points)
+	}),
+	rounded: defineStrategy({
+		step: "curve",
+		name: "rounded",
+		describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => roundedCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	}),
+	spline: defineStrategy({
+		step: "curve",
+		name: "spline",
+		describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
+		defaults: { tension: 0 },
+		run: (input, o) => splineCurve(input.points, {
+			...contextOf(input),
+			tension: o.tension
+		})
+	}),
+	arc: defineStrategy({
+		step: "curve",
+		name: "arc",
+		describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => arcCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	})
+});
+const roomStrategy = (method, describe) => defineStrategy({
+	step: "room",
+	name: method,
+	describe,
+	defaults: {},
+	run: (input, o) => roomDemand(input.items, input.links, {
+		...o,
+		method
+	})
+});
+/** The built-in room strategies: the methods of `roomDemand`. */
+const roomStrategies = Object.freeze({
+	routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
+	lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap.")
+});
+/** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
+const BUILT_IN_STRATEGIES = Object.freeze([
+	...Object.values(routerStrategies),
+	...Object.values(curveStrategies),
+	...Object.values(roomStrategies)
+]);
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+const STRATEGIES = createRegistry(BUILT_IN_STRATEGIES);
 // src/bench/curves.ts
 const now$1 = () => globalThis.performance?.now() ?? Date.now();
 /**
@@ -4314,6 +4656,13 @@ const now$1 = () => globalThis.performance?.now() ?? Date.now();
 * The type `spline` leaves each plug along the normal of the nearest side of its node.
 */
 function benchCurves(router, fixture, graph, options = {}) {
+	return benchCurveStrategies(router, fixture, graph, CURVE_TYPES.map((t) => curveStrategies[t]), options);
+}
+/**
+* This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+* The option `radius` goes to each strategy. A strategy without such an option does not read it.
+*/
+function benchCurveStrategies(router, fixture, graph, curves, options = {}) {
 	const tolerance = options.tolerance ?? .25;
 	const result = router.route(graph);
 	const byId = nodeIndex(graph);
@@ -4337,17 +4686,17 @@ function benchCurves(router, fixture, graph, options = {}) {
 	});
 	const base = measureLinks(boxes, routes);
 	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
-	return CURVE_TYPES.map((type) => {
+	const radius = { radius: options.radius ?? 12 };
+	return curves.map((curve) => {
 		const make = (withSpace) => routes.map((r) => ({
 			source: r.source,
 			target: r.target,
-			points: sampleCurve(curveOf(r.points, {
-				type,
-				radius: options.radius ?? 12,
+			points: sampleCurve(curve.run({
+				points: r.points,
 				startNormal: r.startNormal,
 				endNormal: r.endNormal,
 				...withSpace ? { space } : {}
-			}), tolerance)
+			}, radius), tolerance)
 		}));
 		const free = measureLinks(boxes, make(false));
 		const t0 = now$1();
@@ -4357,7 +4706,7 @@ function benchCurves(router, fixture, graph, options = {}) {
 		return {
 			router: router.name,
 			fixture,
-			type,
+			type: curve.name,
 			links: routes.length,
 			through: base.through,
 			free: free.through,
@@ -4393,11 +4742,13 @@ function areaOf(nodes) {
 }
 /**
 * This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
-* It also measures the lane routes of the router `sections` at the lane width `spacing`.
+* With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+* Without it, the links of a gap share the lines of the level links.
+* The function also measures the lane routes of the router `sections` at the lane width `spacing`.
 */
-function measureBoard(graph, spacing) {
+function measureBoard(graph, spacing, order) {
 	const links = roomLinks(graph);
-	const drawn = levelLinks(graph.nodes.map((n) => ({
+	const level = levelLinks(graph.nodes.map((n) => ({
 		id: n.id,
 		box: n.box,
 		nodes: [n.id]
@@ -4406,6 +4757,10 @@ function measureBoard(graph, spacing) {
 		target: l.target,
 		count: l.count ?? 1
 	})));
+	const drawn = order ? gapLanes(graph.nodes, level, {
+		spacing,
+		order
+	}) : level;
 	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
 	const edgeOf = /* @__PURE__ */ new Map();
 	for (const e of graph.edges) {
@@ -4427,10 +4782,10 @@ function measureBoard(graph, spacing) {
 	};
 }
 /**
-* This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
-* The options of `makeRoom` are the same for each method, except `method`.
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+* The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
 */
-function benchRoom(fixture, graph, options = {}) {
+function benchRoom(fixture, graph, options = {}, methods = [roomStrategies.routes, roomStrategies.lines]) {
 	const spacing = options.spacing ?? 4;
 	const area0 = areaOf(graph.nodes);
 	const links = roomLinks(graph);
@@ -4445,28 +4800,129 @@ function benchRoom(fixture, graph, options = {}) {
 		}, spacing)
 	});
 	const rows = [row("packed", graph.nodes, 0)];
-	const states = [
-		["gutter", {
-			...options,
-			spacing: 0,
-			method: "routes"
-		}],
-		["routes", {
-			...options,
-			method: "routes"
-		}],
-		["lines", {
-			...options,
-			method: "lines"
-		}]
-	];
-	for (const [board, o] of states) {
+	const t0 = now();
+	const gutter = makeRoom(graph.nodes, links, {
+		...options,
+		spacing: 0,
+		method: "routes"
+	});
+	rows.push(row("gutter", gutter.items, now() - t0));
+	const { method: _method, ...preset } = options;
+	for (const s of methods) {
+		const t1 = now();
+		const gaps = s.run({
+			items: graph.nodes,
+			links
+		}, preset);
+		const nodes = openGaps(graph.nodes, gaps, options.snap);
+		rows.push(row(s.name, nodes, now() - t1));
+	}
+	return rows;
+}
+/**
+* This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+* The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
+*/
+function sweepRoom(fixture, graph, settings, baseline = {
+	gutter: 8,
+	spacing: 4
+}) {
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms, spacing, lanes) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing, lanes)
+	});
+	const rows = [row("gutter", makeRoom(graph.nodes, links, {
+		...baseline,
+		spacing: 0,
+		method: "routes",
+		maxGrowth: Infinity,
+		passes: 1
+	}).items, 0, baseline.spacing ?? 4)];
+	for (const s of settings) {
 		const t0 = now();
-		const room = makeRoom(graph.nodes, links, o);
-		rows.push(row(board, room.items, now() - t0));
+		const open = makeRoom(graph.nodes, links, {
+			...s.options,
+			method: "routes"
+		});
+		rows.push(row(s.name, open.items, now() - t0, s.options.spacing ?? 4, s.lanes));
 	}
 	return rows;
 }
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+const GROWTH_SWEEP = [
+	0,
+	.06,
+	.09,
+	.12,
+	.15,
+	.18,
+	.21,
+	.25,
+	.3,
+	.35,
+	.5,
+	Infinity
+];
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+function growthSettings(values = GROWTH_SWEEP) {
+	return values.map((m) => ({
+		name: `maxGrowth ${m}`,
+		options: {
+			gutter: 8,
+			spacing: 4,
+			maxGrowth: m
+		}
+	}));
+}
+/**
+* This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+* The order `shared` is the far view without lanes, as before ROOM-C.
+*/
+function laneSettings(spacings = [
+	2,
+	4,
+	6,
+	8
+], orders = LANE_ORDERS) {
+	return spacings.flatMap((spacing) => [{
+		name: `shared spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		}
+	}, ...orders.map((lanes) => ({
+		name: `${lanes} spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		},
+		lanes
+	}))]);
+}
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+function passSettings(gutters = [
+	4,
+	8,
+	12,
+	16
+], passes = [1, 2]) {
+	return gutters.flatMap((gutter) => passes.map((p) => ({
+		name: `gutter ${gutter} passes ${p}`,
+		options: {
+			gutter,
+			spacing: 4,
+			passes: p
+		}
+	})));
+}
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 function formatRoom(rows) {
 	return [
@@ -4478,6 +4934,6 @@ function formatRoom(rows) {
 		})
 	].join("\n");
 }
-export { BACKTRACK_MIN, BACKTRACK_SHARE, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, Grid, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, arcCurve, backtrackOf, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, cubicAt, curveOf, curveSpace, denseGroupsBoard, dist, distinctPoints, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatTable, frechet, goesOutAndBack, groupEdges, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roomDemand, roomLinks, roundCorners, roundedCurve, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splineCurve, splitPoint, straightCurve, straightRouter, sumFaults, toSvgPath, treeDepth, trunksRouter, turns };
+export { BACKTRACK_MIN, BACKTRACK_SHARE, BUILT_IN_STRATEGIES, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, GROWTH_SWEEP, Grid, LANE_ORDERS, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, STEPS, STRATEGIES, TOLERANCE, WayFinder, allSections, arcCurve, asRouter, backtrackOf, benchCurveStrategies, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, createRegistry, cubicAt, curveOf, curveSpace, curveStrategies, defineStrategy, denseGroupsBoard, dist, distinctPoints, findStrategy, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatTable, frechet, gapLanes, getStrategy, goesOutAndBack, groupEdges, growthSettings, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, laneSettings, listStrategies, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, passSettings, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, register, rng, roomDemand, roomLinks, roomStrategies, roundCorners, roundedCurve, routerStrategies, routersOf, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splineCurve, splitPoint, straightCurve, straightRouter, sumFaults, sweepRoom, toSvgPath, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map