@mark1russell7/highways 0.9.0 → 0.9.1

package/build/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_RNG, RECORD_EPS, RECT_SCATTERED, SPLIT_SCHEMA, canonicalJson, canonicalJson as canonicalJson$1, checkDeclared, compareMeasure, corpusHashOf, createFamilyRegistry, createFamilyRegistry as createFamilyRegistry$1, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex, sha256Hex as sha256Hex$1, splitFileName } from "@mark1russell7/layout-contract";
+import { DEFAULT_RNG, RECORD_EPS, RECT_SCATTERED, SPLIT_SCHEMA, canonicalJson, canonicalJson as canonicalJson$1, checkDeclared, compareMeasure, corpusHashOf, createFamilyRegistry, createFamilyRegistry as createFamilyRegistry$1, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portPoint, portfolio, randomInt, selectBest, sha256Hex, sha256Hex as sha256Hex$1, splitFileName } from "@mark1russell7/layout-contract";
 // src/geom.ts
 /** This function gives the distance between two points. */
 function dist(a, b) {
@@ -331,14 +331,75 @@ function nodeIndex(g) {
 	for (const n of g.nodes) m.set(n.id, n);
 	return m;
 }
-/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+/** The names of the sides in `@mark1russell7/layout-contract`. */
+const CONTRACT_SIDE = {
+	north: "top",
+	east: "right",
+	south: "bottom",
+	west: "left"
+};
+/**
+* This function gives the place of a fixed plug, relative to the top-left corner of the node box, or `undefined` for a free plug.
+* A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
+*/
+function portOffset(box, port) {
+	if (port.at !== void 0) return port.at;
+	if (port.side === void 0 || port.along === void 0) return void 0;
+	return portPoint(box, {
+		id: port.id,
+		side: CONTRACT_SIDE[port.side],
+		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`. */
+function checkPort(node, port) {
+	if (port.along === void 0) return;
+	const at = `The plug "${port.id}" of the node "${node.id}"`;
+	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.`);
+}
+/**
+* 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`).
+*/
+function resolvePorts(graph) {
+	let found = false;
+	for (const n of graph.nodes) for (const p of n.ports ?? []) {
+		checkPort(n, p);
+		if (p.along !== void 0) found = true;
+	}
+	if (!found) return graph;
+	const nodes = graph.nodes.map((n) => {
+		if (!n.ports?.some((p) => p.along !== void 0)) return n;
+		const ports = n.ports.map((p) => {
+			if (p.along === void 0) return p;
+			return {
+				id: p.id,
+				side: p.side,
+				at: portOffset(n.box, p)
+			};
+		});
+		return {
+			...n,
+			ports
+		};
+	});
+	return {
+		...graph,
+		nodes
+	};
+}
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
 function fixedPortPoint(node, end) {
 	if (end.port === void 0) return void 0;
 	const p = node.ports?.find((q) => q.id === end.port);
-	if (p?.at === void 0) return void 0;
+	const at = p === void 0 ? void 0 : portOffset(node.box, p);
+	if (at === void 0) return void 0;
 	return {
-		x: node.box.x + p.at.x,
-		y: node.box.y + p.at.y
+		x: node.box.x + at.x,
+		y: node.box.y + at.y
 	};
 }
 // src/fixtures.ts
@@ -4984,7 +5045,8 @@ function sidePlugs(ways, s, es, t, et, options = {}) {
 function cornersRouter(options) {
 	const router = {
 		name: options.name,
-		route(graph) {
+		route(input) {
+			const graph = resolvePorts(input);
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const routes = [];
@@ -5065,7 +5127,7 @@ function spacePlugs(ends, gap) {
 			ps,
 			4
 		]]) {
-			if ((end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port))?.at !== void 0) continue;
+			if (fixedPortPoint(node, end) !== void 0) continue;
 			const key = JSON.stringify([
 				node.id,
 				plug.normal.x,
@@ -5114,7 +5176,8 @@ function spacePlugs(ends, gap) {
 */
 const plugsRouter = {
 	name: "plugs",
-	route(graph) {
+	route(input) {
+		const graph = resolvePorts(input);
 		const byId = nodeIndex(graph);
 		const routes = [];
 		for (const e of graph.edges) {
@@ -5943,7 +6006,8 @@ const dedupe$4 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
 function sectionsRouter(options) {
 	const router = {
 		name: options.name,
-		route(graph) {
+		route(input) {
+			const graph = resolvePorts(input);
 			const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
 			const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
 			const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;
@@ -6984,7 +7048,8 @@ function trunksRouter(options) {
 	const rule = groupRuleOf(options.rule);
 	const router = {
 		name: options.name,
-		route(graph) {
+		route(input) {
+			const graph = resolvePorts(input);
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const points = /* @__PURE__ */ new Map();
@@ -7162,7 +7227,7 @@ function turn(from, base, to) {
 * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
 * The result gives each stretch as a run, with the order of its lanes.
 */
-function sharedRouter(options) {
+function sharedRouter(options, negotiation) {
 	const discount = Math.min(1, Math.max(.05, options.discount ?? .5));
 	const flow = options.cost === "flow";
 	const alpha = Math.min(1, Math.max(.1, options.alpha ?? .6));
@@ -7179,7 +7244,8 @@ function sharedRouter(options) {
 	};
 	const router = {
 		name: options.name,
-		route(graph) {
+		route(input) {
+			const graph = resolvePorts(input);
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const corners = ways.corners;
@@ -7221,8 +7287,11 @@ function sharedRouter(options) {
 				if (wd === void 0) widths.set(k, wd = channelWidth(ways.obstacles, corners.points[i], corners.points[j]));
 				return wd;
 			};
-			/** This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`. */
-			const route = (w, before) => {
+			/**
+			* This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`.
+			* `history` holds the history of each link of the key, for the negotiation of `attraction`.
+			*/
+			const route = (w, before, history) => {
 				let used = discounted.get(w.key);
 				if (!used) discounted.set(w.key, used = /* @__PURE__ */ new Map());
 				const mine = used;
@@ -7239,6 +7308,20 @@ function sharedRouter(options) {
 					cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
 					floor /= (1 + reuse * most) ** reuseExponent;
 				}
+				if (negotiation !== void 0 && history !== void 0) {
+					const plain = cost;
+					const a = negotiation.attraction;
+					const b = negotiation.capacityWeight;
+					let most = 0;
+					for (const h of history.values()) most = Math.max(most, h);
+					cost = (i, j, d) => {
+						const k = link(i, j);
+						const use = (mine.get(k)?.length ?? 0) + 1;
+						const cap = Math.max(1, Math.floor(widthOf(i, j) / negotiation.laneWidth));
+						return plain(i, j, d) * (1 - a * (history.get(k) ?? 0)) * (1 + b * Math.max(0, use - cap));
+					};
+					floor *= 1 - a * most;
+				}
 				const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
 				if (!way) return;
 				w.found = true;
@@ -7254,8 +7337,38 @@ function sharedRouter(options) {
 					if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b)).length));
 				}
 			};
-			for (const w of order) route(w);
-			for (let pass = 1; pass < passes; pass++) {
+			/**
+			* This function gives the passes of the negotiation (HWY-044). After each pass, the history of each link grows by `use / m`,
+			* with `m` the edges of the key, up to `0.9 / attraction`. Each later pass routes each edge again from no ways.
+			*/
+			const negotiate = (list) => {
+				const nego = negotiation;
+				const histories = /* @__PURE__ */ new Map();
+				const size = /* @__PURE__ */ new Map();
+				for (const w of list) size.set(w.key, (size.get(w.key) ?? 0) + 1);
+				const most = nego.attraction > 0 ? .9 / nego.attraction : Infinity;
+				for (let pass = 0; pass < Math.max(1, Math.floor(nego.passes)); pass++) {
+					if (pass > 0) {
+						for (const [key, links] of discounted) {
+							let h = histories.get(key);
+							if (!h) histories.set(key, h = /* @__PURE__ */ new Map());
+							const m = size.get(key) ?? 1;
+							for (const [k, users] of links) h.set(k, Math.min(most, (h.get(k) ?? 0) + users.length / m));
+						}
+						discounted.clear();
+						top.clear();
+						for (const w of list) {
+							w.found = false;
+							w.seq = [];
+							w.ids = [];
+						}
+					}
+					for (const w of list) route(w, void 0, histories.get(w.key) ?? /* @__PURE__ */ new Map());
+				}
+			};
+			if (negotiation !== void 0) negotiate(order);
+			else for (const w of order) route(w);
+			for (let pass = 1; negotiation === void 0 && pass < passes; pass++) {
 				if (reuse > 0) {
 					const before = /* @__PURE__ */ new Map();
 					for (const [key, links] of discounted) before.set(key, new Map([...links].map(([k, list]) => [k, list.length])));
@@ -7497,7 +7610,8 @@ function boxExit(box, toward) {
 */
 const straightRouter = {
 	name: "straight",
-	route(graph) {
+	route(input) {
+		const graph = resolvePorts(input);
 		const byId = nodeIndex(graph);
 		const routes = [];
 		for (const e of graph.edges) {
@@ -7516,6 +7630,209 @@ const straightRouter = {
 		return { routes };
 	}
 };
+// src/strategies/model.ts
+/**
+* The steps that have strategies, in the order of the pipeline.
+* The plugs come before the router, because the router searches its ways between them. The levels come after the routes, because the last level reads them.
+* The step `whole` runs the other steps, so it comes last.
+*/
+const STEPS = [
+	"group",
+	"plugs",
+	"router",
+	"highway",
+	"levels",
+	"curve",
+	"room",
+	"whole"
+];
+/** This function gives a frozen copy of a schema, with each declaration frozen. */
+function freezeSchema(schema) {
+	const out = {};
+	for (const [key, d] of Object.entries(schema)) out[key] = Object.freeze({ ...d });
+	return Object.freeze(out);
+}
+/**
+* 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, schema, 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 }),
+		...schema === void 0 ? {} : { schema: freezeSchema(schema) },
+		...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 = {
+		group: [],
+		plugs: [],
+		router: [],
+		highway: [],
+		levels: [],
+		curve: [],
+		room: [],
+		whole: []
+	};
+	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({
+		group: Object.freeze(out.group),
+		plugs: Object.freeze(out.plugs),
+		router: Object.freeze(out.router),
+		highway: Object.freeze(out.highway),
+		levels: Object.freeze(out.levels),
+		curve: Object.freeze(out.curve),
+		room: Object.freeze(out.room),
+		whole: Object.freeze(out.whole)
+	});
+}
+/** 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([...STEPS.flatMap((step) => listStrategies(registry, step)), ...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/routers/attraction/index.ts
+/** The default options of the router `attraction`. */
+const ATTRACTION_DEFAULTS = Object.freeze({
+	passes: 3,
+	attraction: .5,
+	capacityWeight: 1,
+	laneWidth: 4
+});
+/** The declarations of the options of the router `attraction` (HWY-044). */
+const ATTRACTION_SCHEMA = {
+	passes: {
+		type: "integer",
+		min: 1,
+		max: 10,
+		step: 1,
+		marks: [
+			2,
+			3,
+			5
+		],
+		default: 3,
+		describe: "The number of passes. Each later pass routes each edge again from no ways."
+	},
+	attraction: {
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .05,
+		marks: [
+			.25,
+			.5,
+			.75
+		],
+		default: .5,
+		describe: "The pull of the history of a link. A busy link of the passes before costs less."
+	},
+	capacityWeight: {
+		type: "number",
+		min: 0,
+		max: 10,
+		step: .5,
+		marks: [
+			0,
+			1,
+			4
+		],
+		default: 1,
+		describe: "The cost weight of each edge over the capacity of a link."
+	},
+	laneWidth: {
+		type: "number",
+		min: 1,
+		max: 12,
+		step: 1,
+		marks: [4, 6],
+		default: 4,
+		describe: "The width of one lane. The capacity of a link is its free width divided by this width."
+	}
+};
+/**
+* This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+* After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+* In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+* The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+*/
+function attractionRouter(options) {
+	const o = {
+		...ATTRACTION_DEFAULTS,
+		...options
+	};
+	return sharedRouter({
+		name: o.name,
+		...o.rule === void 0 ? {} : { rule: o.rule },
+		...o.maxNodes === void 0 ? {} : { maxNodes: o.maxNodes }
+	}, {
+		passes: Math.max(1, Math.floor(o.passes)),
+		attraction: Math.min(1, Math.max(0, o.attraction)),
+		capacityWeight: Math.max(0, o.capacityWeight),
+		laneWidth: Math.max(1e-6, o.laneWidth)
+	});
+}
+/**
+* The router strategy `attraction` (HWY-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 attractionStrategy = defineStrategy({
+	step: "router",
+	name: "attraction",
+	describe: "Negotiated attraction (HWY-044). The router `shared` routes each edge again in each pass, and the busy links of the passes before pull the edges.",
+	defaults: { ...ATTRACTION_DEFAULTS },
+	schema: ATTRACTION_SCHEMA,
+	maxNodes: 1e4,
+	run: (graph, o) => attractionRouter({
+		...o,
+		name: "attraction",
+		rule: byCollection
+	}).route(graph)
+});
 // src/routers/index.ts
 /** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 const ROUTERS = [
@@ -8409,154 +8726,49 @@ function facingEnds(input) {
 	}
 	return out;
 }
-// src/strategies/model.ts
-/**
-* The steps that have strategies, in the order of the pipeline.
-* The plugs come before the router, because the router searches its ways between them. The levels come after the routes, because the last level reads them.
-* The step `whole` runs the other steps, so it comes last.
-*/
-const STEPS = [
-	"group",
-	"plugs",
-	"router",
-	"highway",
-	"levels",
-	"curve",
-	"room",
-	"whole"
-];
-/** This function gives a frozen copy of a schema, with each declaration frozen. */
-function freezeSchema(schema) {
-	const out = {};
-	for (const [key, d] of Object.entries(schema)) out[key] = Object.freeze({ ...d });
-	return Object.freeze(out);
+// src/highways/model.ts
+/** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
+function pointAt(line, at) {
+	if (line.length === 0) throw new Error("The polyline has no point.");
+	if (at <= 0) return line[0];
+	if (at >= line.length - 1) return line[line.length - 1];
+	const i = Math.floor(at);
+	const u = at - i;
+	const a = line[i];
+	if (u === 0) return a;
+	const b = line[i + 1];
+	return {
+		x: a.x + (b.x - a.x) * u,
+		y: a.y + (b.y - a.y) * u
+	};
+}
+/** This function gives the length of a polyline from the place `from` to the place `to`, with `from` not larger than `to`. */
+function lengthBetween(line, from, to) {
+	if (to <= from) return 0;
+	let sum = 0;
+	let prev = pointAt(line, from);
+	for (let i = Math.floor(from) + 1; i < to; i++) {
+		const p = line[i];
+		sum += dist(prev, p);
+		prev = p;
+	}
+	return sum + dist(prev, pointAt(line, to));
+}
+/** This function gives a member of a highway with its merge point and its split point at the places `on` and `off` of the spine. */
+function memberAt(spine, edge, on, off, seq = 0) {
+	return {
+		edge,
+		on,
+		off,
+		merge: pointAt(spine, on),
+		split: pointAt(spine, off),
+		seq
+	};
 }
 /**
-* This function 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, schema, 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 }),
-		...schema === void 0 ? {} : { schema: freezeSchema(schema) },
-		...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 = {
-		group: [],
-		plugs: [],
-		router: [],
-		highway: [],
-		levels: [],
-		curve: [],
-		room: [],
-		whole: []
-	};
-	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({
-		group: Object.freeze(out.group),
-		plugs: Object.freeze(out.plugs),
-		router: Object.freeze(out.router),
-		highway: Object.freeze(out.highway),
-		levels: Object.freeze(out.levels),
-		curve: Object.freeze(out.curve),
-		room: Object.freeze(out.room),
-		whole: Object.freeze(out.whole)
-	});
-}
-/** 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([...STEPS.flatMap((step) => listStrategies(registry, step)), ...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/highways/model.ts
-/** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
-function pointAt(line, at) {
-	if (line.length === 0) throw new Error("The polyline has no point.");
-	if (at <= 0) return line[0];
-	if (at >= line.length - 1) return line[line.length - 1];
-	const i = Math.floor(at);
-	const u = at - i;
-	const a = line[i];
-	if (u === 0) return a;
-	const b = line[i + 1];
-	return {
-		x: a.x + (b.x - a.x) * u,
-		y: a.y + (b.y - a.y) * u
-	};
-}
-/** This function gives the length of a polyline from the place `from` to the place `to`, with `from` not larger than `to`. */
-function lengthBetween(line, from, to) {
-	if (to <= from) return 0;
-	let sum = 0;
-	let prev = pointAt(line, from);
-	for (let i = Math.floor(from) + 1; i < to; i++) {
-		const p = line[i];
-		sum += dist(prev, p);
-		prev = p;
-	}
-	return sum + dist(prev, pointAt(line, to));
-}
-/** This function gives a member of a highway with its merge point and its split point at the places `on` and `off` of the spine. */
-function memberAt(spine, edge, on, off, seq = 0) {
-	return {
-		edge,
-		on,
-		off,
-		merge: pointAt(spine, on),
-		split: pointAt(spine, off),
-		seq
-	};
-}
-/**
-* This function lists the problems of a plan against its graph. A good plan gives an empty list.
-* Each highway has a spine of two points or more, and two members or more. Each member is an edge of the graph, with `on` and `off` on the spine and apart.
-* An edge is a member of a highway one time at most.
+* This function lists the problems of a plan against its graph. A good plan gives an empty list.
+* Each highway has a spine of two points or more, and two members or more. Each member is an edge of the graph, with `on` and `off` on the spine and apart.
+* An edge is a member of a highway one time at most.
 */
 function checkPlan(graph, plan) {
 	const edges = new Set(graph.edges.map((e) => e.id));
@@ -8624,7 +8836,8 @@ function slice(stops, on, off) {
 * The result has a shared run for each stretch of a spine where the same two edges or more go. Each run holds the points of its routes in a row.
 * The same graph, plan and options give the same result.
 */
-function follow(graph, plan, options = {}) {
+function follow(input, plan, options = {}) {
+	const graph = resolvePorts(input);
 	const byId = nodeIndex(graph);
 	const ways = new WayFinder(graph.nodes, options);
 	const base = new Map((options.routes?.routes ?? []).map((r) => [r.edge, r.points]));
@@ -11266,9 +11479,9 @@ function snapPlan(input, lines, o) {
 		const a = free(line.a);
 		const b = free(line.b);
 		if (dist(a, b) <= finder.margin) continue;
-		const raw = corners.path(a, b);
+		const raw = o.direct === true && finder.obstacles.clear(a, b, pad) ? [a, b] : corners.path(a, b);
 		if (!raw) continue;
-		const spine = corners.pull(raw);
+		const spine = o.direct === true && raw.length === 2 ? raw : corners.pull(raw);
 		if (spine.length < 2 || polylineLength(spine) <= 1e-6) continue;
 		const riders = [];
 		for (const m of line.members) {
@@ -15922,7 +16135,7 @@ const P_HUB_DEFAULTS = Object.freeze({
 	minSize: 2
 });
 /** The largest number of candidate points. A larger set keeps each `k`-th point. */
-const MAX_CANDIDATES = 300;
+const MAX_CANDIDATES$1 = 300;
 /** This function gives the centres of the cells of each section of the tree. */
 function sectionCentres(root) {
 	const out = [];
@@ -15943,8 +16156,8 @@ function hubCandidates(input, candidates) {
 		seen.add(key);
 		return true;
 	});
-	if (points.length <= MAX_CANDIDATES) return points;
-	const k = Math.ceil(points.length / MAX_CANDIDATES);
+	if (points.length <= MAX_CANDIDATES$1) return points;
+	const k = Math.ceil(points.length / MAX_CANDIDATES$1);
 	return points.filter((_, i) => i % k === 0);
 }
 /**
@@ -16228,93 +16441,1271 @@ function scaleSpacePlan(input, o) {
 		minSize: Math.max(2, Math.round(o.minSize))
 	});
 }
-// src/highways/ridges/index.ts
-/** The default options of the strategy `ridges`. */
-const RIDGE_DEFAULTS = Object.freeze({
-	source: "lines",
-	cell: 8,
-	bandwidth: 16,
-	strength: .15,
-	minLength: 60,
-	snap: 16,
-	minSize: 2
-});
-/** The largest angle between an edge and a ridge that it snaps to, in degrees. */
-const MAX_ANGLE = 30;
+// src/highways/free-lines.ts
+/** The values of `StreetSource`. */
+const STREET_SOURCES = Object.freeze(["room", "corners"]);
+const round = (v) => Math.round(v * 2) / 2;
+/**
+* This function gives the free pieces of the line `x = c` (axis `x`) or `y = c` (axis `y`). A box closer than `pad` to the line blocks it.
+* A piece shorter than `min` is not in the list. The pieces run over the board and `2 pad` past it.
+*/
+function freePieces(finder, axis, c, pad, min, lo, hi) {
+	const blocks = [];
+	const strip = axis === "x" ? {
+		x: c - pad,
+		y: lo,
+		w: 2 * pad,
+		h: hi - lo
+	} : {
+		x: lo,
+		y: c - pad,
+		w: hi - lo,
+		h: 2 * pad
+	};
+	finder.obstacles.query(strip, (n) => {
+		const a = axis === "x" ? n.box.x : n.box.y;
+		const w = axis === "x" ? n.box.w : n.box.h;
+		if (c <= a - pad || c >= a + w + pad) return;
+		const b = axis === "x" ? n.box.y : n.box.x;
+		const h = axis === "x" ? n.box.h : n.box.w;
+		blocks.push([b - pad, b + h + pad]);
+	});
+	blocks.sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+	const out = [];
+	const at = (u) => axis === "x" ? {
+		x: c,
+		y: u
+	} : {
+		x: u,
+		y: c
+	};
+	let from = lo;
+	for (const [s, e] of blocks) {
+		if (s - from >= min) out.push({
+			a: at(from),
+			b: at(s)
+		});
+		from = Math.max(from, e);
+	}
+	if (hi - from >= min) out.push({
+		a: at(from),
+		b: at(hi)
+	});
+	return out;
+}
 /**
-* This function gives the density of the polylines on a grid of cells, after a Gaussian blur of the width `bandwidth`.
-* Each polyline adds 1 to each cell that it goes through, one time for each polyline.
+* This function gives the candidate streets of a board. Each street is an axis-parallel piece of free space.
+* The source `room` takes the middle line of each gap of `boardGaps` that is two margins wide or more.
+* The source `corners` takes the lines one margin out from each side of each box.
+* A street is two margins long or more. The list has no copies, and its order is the same each time.
 */
-function lineDensity(lines, box, cellSize, bandwidth) {
-	const cell = Math.max(cellSize, box.w / 1024, box.h / 1024, 1e-6);
-	const pad = 3 * bandwidth;
-	const x0 = box.x - pad;
-	const y0 = box.y - pad;
-	const w = Math.max(1, Math.ceil((box.w + 2 * pad) / cell));
-	const h = Math.max(1, Math.ceil((box.h + 2 * pad) / cell));
-	const raw = new Float64Array(w * h);
-	const stamp = new Int32Array(w * h).fill(-1);
-	lines.forEach((p, li) => {
-		for (let i = 1; i < p.length; i++) {
-			const a = p[i - 1];
-			const b = p[i];
-			const steps = Math.max(1, Math.ceil(2 * dist(a, b) / cell));
-			for (let k = 0; k <= steps; k++) {
-				const x = Math.floor((a.x + (b.x - a.x) * k / steps - x0) / cell);
-				const y = Math.floor((a.y + (b.y - a.y) * k / steps - y0) / cell);
-				if (x < 0 || y < 0 || x >= w || y >= h) continue;
-				const c = y * w + x;
-				if (stamp[c] === li) continue;
-				stamp[c] = li;
-				raw[c] = raw[c] + 1;
-			}
-		}
-	});
-	const sigma = Math.max(1e-6, bandwidth / cell);
-	const r = Math.ceil(3 * sigma);
-	const kernel = Array.from({ length: 2 * r + 1 }, (_, i) => Math.exp(-((i - r) ** 2) / (2 * sigma * sigma)));
-	const sum = kernel.reduce((s, v) => s + v, 0);
-	const tmp = new Float64Array(w * h);
-	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-		let v = 0;
-		for (let i = -r; i <= r; i++) {
-			const xi = x + i;
-			if (xi >= 0 && xi < w) v += raw[y * w + xi] * kernel[i + r];
-		}
-		tmp[y * w + x] = v / sum;
+function freeLines(graph, finder, source) {
+	const nodes = graph.nodes;
+	if (nodes.length === 0) return [];
+	const m = finder.margin;
+	const pad = m / 2;
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of nodes) {
+		x0 = Math.min(x0, n.box.x);
+		y0 = Math.min(y0, n.box.y);
+		x1 = Math.max(x1, n.box.x + n.box.w);
+		y1 = Math.max(y1, n.box.y + n.box.h);
 	}
-	const rho = new Float64Array(w * h);
-	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-		let v = 0;
-		for (let i = -r; i <= r; i++) {
-			const yi = y + i;
-			if (yi >= 0 && yi < h) v += tmp[yi * w + x] * kernel[i + r];
-		}
-		rho[y * w + x] = v / sum;
+	const lines = [];
+	if (source === "room") {
+		for (const g of boardGaps(nodes)) if (g.width >= 2 * m) lines.push({
+			axis: g.axis,
+			c: round(g.at - g.width / 2)
+		});
+	} else for (const n of nodes) {
+		lines.push({
+			axis: "x",
+			c: round(n.box.x - m)
+		}, {
+			axis: "x",
+			c: round(n.box.x + n.box.w + m)
+		});
+		lines.push({
+			axis: "y",
+			c: round(n.box.y - m)
+		}, {
+			axis: "y",
+			c: round(n.box.y + n.box.h + m)
+		});
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const sorted = [...lines].sort((p, q) => p.axis === q.axis ? p.c - q.c : p.axis < q.axis ? -1 : 1);
+	for (const l of sorted) {
+		const k = `${l.axis}${l.c}`;
+		if (seen.has(k)) continue;
+		seen.add(k);
+		const [lo, hi] = l.axis === "x" ? [y0 - 2 * m, y1 + 2 * m] : [x0 - 2 * m, x1 + 2 * m];
+		out.push(...freePieces(finder, l.axis, l.c, pad, 2 * m, lo, hi));
+	}
+	return out;
+}
+/** This function gives the edges of the input for the streets, with the points out of their plugs and the lengths of their first routes. */
+function streetEdges(input, finder) {
+	const first = firstRoutes(input);
+	const out = [];
+	for (const p of edgePlugs(input.graph)) {
+		const route = first.get(p.edge.id);
+		const s = finder.out(p.ps);
+		const t = finder.out(p.pt);
+		out.push({
+			edge: p.edge.id,
+			s,
+			t,
+			base: route ? polylineLength(route) : dist(s, t)
+		});
+	}
+	return out;
+}
+/** This function gives the point of the street nearest to `p`. */
+function streetPoint(line, p) {
+	if (line.a.x === line.b.x) {
+		const lo = Math.min(line.a.y, line.b.y);
+		const hi = Math.max(line.a.y, line.b.y);
+		return {
+			x: line.a.x,
+			y: Math.min(hi, Math.max(lo, p.y))
+		};
 	}
+	const lo = Math.min(line.a.x, line.b.x);
+	const hi = Math.max(line.a.x, line.b.x);
 	return {
-		w,
-		h,
-		cell,
-		x0,
-		y0,
-		rho
+		x: Math.min(hi, Math.max(lo, p.x)),
+		y: line.a.y
+	};
+}
+/** This function gives the ride of an edge on a street. The edge joins the street at the point nearest to `s`, and leaves it at the point nearest to `t`. */
+function streetRide(line, e) {
+	const on = streetPoint(line, e.s);
+	const off = streetPoint(line, e.t);
+	return {
+		on,
+		off,
+		ride: dist(on, off),
+		ramps: dist(e.s, on) + dist(off, e.t)
 	};
 }
+// src/highways/gaps/index.ts
+/** The default options of the strategy `gaps`. */
+const GAP_DEFAULTS = Object.freeze({
+	minSize: 3,
+	discount: .5,
+	detour: 1.3,
+	source: "room"
+});
+/** The best street of an edge, from the streets in `open`. The ride costs `discount` times its length. The way is at most `detour` times the first route. */
+function bestStreet(lines, open, e, o, min) {
+	let best = -1;
+	let bestSaving = 1e-9;
+	for (const i of open) {
+		const r = streetRide(lines[i], e);
+		if (r.ride < min) continue;
+		if (r.ramps + r.ride > o.detour * e.base) continue;
+		const saving = e.base - (r.ramps + o.discount * r.ride);
+		if (saving > bestSaving || saving === bestSaving && i < best) [best, bestSaving] = [i, saving];
+	}
+	return best;
+}
 /**
-* This function gives the ridges of a density image (Lindeberg 1998). A ridge cell has a negative eigenvalue of the Hessian with the larger size.
-* Its density is a maximum along the eigenvector of that eigenvalue. Its strength is the density times the size of that eigenvalue.
-* The cells with `strength` times the largest strength or more join their neighbours with a direction within 30 degrees.
-* Each group of cells gives the segment of its main axis. A segment of `minLength` or more is a ridge. The ridges come in the order of their total strength.
+* This function gives the highways on the gaps of the board (HWY-057). The streets are the free middle lines of the gaps.
+* Each edge takes the street that saves it the most cost, when a length on a street costs `discount` times its length.
+* A street with `minSize` edges or more becomes a highway. The edges of the other streets then choose again among the highways, two times.
 */
-function densityRidges(img, strength, minLength) {
-	const { w, h, rho } = img;
-	const at = (x, y) => rho[Math.min(h - 1, Math.max(0, y)) * w + Math.min(w - 1, Math.max(0, x))];
-	const power = new Float64Array(w * h);
-	const across = new Float64Array(w * h * 2);
-	let top = 0;
-	for (let y = 1; y < h - 1; y++) for (let x = 1; x < w - 1; x++) {
-		const v = at(x, y);
+function gapPlan(input, o) {
+	const finder = new WayFinder(input.graph.nodes);
+	const lines = freeLines(input.graph, finder, o.source);
+	const edges = streetEdges(input, finder);
+	const min = 2 * finder.margin;
+	const size = Math.max(2, Math.round(o.minSize));
+	let open = new Set(lines.map((_, i) => i));
+	let choice = /* @__PURE__ */ new Map();
+	for (let round = 0; round < 3; round++) {
+		choice = /* @__PURE__ */ new Map();
+		const count = /* @__PURE__ */ new Map();
+		for (const e of edges) {
+			const i = bestStreet(lines, open, e, o, min);
+			if (i < 0) continue;
+			choice.set(e.edge, i);
+			count.set(i, (count.get(i) ?? 0) + 1);
+		}
+		const kept = new Set([...open].filter((i) => (count.get(i) ?? 0) >= size));
+		if (kept.size === open.size) break;
+		open = kept;
+	}
+	const byLine = /* @__PURE__ */ new Map();
+	for (const e of edges) {
+		const i = choice.get(e.edge);
+		if (i === void 0 || !open.has(i)) continue;
+		const r = streetRide(lines[i], e);
+		const list = byLine.get(i) ?? [];
+		list.push({
+			edge: e.edge,
+			from: r.on,
+			to: r.off,
+			at: 0
+		});
+		byLine.set(i, list);
+	}
+	return snapPlan(input, [...byLine.keys()].sort((p, q) => p - q).map((i) => {
+		const members = byLine.get(i);
+		const line = lines[i];
+		const vertical = line.a.x === line.b.x;
+		const us = members.flatMap((m) => vertical ? [m.from.y, m.to.y] : [m.from.x, m.to.x]);
+		const lo = Math.min(...us);
+		const hi = Math.max(...us);
+		const a = vertical ? {
+			x: line.a.x,
+			y: lo
+		} : {
+			x: lo,
+			y: line.a.y
+		};
+		const b = vertical ? {
+			x: line.a.x,
+			y: hi
+		} : {
+			x: hi,
+			y: line.a.y
+		};
+		return {
+			key: `gap${i}`,
+			a,
+			b,
+			members
+		};
+	}), {
+		minSize: size,
+		direct: true
+	});
+}
+// src/highways/interchanges/index.ts
+/** The values of `InterchangeBase`. */
+const INTERCHANGE_BASES = Object.freeze(["corridors", "shared-ways"]);
+/** The default options of the strategy `interchanges`. */
+const INTERCHANGE_DEFAULTS = Object.freeze({
+	from: "corridors",
+	changeCost: 2,
+	interchanges: 16,
+	perEdge: 2,
+	radius: 2,
+	discount: .5,
+	detour: 1.5
+});
+/** The largest number of candidate interchanges of the first pass. */
+const MAX_CANDIDATES = 64;
+/** The nearest points of the segments `a b` and `c d`, as the parameters `s` and `t` from 0 to 1, with their distance. */
+function nearestOfSegments(a, b, c, d) {
+	const ux = b.x - a.x;
+	const uy = b.y - a.y;
+	const vx = d.x - c.x;
+	const vy = d.y - c.y;
+	const at = (s, t) => {
+		const dx = a.x + s * ux - (c.x + t * vx);
+		const dy = a.y + s * uy - (c.y + t * vy);
+		return Math.sqrt(dx * dx + dy * dy);
+	};
+	const clamp = (v) => Math.min(1, Math.max(0, v));
+	const uu = ux * ux + uy * uy;
+	const vv = vx * vx + vy * vy;
+	const project = (p, q, x, y, len) => len > 0 ? clamp(((p.x - q.x) * x + (p.y - q.y) * y) / len) : 0;
+	const tries = [
+		[0, project(a, c, vx, vy, vv)],
+		[1, project(b, c, vx, vy, vv)],
+		[project(c, a, ux, uy, uu), 0],
+		[project(d, a, ux, uy, uu), 1]
+	];
+	const den = ux * vy - uy * vx;
+	if (Math.abs(den) > 1e-12) {
+		const s = ((c.x - a.x) * vy - (c.y - a.y) * vx) / den;
+		const t = ((c.x - a.x) * uy - (c.y - a.y) * ux) / den;
+		if (s >= 0 && s <= 1 && t >= 0 && t <= 1) tries.push([s, t]);
+	}
+	let best = {
+		s: 0,
+		t: 0,
+		d: Infinity
+	};
+	for (const [s, t] of tries) {
+		const v = at(s, t);
+		if (v < best.d - 1e-12) best = {
+			s,
+			t,
+			d: v
+		};
+	}
+	return best;
+}
+/** This function gives the candidate interchanges: the nearest places of each pair of spines that come within `radius`, with a link in clear view. */
+function interchangeCandidates(spines, radius, clear) {
+	const out = [];
+	for (let h = 0; h < spines.length; h++) for (let g = h + 1; g < spines.length; g++) {
+		const p = spines[h];
+		const q = spines[g];
+		let best;
+		for (let i = 0; i + 1 < p.length; i++) for (let j = 0; j + 1 < q.length; j++) {
+			const n = nearestOfSegments(p[i], p[i + 1], q[j], q[j + 1]);
+			if (n.d <= radius && (!best || n.d < best.gap - 1e-12)) best = {
+				h,
+				hAt: i + n.s,
+				g,
+				gAt: j + n.t,
+				gap: n.d
+			};
+		}
+		if (best && (best.gap <= 1e-9 || clear(pointAt(p, best.hAt), pointAt(q, best.gAt)))) out.push(best);
+	}
+	return out.sort((x, y) => x.gap - y.gap || x.h - y.h || x.g - y.g).slice(0, MAX_CANDIDATES);
+}
+/**
+* This function gives the highways of a network with interchanges (HWY-060). The highways come from a plan. Two highways that come near get an interchange.
+* Each edge takes its cheapest way: a ride on one highway, or on up to `perEdge` highways with a change at an interchange.
+* A change costs `changeCost` units. The interchanges that the most edges use stay, up to `interchanges`.
+*/
+function interchangePlan(input, o) {
+	const graph = input.graph;
+	const base = basePlan(input, o.from);
+	const spines = base.highways.map((h) => h.spine);
+	if (spines.length === 0) return { highways: [] };
+	const finder = new WayFinder(graph.nodes);
+	const pad = finder.margin / 2;
+	const unit = boardUnit(graph);
+	const first = firstRoutes(input);
+	const change = Math.max(0, o.changeCost) * unit;
+	const perEdge = Math.min(3, Math.max(1, Math.round(o.perEdge)));
+	const disc = Math.min(1, Math.max(.05, o.discount));
+	const ride = (h, a, b) => lengthBetween(spines[h], Math.min(a, b), Math.max(a, b));
+	const edges = edgePlugs(graph).map((p) => {
+		const s = finder.out(p.ps);
+		const t = finder.out(p.pt);
+		const route = first.get(p.edge.id);
+		const ends = spines.map((spine) => {
+			const on = nearestPlace(spine, s);
+			const off = nearestPlace(spine, t);
+			return {
+				on,
+				off,
+				rampIn: dist(s, pointAt(spine, on)),
+				rampOut: dist(pointAt(spine, off), t)
+			};
+		});
+		return {
+			edge: p.edge.id,
+			s,
+			t,
+			base: route ? polylineLength(route) : dist(s, t),
+			ends
+		};
+	});
+	const tripOf = (e, list) => {
+		const found = {
+			cost: Infinity,
+			trip: void 0
+		};
+		const offer = (cost, length, trip) => {
+			if (trip.legs.some((l) => ride(l.h, l.on, l.off) < finder.margin)) return;
+			if (cost >= e.base || length > o.detour * e.base) return;
+			if (cost < found.cost - 1e-9) [found.cost, found.trip] = [cost, trip];
+		};
+		spines.forEach((_, h) => {
+			const x = e.ends[h];
+			const r = ride(h, x.on, x.off);
+			offer(x.rampIn + disc * r + x.rampOut, x.rampIn + r + x.rampOut, {
+				legs: [{
+					h,
+					on: x.on,
+					off: x.off
+				}],
+				used: []
+			});
+		});
+		if (perEdge < 2) return found.trip;
+		const sides = list.flatMap((c, i) => [{
+			i,
+			p: c.h,
+			pAt: c.hAt,
+			q: c.g,
+			qAt: c.gAt,
+			gap: c.gap
+		}, {
+			i,
+			p: c.g,
+			pAt: c.gAt,
+			q: c.h,
+			qAt: c.hAt,
+			gap: c.gap
+		}]);
+		for (const a of sides) {
+			const x = e.ends[a.p];
+			const y = e.ends[a.q];
+			const r1 = ride(a.p, x.on, a.pAt);
+			const r2 = ride(a.q, a.qAt, y.off);
+			offer(x.rampIn + disc * (r1 + r2) + a.gap + change + y.rampOut, x.rampIn + r1 + r2 + a.gap + y.rampOut, {
+				legs: [{
+					h: a.p,
+					on: x.on,
+					off: a.pAt
+				}, {
+					h: a.q,
+					on: a.qAt,
+					off: y.off
+				}],
+				used: [a.i]
+			});
+			if (perEdge < 3) continue;
+			for (const b of sides) {
+				if (b.p !== a.q || b.q === a.p || b.i === a.i) continue;
+				const z = e.ends[b.q];
+				const r3 = ride(a.q, a.qAt, b.pAt);
+				const r4 = ride(b.q, b.qAt, z.off);
+				offer(x.rampIn + disc * (r1 + r3 + r4) + a.gap + b.gap + 2 * change + z.rampOut, x.rampIn + r1 + r3 + r4 + a.gap + b.gap + z.rampOut, {
+					legs: [
+						{
+							h: a.p,
+							on: x.on,
+							off: a.pAt
+						},
+						{
+							h: a.q,
+							on: a.qAt,
+							off: b.pAt
+						},
+						{
+							h: b.q,
+							on: b.qAt,
+							off: z.off
+						}
+					],
+					used: [a.i, b.i]
+				});
+			}
+		}
+		return found.trip;
+	};
+	const clear = (a, b) => finder.obstacles.clear(a, b, pad);
+	const candidates = interchangeCandidates(spines, Math.max(0, o.radius) * unit, clear);
+	const use = new Array(candidates.length).fill(0);
+	for (const e of edges) for (const i of tripOf(e, candidates)?.used ?? []) use[i] = use[i] + 1;
+	const kept = candidates.map((c, i) => ({
+		c,
+		i,
+		n: use[i]
+	})).filter((x) => x.n > 0).sort((x, y) => y.n - x.n || x.i - y.i).slice(0, Math.max(1, Math.round(o.interchanges))).sort((x, y) => x.i - y.i).map((x) => x.c);
+	const riders = spines.map(() => []);
+	for (const e of edges) {
+		const trip = tripOf(e, kept);
+		if (!trip) continue;
+		trip.legs.forEach((l, seq) => riders[l.h].push({
+			edge: e.edge,
+			on: l.on,
+			off: l.off,
+			seq,
+			points: [
+				e.s,
+				...spinePart(spines[l.h], l.on, l.off),
+				e.t
+			]
+		}));
+	}
+	const highways = [];
+	spines.forEach((spine, h) => {
+		const list = riders[h];
+		if (list.length < 2) return;
+		const lanes = orderLanes(spine, list.map((r) => ({
+			edge: r.edge,
+			points: r.points
+		})), "bundle");
+		const byEdge = new Map(list.map((r) => [r.edge, r]));
+		const members = lanes.map((edge) => {
+			const r = byEdge.get(edge);
+			return memberAt(spine, edge, r.on, r.off, r.seq);
+		});
+		highways.push({
+			id: `h${h}`,
+			key: base.highways[h].key,
+			spine,
+			lanes,
+			members
+		});
+	});
+	return tidyPlan({ highways });
+}
+// src/bench/measures/bundles.ts
+/**
+* This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
+* `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
+*/
+function inkSaved(routes) {
+	let total = 0;
+	for (const r of routes) total += polylineLength(r.points);
+	if (total <= 0) return 0;
+	let ink = 0;
+	for (const [a, b] of drawnSegments(routes)) ink += dist(a, b);
+	return Math.max(0, 1 - ink / total);
+}
+/**
+* This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
+* `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
+* `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
+*/
+function ambiguity(graph, routes, options = {}) {
+	const n = graph.nodes.length;
+	const index = new Map(graph.nodes.map((v, i) => [v.id, i]));
+	const ends = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const s = index.get(e.source.node);
+		const t = index.get(e.target.node);
+		if (s !== void 0 && t !== void 0) ends.set(e.id, [s, t]);
+	}
+	const keyIds = /* @__PURE__ */ new Map();
+	const nodesOf = [];
+	const keysOf = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const end = ends.get(r.edge);
+		if (!end) continue;
+		const own = [];
+		for (let i = 1; i < r.points.length; i++) {
+			const k = segmentKey(r.points[i - 1], r.points[i]);
+			if (k === void 0) continue;
+			let id = keyIds.get(k);
+			if (id === void 0) {
+				id = nodesOf.length;
+				keyIds.set(k, id);
+				nodesOf.push([]);
+			}
+			if (own.includes(id)) continue;
+			own.push(id);
+			nodesOf[id].push(end[0], end[1]);
+		}
+		keysOf.set(r.edge, own);
+	}
+	const mark = new Int32Array(n).fill(-1);
+	nodesOf.forEach((list, k) => {
+		let j = 0;
+		for (const v of list) if (mark[v] !== k) {
+			mark[v] = k;
+			list[j++] = v;
+		}
+		list.length = j;
+	});
+	const incident = Array.from({ length: n }, () => []);
+	const adjacent = Array.from({ length: n }, () => []);
+	for (const e of graph.edges) {
+		const end = ends.get(e.id);
+		if (!end) continue;
+		incident[end[0]].push(e.id);
+		incident[end[1]].push(e.id);
+		adjacent[end[0]].push(end[1]);
+		adjacent[end[1]].push(end[0]);
+	}
+	const exact = n <= (options.exact ?? 1e3);
+	const R = rng(options.seed ?? 1);
+	const pick = exact ? Array.from({ length: n }, (_, i) => i) : Array.from({ length: options.sample ?? 2e3 }, () => Math.floor(R() * n));
+	const keyStamp = new Int32Array(nodesOf.length).fill(-1);
+	const nearStamp = new Int32Array(n).fill(-1);
+	const linkStamp = new Int32Array(n).fill(-1);
+	let all = 0;
+	let wrong = 0;
+	pick.forEach((v, step) => {
+		for (const w of adjacent[v]) linkStamp[w] = step;
+		nearStamp[v] = step;
+		for (const e of incident[v]) for (const k of keysOf.get(e) ?? []) {
+			if (keyStamp[k] === step) continue;
+			keyStamp[k] = step;
+			for (const w of nodesOf[k]) {
+				if (nearStamp[w] === step) continue;
+				nearStamp[w] = step;
+				all++;
+				if (linkStamp[w] !== step) wrong++;
+			}
+		}
+	});
+	return {
+		value: all ? wrong / all : 0,
+		estimated: !exact
+	};
+}
+/** The drawn segments of each route, as keys, in the order of its points. A segment shorter than the grain of `segmentKey` has no key. */
+function routeKeys(routes) {
+	const keys = /* @__PURE__ */ new Map();
+	const users = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const own = [];
+		for (let i = 1; i < r.points.length; i++) {
+			const k = segmentKey(r.points[i - 1], r.points[i]);
+			if (k === void 0) continue;
+			own.push(k);
+			let set = users.get(k);
+			if (!set) users.set(k, set = /* @__PURE__ */ new Set());
+			set.add(r.edge);
+		}
+		keys.set(r.edge, own);
+	}
+	return {
+		keys,
+		users
+	};
+}
+/**
+* This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
+* An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
+* The scale is 0 to 1. A higher value is better only in context. The cost is linear.
+*/
+function bundledShare(result) {
+	const routes = result.routes;
+	if (routes.length === 0) return 0;
+	const shared = /* @__PURE__ */ new Set();
+	for (const run of result.runs ?? []) for (const e of run.edges) shared.add(e);
+	for (const b of result.bundles ?? []) if (b.edges.length > 1) for (const e of b.edges) shared.add(e);
+	const { keys, users } = routeKeys(routes);
+	for (const [edge, own] of keys) if (own.some((k) => (users.get(k)?.size ?? 0) > 1)) shared.add(edge);
+	let count = 0;
+	for (const r of routes) if (shared.has(r.edge)) count++;
+	return count / routes.length;
+}
+/**
+* This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
+* The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
+* The cost is an extra run of the base router, and then linear.
+*/
+function bundleStretch(routes, base) {
+	const baseLength = /* @__PURE__ */ new Map();
+	for (const r of base) baseLength.set(r.edge, polylineLength(r.points));
+	const st = [];
+	for (const r of routes) {
+		const b = baseLength.get(r.edge);
+		if (b === void 0 || b <= 1 || r.points.length < 2) continue;
+		st.push(polylineLength(r.points) / b);
+	}
+	if (st.length === 0) return {
+		median: 1,
+		q95: 1,
+		edges: 0
+	};
+	return {
+		median: quantile(st, .5),
+		q95: quantile(st, .95),
+		edges: st.length
+	};
+}
+/**
+* This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
+* A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
+* One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
+* Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
+*/
+function mergeAngle(routes) {
+	const { users } = routeKeys(routes);
+	const sig = /* @__PURE__ */ new Map();
+	for (const [k, set] of users) sig.set(k, [...set].sort().join("\0"));
+	let max = 0;
+	for (const r of routes) {
+		let prev;
+		for (let i = 1; i < r.points.length; i++) {
+			const a = r.points[i - 1];
+			const b = r.points[i];
+			const k = segmentKey(a, b);
+			if (k === void 0) continue;
+			if (prev && sig.get(prev.k) !== sig.get(k) && ((users.get(prev.k)?.size ?? 0) > 1 || (users.get(k)?.size ?? 0) > 1)) {
+				const ux = prev.b.x - prev.a.x;
+				const uy = prev.b.y - prev.a.y;
+				const vx = b.x - a.x;
+				const vy = b.y - a.y;
+				const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+				max = Math.max(max, turn * 180 / Math.PI);
+			}
+			prev = {
+				k,
+				a,
+				b
+			};
+		}
+	}
+	return max;
+}
+// src/highways/search/index.ts
+/** The default options of the strategy `search`. */
+const SEARCH_DEFAULTS = Object.freeze({
+	from: "corridors",
+	pool: Object.freeze(["quickbundles", "road-classes"]),
+	evaluations: 16,
+	temperature: .02,
+	inkWeight: 1,
+	stretchWeight: .5,
+	ambiguityWeight: .5,
+	angleWeight: .25,
+	seed: 1
+});
+/** The values of `SearchMove`, in the order of the draw. */
+const SEARCH_MOVES = Object.freeze([
+	"add",
+	"drop",
+	"edge",
+	"point"
+]);
+/** The number of moves of one sweep of the annealing. */
+const SWEEP = 4;
+/** This function gives a seeded random source with values from 0 to 1 (mulberry32). */
+function random(seed) {
+	let a = Math.floor(seed) >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* This function gives the score of the routes of a plan: `w1 B1 - w3 B3 - w4 B4 - w6 B6 / 180`. Higher is better.
+* B3 is the 0.95 quantile of the stretch against the first routes. The score reads only the graph and the routes of the plan.
+*/
+function searchScore(graph, routes, first, o) {
+	const ink = inkSaved(routes);
+	const stretch = bundleStretch(routes, first).q95;
+	const amb = o.ambiguityWeight > 0 ? ambiguity(graph, routes).value : 0;
+	const angle = o.angleWeight > 0 ? mergeAngle(routes) / 180 : 0;
+	return o.inkWeight * ink - o.stretchWeight * stretch - o.ambiguityWeight * amb - o.angleWeight * angle;
+}
+/**
+* The function `acceptance` gives the chance to keep a worse plan, for a loss `y` of 0 or more on the scale of the temperature.
+* It is `1 / (1 + y + y² / 2)`, near `exp(-y)` for a small loss.
+* It uses only exact arithmetic, so each platform keeps the same plans.
+*/
+function acceptance(y) {
+	return 1 / (1 + y + y * y / 2);
+}
+/**
+* This function gives the highways of a local search over the set of highways (HWY-059). The search starts at the plan of `from`.
+* Each move adds a highway of the pool, drops a highway, moves one edge to another highway, or moves one point of a spine.
+* The annealing keeps a worse plan with the chance `acceptance(-delta / T)`. The best plan that the search measures is the result.
+*
+* The score reads only this graph and its routes. Thus the search does not fit to the inputs of a screen.
+*/
+function searchPlan(input, o) {
+	const graph = input.graph;
+	const start = tidyPlan(candidatePlan(input, o.from));
+	const budget = Math.max(0, Math.floor(o.evaluations));
+	if (budget === 0 || graph.edges.length === 0) return start;
+	const pool = [];
+	for (const source of o.pool) if (source !== o.from) pool.push(...candidatePlan(input, source).highways);
+	const finder = new WayFinder(graph.nodes);
+	const pad = finder.margin / 2;
+	const plugs = new Map(edgePlugs(graph).map((p) => [p.edge.id, p]));
+	const routes = firstRoutes(input);
+	const first = follow(graph, { highways: [] }).routes;
+	const scoreOf = (plan) => searchScore(graph, follow(graph, plan).routes, first, o);
+	const next = random(o.seed);
+	const pick = (list) => list[Math.floor(next() * list.length) % list.length];
+	const tidy = (highways) => tidyPlan(orderAlongRoutes({ highways }, routes));
+	/** This function gives the plan after one move, or `undefined` when the move does not apply. */
+	const moved = (plan, move) => {
+		const list = [...plan.highways];
+		if (move === "add") {
+			const known = new Set(list.map((h) => h.spine.map((p) => `${p.x},${p.y}`).join(";")));
+			const fresh = pool.filter((h) => !known.has(h.spine.map((p) => `${p.x},${p.y}`).join(";")));
+			if (fresh.length === 0) return void 0;
+			return tidy([...list, pick(fresh)]);
+		}
+		if (list.length === 0) return void 0;
+		const i = Math.floor(next() * list.length) % list.length;
+		const h = list[i];
+		if (move === "drop") return tidy(list.filter((_, j) => j !== i));
+		if (move === "edge") {
+			if (list.length < 2 || h.members.length < 3) return void 0;
+			const m = pick(h.members);
+			const plug = plugs.get(m.edge);
+			if (!plug) return void 0;
+			const others = list.map((g, j) => ({
+				g,
+				j
+			})).filter((x) => x.j !== i && !x.g.members.some((y) => y.edge === m.edge));
+			if (others.length === 0) return void 0;
+			const s = plug.ps.point;
+			const t = plug.pt.point;
+			const to = pick(others);
+			const on = nearestPlace(to.g.spine, s);
+			const off = nearestPlace(to.g.spine, t);
+			if (Math.abs(on - off) < 1e-6) return void 0;
+			list[i] = {
+				...h,
+				members: h.members.filter((y) => y.edge !== m.edge),
+				lanes: h.lanes.filter((e) => e !== m.edge)
+			};
+			list[to.j] = {
+				...to.g,
+				members: [...to.g.members, memberAt(to.g.spine, m.edge, on, off, m.seq)],
+				lanes: [...to.g.lanes, m.edge]
+			};
+			return tidy(list);
+		}
+		const k = Math.floor(next() * h.spine.length) % h.spine.length;
+		const step = 2 * finder.margin * (next() < .5 ? -1 : 1);
+		const p = h.spine[k];
+		const q = next() < .5 ? {
+			x: p.x + step,
+			y: p.y
+		} : {
+			x: p.x,
+			y: p.y + step
+		};
+		const spine = h.spine.map((x, j) => j === k ? q : x);
+		if (!finder.obstacles.clearPath(spine, pad)) return void 0;
+		list[i] = {
+			...h,
+			spine,
+			members: h.members.map((m) => memberAt(spine, m.edge, m.on, m.off, m.seq))
+		};
+		return tidy(list);
+	};
+	let current = start;
+	let currentScore = scoreOf(start);
+	let best = start;
+	let bestScore = currentScore;
+	let temperature = Math.max(0, o.temperature);
+	for (let n = 1, tries = 0; n < budget && tries < 4 * budget; tries++) {
+		const plan = moved(current, pick(SEARCH_MOVES));
+		if (!plan) continue;
+		n++;
+		const score = scoreOf(plan);
+		const delta = score - currentScore;
+		if (delta >= 0 || temperature > 0 && next() < acceptance(-delta / temperature)) [current, currentScore] = [plan, score];
+		if (score > bestScore + 1e-12) [best, bestScore] = [plan, score];
+		if (n % SWEEP === 0) temperature *= .95;
+	}
+	return best;
+}
+// src/highways/steiner/index.ts
+/** The values of `SteinerGroup`. */
+const STEINER_GROUPS = Object.freeze(["source", "key"]);
+/** The values of `SteinerMethod`. */
+const STEINER_METHODS = Object.freeze(["one-steiner", "spanning"]);
+/** The values of `SteinerMetric`. */
+const STEINER_METRICS = Object.freeze(["rectilinear", "octilinear"]);
+/** The default options of the strategy `steiner`. */
+const STEINER_DEFAULTS = Object.freeze({
+	group: "source",
+	method: "one-steiner",
+	maxGroup: 12,
+	metric: "rectilinear",
+	detour: 1.5,
+	minSize: 2
+});
+/** This function gives the distance of two points in the metric. */
+function metricDistance(a, b, metric) {
+	const dx = Math.abs(a.x - b.x);
+	const dy = Math.abs(a.y - b.y);
+	return metric === "rectilinear" ? dx + dy : Math.max(dx, dy) + (Math.SQRT2 - 1) * Math.min(dx, dy);
+}
+/** This function gives the links of the spanning tree of the points (Prim), as pairs of indices, and the sum of their lengths. */
+function spanningTree(points, metric) {
+	const n = points.length;
+	if (n < 2) return {
+		links: [],
+		cost: 0
+	};
+	const inTree = new Uint8Array(n);
+	const best = new Float64Array(n).fill(Infinity);
+	const from = new Int32Array(n).fill(-1);
+	best[0] = 0;
+	const links = [];
+	let cost = 0;
+	for (let k = 0; k < n; k++) {
+		let u = -1;
+		for (let i = 0; i < n; i++) if (!inTree[i] && (u < 0 || best[i] < best[u])) u = i;
+		inTree[u] = 1;
+		if (from[u] >= 0) {
+			links.push([from[u], u]);
+			cost += best[u];
+		}
+		for (let i = 0; i < n; i++) {
+			if (inTree[i]) continue;
+			const d = metricDistance(points[u], points[i], metric);
+			if (d < best[i]) {
+				best[i] = d;
+				from[i] = u;
+			}
+		}
+	}
+	return {
+		links,
+		cost
+	};
+}
+/**
+* This function gives a Steiner tree of the terminals by the iterated 1-Steiner method (Kahng and Robins). The candidates are the points of the Hanan grid.
+* Each round adds the candidate that makes the spanning tree shortest, and drops each added point with two links or fewer.
+* The test `free` removes the candidates in the boxes. The result has the terminals first, then the added points.
+*/
+function oneSteiner(terminals, metric, free) {
+	const points = [...terminals];
+	const xs = [...new Set(terminals.map((p) => p.x))].sort((a, b) => a - b);
+	const ys = [...new Set(terminals.map((p) => p.y))].sort((a, b) => a - b);
+	const taken = new Set(terminals.map((p) => `${p.x},${p.y}`));
+	const candidates = [];
+	for (const x of xs) for (const y of ys) if (!taken.has(`${x},${y}`) && free({
+		x,
+		y
+	})) candidates.push({
+		x,
+		y
+	});
+	let tree = spanningTree(points, metric);
+	for (let round = 0; round < terminals.length; round++) {
+		let best = -1;
+		let bestCost = tree.cost - 1e-9 * Math.max(1, tree.cost);
+		candidates.forEach((c, i) => {
+			const cost = spanningTree([...points, c], metric).cost;
+			if (cost < bestCost) [best, bestCost] = [i, cost];
+		});
+		if (best < 0) break;
+		points.push(candidates[best]);
+		candidates.splice(best, 1);
+		tree = spanningTree(points, metric);
+		for (;;) {
+			const degree = new Array(points.length).fill(0);
+			for (const [a, b] of tree.links) {
+				degree[a] = degree[a] + 1;
+				degree[b] = degree[b] + 1;
+			}
+			let drop = -1;
+			for (let i = terminals.length; i < points.length; i++) if (degree[i] <= 2) drop = i;
+			if (drop < 0) break;
+			points.splice(drop, 1);
+			tree = spanningTree(points, metric);
+		}
+	}
+	return {
+		points,
+		links: tree.links
+	};
+}
+/**
+* This function gives the polyline of one link of the tree. A rectilinear link is an L in clear view, else a path through the corner graph.
+* An octilinear link is a straight piece and a diagonal piece. The same link gives the same points each time.
+*/
+function linkPath(a, b, metric, finder) {
+	const pad = finder.margin / 2;
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const tries = [];
+	if (Math.abs(dx) < 1e-9 || Math.abs(dy) < 1e-9) tries.push([a, b]);
+	else if (metric === "rectilinear") tries.push([
+		a,
+		{
+			x: b.x,
+			y: a.y
+		},
+		b
+	], [
+		a,
+		{
+			x: a.x,
+			y: b.y
+		},
+		b
+	]);
+	else {
+		const d = Math.min(Math.abs(dx), Math.abs(dy));
+		const diag = {
+			x: a.x + Math.sign(dx) * d,
+			y: a.y + Math.sign(dy) * d
+		};
+		const late = {
+			x: b.x - Math.sign(dx) * d,
+			y: b.y - Math.sign(dy) * d
+		};
+		tries.push([
+			a,
+			diag,
+			b
+		], [
+			a,
+			late,
+			b
+		]);
+	}
+	for (const t of tries) if (finder.obstacles.clearPath(t, pad)) return t.filter((p, i) => i === 0 || p.x !== t[i - 1].x || p.y !== t[i - 1].y);
+	const way = finder.corners.path(a, b);
+	return way ? finder.corners.pull(way) : [a, b];
+}
+/**
+* This function gives the highways of obstacle-avoiding Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree over the points out of its plugs.
+* The links of the tree are rectilinear or octilinear, and they go around the boxes. Each edge takes its path in the tree, when that path is short enough.
+* The stretches of the tree that two edges or more share become highways.
+*/
+function steinerPlan(input, o) {
+	const finder = new WayFinder(input.graph.nodes);
+	const pad = finder.margin / 2;
+	const first = firstRoutes(input);
+	const groups = /* @__PURE__ */ new Map();
+	for (const p of edgePlugs(input.graph)) {
+		const key = o.group === "key" ? byCollection(p.edge) ?? `\u0000${p.edge.source.node}` : p.edge.source.node;
+		const s = finder.out(p.ps);
+		const t = finder.out(p.pt);
+		const route = first.get(p.edge.id);
+		const list = groups.get(key) ?? [];
+		list.push({
+			edge: p.edge.id,
+			s,
+			t,
+			base: route ? polylineLength(route) : metricDistance(s, t, "rectilinear")
+		});
+		groups.set(key, list);
+	}
+	const ways = [];
+	for (const key of [...groups.keys()].sort()) {
+		const list = groups.get(key);
+		if (list.length < 2) continue;
+		const index = /* @__PURE__ */ new Map();
+		const terminals = [];
+		const at = (p) => {
+			const k = `${p.x},${p.y}`;
+			let i = index.get(k);
+			if (i === void 0) {
+				index.set(k, i = terminals.length);
+				terminals.push(p);
+			}
+			return i;
+		};
+		const ends = list.map((e) => [at(e.s), at(e.t)]);
+		const tree = o.method === "one-steiner" && terminals.length <= o.maxGroup ? oneSteiner(terminals, o.metric, (p) => !finder.obstacles.inside(p, pad)) : {
+			points: terminals,
+			...spanningTree(terminals, o.metric)
+		};
+		const n = tree.points.length;
+		const next = Array.from({ length: n }, () => []);
+		for (const [a, b] of tree.links) {
+			const path = linkPath(tree.points[a], tree.points[b], o.metric, finder);
+			next[a].push({
+				to: b,
+				path
+			});
+			next[b].push({
+				to: a,
+				path: [...path].reverse()
+			});
+		}
+		list.forEach((e, k) => {
+			const [s, t] = ends[k];
+			const back = new Int32Array(n).fill(-2);
+			const via = new Array(n);
+			back[s] = -1;
+			const queue = [s];
+			while (queue.length > 0) {
+				const u = queue.shift();
+				if (u === t) break;
+				for (const x of next[u]) {
+					if (back[x.to] !== -2) continue;
+					back[x.to] = u;
+					via[x.to] = x.path;
+					queue.push(x.to);
+				}
+			}
+			if (back[t] === -2 || s === t) return;
+			const pieces = [];
+			for (let v = t; v !== s; v = back[v]) pieces.push(via[v]);
+			const points = [];
+			for (const piece of pieces.reverse()) for (const p of piece) if (points.length === 0 || p.x !== points[points.length - 1].x || p.y !== points[points.length - 1].y) points.push(p);
+			if (polylineLength(points) > o.detour * e.base) return;
+			ways.push({
+				edge: e.edge,
+				key,
+				points
+			});
+		});
+	}
+	return sharedStretches(ways, { minSize: o.minSize });
+}
+// src/highways/streets/index.ts
+/** The default options of the strategy `streets`. */
+const STREET_DEFAULTS = Object.freeze({
+	detour: 1.2,
+	minGain: 2,
+	maxStreets: 32,
+	minSize: 2,
+	source: "corners"
+});
+/**
+* This function gives orthogonal streets by a greedy set cover (HWY-058). A street covers each edge whose way along it is at most `detour` times its first route.
+* Each step takes the street with the largest gain: the length that its new edges ride, over the length of the street that they use.
+* The cover stops at `maxStreets` streets, or when the best gain is below `minGain`. Each edge rides one street at most.
+*/
+function streetPlan(input, o) {
+	const finder = new WayFinder(input.graph.nodes);
+	const lines = freeLines(input.graph, finder, o.source);
+	const edges = streetEdges(input, finder);
+	const min = 2 * finder.margin;
+	const size = Math.max(2, Math.round(o.minSize));
+	const covers = lines.map((line) => {
+		const out = [];
+		for (const e of edges) {
+			const r = streetRide(line, e);
+			if (r.ride >= min && r.ramps + r.ride <= o.detour * e.base) out.push({
+				edge: e.edge,
+				ride: r
+			});
+		}
+		return out;
+	});
+	const done = /* @__PURE__ */ new Set();
+	const chosen = [];
+	const used = /* @__PURE__ */ new Set();
+	while (chosen.length < Math.max(0, Math.floor(o.maxStreets))) {
+		let best = -1;
+		let bestGain = -Infinity;
+		let bestPart = [];
+		covers.forEach((cover, i) => {
+			if (used.has(i)) return;
+			const part = cover.filter((c) => !done.has(c.edge));
+			if (part.length < size) return;
+			const vertical = lines[i].a.x === lines[i].b.x;
+			const us = part.flatMap((c) => vertical ? [c.ride.on.y, c.ride.off.y] : [c.ride.on.x, c.ride.off.x]);
+			const span = Math.max(...us) - Math.min(...us);
+			if (span <= 0) return;
+			let ride = 0;
+			for (const c of part) ride += c.ride.ride;
+			const gain = ride / span;
+			if (gain > bestGain) [best, bestGain, bestPart] = [
+				i,
+				gain,
+				part
+			];
+		});
+		if (best < 0 || bestGain < o.minGain) break;
+		used.add(best);
+		for (const c of bestPart) done.add(c.edge);
+		const line = lines[best];
+		const vertical = line.a.x === line.b.x;
+		const us = bestPart.flatMap((c) => vertical ? [c.ride.on.y, c.ride.off.y] : [c.ride.on.x, c.ride.off.x]);
+		const lo = Math.min(...us);
+		const hi = Math.max(...us);
+		const a = vertical ? {
+			x: line.a.x,
+			y: lo
+		} : {
+			x: lo,
+			y: line.a.y
+		};
+		const b = vertical ? {
+			x: line.a.x,
+			y: hi
+		} : {
+			x: hi,
+			y: line.a.y
+		};
+		if (dist(a, b) <= 0) continue;
+		chosen.push({
+			key: `street${chosen.length}`,
+			a,
+			b,
+			members: bestPart.map((c) => ({
+				edge: c.edge,
+				from: c.ride.on,
+				to: c.ride.off,
+				at: 0
+			}))
+		});
+	}
+	return snapPlan(input, chosen, {
+		minSize: size,
+		direct: true
+	});
+}
+// src/highways/ridges/index.ts
+/** The default options of the strategy `ridges`. */
+const RIDGE_DEFAULTS = Object.freeze({
+	source: "lines",
+	cell: 8,
+	bandwidth: 16,
+	strength: .15,
+	minLength: 60,
+	snap: 16,
+	minSize: 2
+});
+/** The largest angle between an edge and a ridge that it snaps to, in degrees. */
+const MAX_ANGLE = 30;
+/**
+* This function gives the density of the polylines on a grid of cells, after a Gaussian blur of the width `bandwidth`.
+* Each polyline adds 1 to each cell that it goes through, one time for each polyline.
+*/
+function lineDensity(lines, box, cellSize, bandwidth) {
+	const cell = Math.max(cellSize, box.w / 1024, box.h / 1024, 1e-6);
+	const pad = 3 * bandwidth;
+	const x0 = box.x - pad;
+	const y0 = box.y - pad;
+	const w = Math.max(1, Math.ceil((box.w + 2 * pad) / cell));
+	const h = Math.max(1, Math.ceil((box.h + 2 * pad) / cell));
+	const raw = new Float64Array(w * h);
+	const stamp = new Int32Array(w * h).fill(-1);
+	lines.forEach((p, li) => {
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			const steps = Math.max(1, Math.ceil(2 * dist(a, b) / cell));
+			for (let k = 0; k <= steps; k++) {
+				const x = Math.floor((a.x + (b.x - a.x) * k / steps - x0) / cell);
+				const y = Math.floor((a.y + (b.y - a.y) * k / steps - y0) / cell);
+				if (x < 0 || y < 0 || x >= w || y >= h) continue;
+				const c = y * w + x;
+				if (stamp[c] === li) continue;
+				stamp[c] = li;
+				raw[c] = raw[c] + 1;
+			}
+		}
+	});
+	const sigma = Math.max(1e-6, bandwidth / cell);
+	const r = Math.ceil(3 * sigma);
+	const kernel = Array.from({ length: 2 * r + 1 }, (_, i) => Math.exp(-((i - r) ** 2) / (2 * sigma * sigma)));
+	const sum = kernel.reduce((s, v) => s + v, 0);
+	const tmp = new Float64Array(w * h);
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		let v = 0;
+		for (let i = -r; i <= r; i++) {
+			const xi = x + i;
+			if (xi >= 0 && xi < w) v += raw[y * w + xi] * kernel[i + r];
+		}
+		tmp[y * w + x] = v / sum;
+	}
+	const rho = new Float64Array(w * h);
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		let v = 0;
+		for (let i = -r; i <= r; i++) {
+			const yi = y + i;
+			if (yi >= 0 && yi < h) v += tmp[yi * w + x] * kernel[i + r];
+		}
+		rho[y * w + x] = v / sum;
+	}
+	return {
+		w,
+		h,
+		cell,
+		x0,
+		y0,
+		rho
+	};
+}
+/**
+* This function gives the ridges of a density image (Lindeberg 1998). A ridge cell has a negative eigenvalue of the Hessian with the larger size.
+* Its density is a maximum along the eigenvector of that eigenvalue. Its strength is the density times the size of that eigenvalue.
+* The cells with `strength` times the largest strength or more join their neighbours with a direction within 30 degrees.
+* Each group of cells gives the segment of its main axis. A segment of `minLength` or more is a ridge. The ridges come in the order of their total strength.
+*/
+function densityRidges(img, strength, minLength) {
+	const { w, h, rho } = img;
+	const at = (x, y) => rho[Math.min(h - 1, Math.max(0, y)) * w + Math.min(w - 1, Math.max(0, x))];
+	const power = new Float64Array(w * h);
+	const across = new Float64Array(w * h * 2);
+	let top = 0;
+	for (let y = 1; y < h - 1; y++) for (let x = 1; x < w - 1; x++) {
+		const v = at(x, y);
 		if (v <= 0) continue;
 		const hxx = at(x + 1, y) - 2 * v + at(x - 1, y);
 		const hyy = at(x, y + 1) - 2 * v + at(x, y - 1);
@@ -21318,18 +22709,343 @@ const PIPELINE_SCHEMA = {
 		step: "levels",
 		describe: "The level rule of a router that reads one, for example `sections`."
 	},
-	levelOptions: {
-		type: "object",
-		describe: "The options of the level rule."
+	levelOptions: {
+		type: "object",
+		describe: "The options of the level rule."
+	},
+	room: {
+		type: "strategy",
+		step: "room",
+		describe: "The room strategy. With it, the gaps of the board open before the routes. Without it, the board stays."
+	},
+	roomOptions: {
+		type: "object",
+		describe: "The options of the room strategy."
+	}
+};
+/** The declarations of the options of the highway strategy `steiner` (HWY-036 with EDA-015). */
+const STEINER_SCHEMA = {
+	group: {
+		type: "enum",
+		values: ["source", "key"],
+		default: "source",
+		describe: "The groups of the trees: the edges from one source node, or the edges of one collection."
+	},
+	method: {
+		type: "enum",
+		values: ["one-steiner", "spanning"],
+		default: "one-steiner",
+		describe: "The method of the tree: the iterated 1-Steiner method, or the spanning tree of the terminals."
+	},
+	maxGroup: {
+		type: "integer",
+		min: 3,
+		max: 32,
+		step: 1,
+		marks: [
+			8,
+			12,
+			16
+		],
+		default: 12,
+		describe: "A group with more terminals than this number gets the spanning tree alone."
+	},
+	metric: {
+		type: "enum",
+		values: ["rectilinear", "octilinear"],
+		default: "rectilinear",
+		describe: "The metric of the tree: two directions or four directions."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "An edge rides the tree only when its path in the tree is this many times its first route or less."
+	},
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 2,
+		describe: "A stretch of a tree with fewer edges than this number is not a highway."
+	}
+};
+/** The declarations of the options of the highway strategy `gaps` (HWY-057). */
+const GAP_SCHEMA = {
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		marks: [
+			2,
+			3,
+			6
+		],
+		default: 3,
+		describe: "A street with fewer edges than this number (the demand) is not a highway."
+	},
+	discount: {
+		type: "number",
+		min: .1,
+		max: .8,
+		step: .05,
+		marks: [
+			.3,
+			.5,
+			.7
+		],
+		default: .5,
+		describe: "The cost of a length on a street against a length off the streets."
+	},
+	detour: {
+		type: "number",
+		min: 1,
+		max: 2,
+		step: .05,
+		marks: [
+			1.2,
+			1.3,
+			1.5
+		],
+		default: 1.3,
+		describe: "An edge rides a street only when its way along the street is this many times its first route or less."
+	},
+	source: {
+		type: "enum",
+		values: ["room", "corners"],
+		default: "room",
+		describe: "The source of the streets: the gaps of the room step, or the lines through the corners."
+	}
+};
+/** The declarations of the options of the highway strategy `streets` (HWY-058). */
+const STREET_SCHEMA = {
+	detour: {
+		type: "number",
+		min: 1,
+		max: 1.5,
+		step: .05,
+		marks: [
+			1.1,
+			1.2,
+			1.3
+		],
+		default: 1.2,
+		describe: "A street covers an edge when the way of the edge along it is this many times its first route or less."
+	},
+	minGain: {
+		type: "number",
+		min: 1,
+		max: 8,
+		step: .25,
+		marks: [
+			1.5,
+			2,
+			4
+		],
+		default: 2,
+		describe: "The cover stops when the best street gives less gain: the length that its edges ride over its length."
+	},
+	maxStreets: {
+		type: "integer",
+		min: 4,
+		max: 64,
+		step: 4,
+		marks: [16, 32],
+		default: 32,
+		describe: "The largest number of streets."
+	},
+	minSize: {
+		type: "integer",
+		min: 2,
+		max: 16,
+		step: 1,
+		default: 2,
+		describe: "A street with fewer new edges than this number is not a highway."
+	},
+	source: {
+		type: "enum",
+		values: ["room", "corners"],
+		default: "corners",
+		describe: "The source of the streets: the gaps of the room step, or the lines through the corners."
+	}
+};
+/** The declarations of the options of the highway strategy `search` (HWY-059). */
+const SEARCH_SCHEMA = {
+	from: {
+		type: "enum",
+		values: [
+			"corridors",
+			"quickbundles",
+			"wspd",
+			"road-classes",
+			"flow-field",
+			"od-cells",
+			"shared-ways"
+		],
+		default: "corridors",
+		describe: "The plan where the search starts."
+	},
+	pool: {
+		type: "list",
+		default: ["quickbundles", "road-classes"],
+		describe: "The generators of the highways that the move `add` takes."
+	},
+	evaluations: {
+		type: "integer",
+		min: 0,
+		max: 400,
+		step: 4,
+		marks: [
+			0,
+			16,
+			64
+		],
+		default: 16,
+		describe: "The number of plans that the search measures. The value 0 gives the start plan."
+	},
+	temperature: {
+		type: "number",
+		min: 0,
+		max: .2,
+		step: .005,
+		marks: [
+			0,
+			.02,
+			.05
+		],
+		default: .02,
+		describe: "The first temperature of the annealing, on the scale of the score."
+	},
+	inkWeight: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [1],
+		default: 1,
+		describe: "The weight of the ink that the routes save (B1)."
+	},
+	stretchWeight: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [.5],
+		default: .5,
+		describe: "The weight of the 0.95 quantile of the stretch (B3)."
+	},
+	ambiguityWeight: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [.5],
+		default: .5,
+		describe: "The weight of the ambiguity (B4)."
+	},
+	angleWeight: {
+		type: "number",
+		min: 0,
+		max: 4,
+		step: .25,
+		marks: [.25],
+		default: .25,
+		describe: "The weight of the largest merge angle (B6), divided by 180 degrees."
+	},
+	seed: {
+		type: "integer",
+		min: 0,
+		max: 1e3,
+		step: 1,
+		default: 1,
+		describe: "The seed of the moves."
+	}
+};
+/** The declarations of the options of the highway strategy `interchanges` (HWY-060). */
+const INTERCHANGE_SCHEMA = {
+	from: {
+		type: "enum",
+		values: ["corridors", "shared-ways"],
+		default: "corridors",
+		describe: "The plan that gives the highways of the network."
+	},
+	changeCost: {
+		type: "number",
+		min: 0,
+		max: 8,
+		step: .5,
+		marks: [
+			0,
+			2,
+			4
+		],
+		default: 2,
+		describe: "The cost of a change between two highways, in units of the board."
+	},
+	interchanges: {
+		type: "integer",
+		min: 1,
+		max: 32,
+		step: 1,
+		marks: [4, 16],
+		default: 16,
+		describe: "The largest number of interchanges."
+	},
+	perEdge: {
+		type: "integer",
+		min: 1,
+		max: 3,
+		step: 1,
+		default: 2,
+		describe: "The largest number of highways on the way of one edge."
+	},
+	radius: {
+		type: "number",
+		min: .5,
+		max: 8,
+		step: .5,
+		marks: [
+			1,
+			2,
+			4
+		],
+		default: 2,
+		describe: "Two highways get an interchange where they come this near, in units of the board."
 	},
-	room: {
-		type: "strategy",
-		step: "room",
-		describe: "The room strategy. With it, the gaps of the board open before the routes. Without it, the board stays."
+	discount: {
+		type: "number",
+		min: .1,
+		max: 1,
+		step: .05,
+		marks: [
+			.3,
+			.5,
+			.7
+		],
+		default: .5,
+		describe: "The cost of a length on a highway against a length off the highways."
 	},
-	roomOptions: {
-		type: "object",
-		describe: "The options of the room strategy."
+	detour: {
+		type: "number",
+		min: 1,
+		max: 3,
+		step: .05,
+		marks: [
+			1.25,
+			1.5,
+			2
+		],
+		default: 1.5,
+		describe: "An edge rides the network only when its way is this many times its first route or less."
 	}
 };
 // src/strategies/builtins.ts
@@ -22020,6 +23736,51 @@ const highwayStrategies = Object.freeze({
 		maxNodes: 1e4,
 		run: (input, o) => scaleSpacePlan(input, o)
 	}),
+	steiner: defineStrategy({
+		step: "highway",
+		name: "steiner",
+		describe: "Obstacle-avoiding rectilinear Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree, and the stretches that edges share become highways.",
+		defaults: { ...STEINER_DEFAULTS },
+		schema: STEINER_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => steinerPlan(input, o)
+	}),
+	gaps: defineStrategy({
+		step: "highway",
+		name: "gaps",
+		describe: "Gap highways (HWY-057). The free middle lines of the gaps are streets, and a street that enough edges choose becomes a highway.",
+		defaults: { ...GAP_DEFAULTS },
+		schema: GAP_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => gapPlan(input, o)
+	}),
+	streets: defineStrategy({
+		step: "highway",
+		name: "streets",
+		describe: "Orthogonal streets by a greedy set cover (HWY-058). Each step takes the street that its new edges ride the most per unit of its length.",
+		defaults: { ...STREET_DEFAULTS },
+		schema: STREET_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => streetPlan(input, o)
+	}),
+	search: defineStrategy({
+		step: "highway",
+		name: "search",
+		describe: "A local search over the set of highways (HWY-059). The annealing adds, drops and moves highways, edges and points on a score of the bundle measures.",
+		defaults: { ...SEARCH_DEFAULTS },
+		schema: SEARCH_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => searchPlan(input, o)
+	}),
+	interchanges: defineStrategy({
+		step: "highway",
+		name: "interchanges",
+		describe: "A network of highways with interchanges (HWY-060). Each edge rides up to a number of highways, with a cost for each change.",
+		defaults: { ...INTERCHANGE_DEFAULTS },
+		schema: INTERCHANGE_SCHEMA,
+		maxNodes: 1e4,
+		run: (input, o) => interchangePlan(input, o)
+	}),
 	"corridors+breakeven": gateStrategy(corridors, breakEvenGate),
 	"corridors+stretch": gateStrategy(corridors, stretchGate),
 	"corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -23394,199 +25155,6 @@ function formatSections(rows) {
 		})
 	].join("\n");
 }
-// src/bench/measures/bundles.ts
-/**
-* This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
-* `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
-*/
-function inkSaved(routes) {
-	let total = 0;
-	for (const r of routes) total += polylineLength(r.points);
-	if (total <= 0) return 0;
-	let ink = 0;
-	for (const [a, b] of drawnSegments(routes)) ink += dist(a, b);
-	return Math.max(0, 1 - ink / total);
-}
-/**
-* This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
-* `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
-* `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
-*/
-function ambiguity(graph, routes, options = {}) {
-	const n = graph.nodes.length;
-	const index = new Map(graph.nodes.map((v, i) => [v.id, i]));
-	const ends = /* @__PURE__ */ new Map();
-	for (const e of graph.edges) {
-		const s = index.get(e.source.node);
-		const t = index.get(e.target.node);
-		if (s !== void 0 && t !== void 0) ends.set(e.id, [s, t]);
-	}
-	const keyIds = /* @__PURE__ */ new Map();
-	const nodesOf = [];
-	const keysOf = /* @__PURE__ */ new Map();
-	for (const r of routes) {
-		const end = ends.get(r.edge);
-		if (!end) continue;
-		const own = [];
-		for (let i = 1; i < r.points.length; i++) {
-			const k = segmentKey(r.points[i - 1], r.points[i]);
-			if (k === void 0) continue;
-			let id = keyIds.get(k);
-			if (id === void 0) {
-				id = nodesOf.length;
-				keyIds.set(k, id);
-				nodesOf.push([]);
-			}
-			if (own.includes(id)) continue;
-			own.push(id);
-			nodesOf[id].push(end[0], end[1]);
-		}
-		keysOf.set(r.edge, own);
-	}
-	const mark = new Int32Array(n).fill(-1);
-	nodesOf.forEach((list, k) => {
-		let j = 0;
-		for (const v of list) if (mark[v] !== k) {
-			mark[v] = k;
-			list[j++] = v;
-		}
-		list.length = j;
-	});
-	const incident = Array.from({ length: n }, () => []);
-	const adjacent = Array.from({ length: n }, () => []);
-	for (const e of graph.edges) {
-		const end = ends.get(e.id);
-		if (!end) continue;
-		incident[end[0]].push(e.id);
-		incident[end[1]].push(e.id);
-		adjacent[end[0]].push(end[1]);
-		adjacent[end[1]].push(end[0]);
-	}
-	const exact = n <= (options.exact ?? 1e3);
-	const R = rng(options.seed ?? 1);
-	const pick = exact ? Array.from({ length: n }, (_, i) => i) : Array.from({ length: options.sample ?? 2e3 }, () => Math.floor(R() * n));
-	const keyStamp = new Int32Array(nodesOf.length).fill(-1);
-	const nearStamp = new Int32Array(n).fill(-1);
-	const linkStamp = new Int32Array(n).fill(-1);
-	let all = 0;
-	let wrong = 0;
-	pick.forEach((v, step) => {
-		for (const w of adjacent[v]) linkStamp[w] = step;
-		nearStamp[v] = step;
-		for (const e of incident[v]) for (const k of keysOf.get(e) ?? []) {
-			if (keyStamp[k] === step) continue;
-			keyStamp[k] = step;
-			for (const w of nodesOf[k]) {
-				if (nearStamp[w] === step) continue;
-				nearStamp[w] = step;
-				all++;
-				if (linkStamp[w] !== step) wrong++;
-			}
-		}
-	});
-	return {
-		value: all ? wrong / all : 0,
-		estimated: !exact
-	};
-}
-/** The drawn segments of each route, as keys, in the order of its points. A segment shorter than the grain of `segmentKey` has no key. */
-function routeKeys(routes) {
-	const keys = /* @__PURE__ */ new Map();
-	const users = /* @__PURE__ */ new Map();
-	for (const r of routes) {
-		const own = [];
-		for (let i = 1; i < r.points.length; i++) {
-			const k = segmentKey(r.points[i - 1], r.points[i]);
-			if (k === void 0) continue;
-			own.push(k);
-			let set = users.get(k);
-			if (!set) users.set(k, set = /* @__PURE__ */ new Set());
-			set.add(r.edge);
-		}
-		keys.set(r.edge, own);
-	}
-	return {
-		keys,
-		users
-	};
-}
-/**
-* This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
-* An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
-* The scale is 0 to 1. A higher value is better only in context. The cost is linear.
-*/
-function bundledShare(result) {
-	const routes = result.routes;
-	if (routes.length === 0) return 0;
-	const shared = /* @__PURE__ */ new Set();
-	for (const run of result.runs ?? []) for (const e of run.edges) shared.add(e);
-	for (const b of result.bundles ?? []) if (b.edges.length > 1) for (const e of b.edges) shared.add(e);
-	const { keys, users } = routeKeys(routes);
-	for (const [edge, own] of keys) if (own.some((k) => (users.get(k)?.size ?? 0) > 1)) shared.add(edge);
-	let count = 0;
-	for (const r of routes) if (shared.has(r.edge)) count++;
-	return count / routes.length;
-}
-/**
-* This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
-* The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
-* The cost is an extra run of the base router, and then linear.
-*/
-function bundleStretch(routes, base) {
-	const baseLength = /* @__PURE__ */ new Map();
-	for (const r of base) baseLength.set(r.edge, polylineLength(r.points));
-	const st = [];
-	for (const r of routes) {
-		const b = baseLength.get(r.edge);
-		if (b === void 0 || b <= 1 || r.points.length < 2) continue;
-		st.push(polylineLength(r.points) / b);
-	}
-	if (st.length === 0) return {
-		median: 1,
-		q95: 1,
-		edges: 0
-	};
-	return {
-		median: quantile(st, .5),
-		q95: quantile(st, .95),
-		edges: st.length
-	};
-}
-/**
-* This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
-* A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
-* One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
-* Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
-*/
-function mergeAngle(routes) {
-	const { users } = routeKeys(routes);
-	const sig = /* @__PURE__ */ new Map();
-	for (const [k, set] of users) sig.set(k, [...set].sort().join("\0"));
-	let max = 0;
-	for (const r of routes) {
-		let prev;
-		for (let i = 1; i < r.points.length; i++) {
-			const a = r.points[i - 1];
-			const b = r.points[i];
-			const k = segmentKey(a, b);
-			if (k === void 0) continue;
-			if (prev && sig.get(prev.k) !== sig.get(k) && ((users.get(prev.k)?.size ?? 0) > 1 || (users.get(k)?.size ?? 0) > 1)) {
-				const ux = prev.b.x - prev.a.x;
-				const uy = prev.b.y - prev.a.y;
-				const vx = b.x - a.x;
-				const vy = b.y - a.y;
-				const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
-				max = Math.max(max, turn * 180 / Math.PI);
-			}
-			prev = {
-				k,
-				a,
-				b
-			};
-		}
-	}
-	return max;
-}
 // src/bench/measures/levels.ts
 /** This function gives the levels in the order of their depth, from the far view to the near view. */
 function byDepth(levels) {
@@ -25842,6 +27410,11 @@ function sideAt(p, w, h) {
 /** This function gives 0 for -0, because JSON writes -0 as 0. Then a file and the graph that it comes from hold the same numbers. */
 const num = round3;
 function portToFile(p, n) {
+	if (p.along !== void 0) return {
+		id: p.id,
+		...p.side ? { side: TO_FILE[p.side] } : {},
+		along: p.along
+	};
 	const side = p.side ? TO_FILE[p.side] : p.at ? sideAt(p.at, n.box.w, n.box.h) : void 0;
 	return {
 		id: p.id,
@@ -25853,6 +27426,11 @@ function portToFile(p, n) {
 	};
 }
 function portToModel(p) {
+	if (p.along !== void 0) return {
+		id: p.id,
+		...p.side ? { side: TO_MODEL[p.side] } : {},
+		along: p.along
+	};
 	if (p.x !== void 0 && p.y !== void 0) return {
 		id: p.id,
 		at: {
@@ -25867,7 +27445,7 @@ function portToModel(p) {
 }
 /**
 * This function writes a graph as an input file of the form `layout-input/1`, with its hash.
-* A fixed plug gets `x`, `y` and the side that holds it. `inputGraph` reads the file back.
+* A fixed plug gets `x`, `y` and the side that holds it. A plug with `along` keeps its `side` and `along`. `inputGraph` reads the file back.
 */
 function graphInput(graph, head) {
 	const boxes = graph.nodes.map((n) => ({
@@ -28193,7 +29771,12 @@ const MOVE_NAMES = Object.freeze({
 	territories: "territory",
 	consensus: "cluster",
 	"p-hub": "hubLink",
-	"scale-space": "cluster"
+	"scale-space": "cluster",
+	steiner: "tree",
+	gaps: "gap",
+	streets: "street",
+	search: "searched",
+	interchanges: "networkRoad"
 });
 /**
 * 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.
@@ -30379,6 +31962,6 @@ const sharedStretchStrategy = defineStrategy({
 		name: "shared-stretch"
 	}).route(graph)
 });
-export { AMBIGUITY_GUARD_DEFAULTS, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, 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, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, 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, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, 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, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, 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, 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_WRAPS, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, STABLE_ID_DEFAULTS, STEPS, STRATEGIES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, arcCurve, areaPlan, asRouter, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkPlan, 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, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diffusionPlan, dimensionAt, dimensionUnit, dist, 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, 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, frechet, frechetBundles, frechetPlan, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, 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, isRoutedStep, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, 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, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, 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, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitPath, splitPoint, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, waypointWay, weberPoint, weiszfeldPlan, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
+export { AMBIGUITY_GUARD_DEFAULTS, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, 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, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, 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, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, 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, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, 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, 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_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPECTRAL_DEFAULTS, SPIRAL_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, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, arcCurve, areaPlan, asRouter, attractionRouter, attractionStrategy, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, 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, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diffusionPlan, dimensionAt, dimensionUnit, dist, 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, 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, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, 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, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, 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, 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, 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, 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, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitPath, splitPoint, 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, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, waypointWay, weberPoint, weiszfeldPlan, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
 
 //# sourceMappingURL=index.js.map