@mark1russell7/highways 0.4.1 → 0.5.0

package/src/highways/gates/ids/index.ts

@@ -0,0 +1,59 @@
+import type { Highway, HighwayInput, HighwayPlan } from "../../model.ts";
+import { commonEdges, matchHighways, type Gate } from "../model.ts";
+
+/** The options of the gate `ids` (HWY-054). */
+export interface StableIdOptions {
+  /** A new highway takes the id of an old highway when the Jaccard index of their edges is this value or more. The default is 0.5. */
+  readonly minJaccard: number;
+}
+
+/** The default options of the gate `ids`. */
+export const STABLE_ID_DEFAULTS: Readonly<StableIdOptions> = Object.freeze({ minJaccard: 0.5 });
+
+/** This function gives the number at the end of an id, or -1 for an id without a number at its end. */
+function numberOf(id: string): number {
+  let start = id.length;
+  while (start > 0 && id.charCodeAt(start - 1) >= 48 && id.charCodeAt(start - 1) <= 57) start--;
+  return start === id.length ? -1 : Number(id.slice(start));
+}
+
+/**
+ * This function gives stable ids to the highways of a plan (HWY-054). The earlier plan is `input.previous`.
+ * Each new highway takes the id of the old highway with the most common edges.
+ * The pairs with the largest Jaccard index of their edges come first.
+ *
+ * A pair needs an index of `minJaccard` or more, and only the edges of both graphs count.
+ * A new highway without a match gets a new id `h<n>` that no old highway and no new highway has. Thus the old highway of a new id ends.
+ * The gate changes only the ids, so the routes do not change. Without an earlier plan, the plan does not change.
+ */
+export function stableIdPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StableIdOptions>): HighwayPlan {
+  if (!input.previous) return plan;
+  const before = input.previous.plan;
+  const matched = matchHighways(before, plan, options.minJaccard, commonEdges(input.previous.graph, input.graph));
+  const taken = new Set<string>([...before.highways.map((h) => h.id)]);
+  for (const [, i0] of matched) taken.add(before.highways[i0]!.id);
+  let next = 1 + Math.max(-1, ...before.highways.map((h) => numberOf(h.id)), ...plan.highways.map((h) => numberOf(h.id)));
+  const fresh = (): string => {
+    while (taken.has(`h${next}`)) next++;
+    const id = `h${next++}`;
+    taken.add(id);
+    return id;
+  };
+  const highways = plan.highways.map((h, i): Highway => {
+    const i0 = matched.get(i);
+    const id = i0 === undefined ? fresh() : before.highways[i0]!.id;
+    return id === h.id ? h : { ...h, id };
+  });
+  return { highways };
+}
+
+/** The gate `ids` (HWY-054): stable highway ids across edits. A highway keeps the id of its match in the earlier plan. */
+export const stableIdGate: Gate<StableIdOptions> = {
+  name: "ids",
+  describe: "The gate `ids` (HWY-054) gives each highway the id of the highway of the earlier plan with the most common edges. The routes do not change.",
+  defaults: STABLE_ID_DEFAULTS,
+  schema: {
+    minJaccard: { type: "number", min: 0.3, max: 0.8, step: 0.05, default: 0.5, describe: "A new highway takes the id of an old highway when the Jaccard index of their edges is this value or more." },
+  },
+  apply: (input, plan, options) => stableIdPlan(input, plan, options),
+};

package/src/highways/gates/index.ts

@@ -0,0 +1,6 @@
+export { commonEdges, edgeLengths, gateStrategy, jaccard, keepMembers, matchHighways, type EdgeLengths, type Gate } from "./model.ts";
+export { BREAK_EVEN_DEFAULTS, breakEvenGate, breakEvenPlan, type BreakEvenOptions } from "./breakeven/index.ts";
+export { STRETCH_DEFAULTS, stretchGate, stretchPlan, type StretchOptions } from "./stretch/index.ts";
+export { AMBIGUITY_GUARD_DEFAULTS, ambiguityGate, ambiguityPlan, nodeAmbiguity, type AmbiguityGuardOptions } from "./ambiguity/index.ts";
+export { HYSTERESIS_DEFAULTS, hysteresisGate, hysteresisPlan, SAME_HIGHWAY, type HysteresisOptions } from "./hysteresis/index.ts";
+export { STABLE_ID_DEFAULTS, stableIdGate, stableIdPlan, type StableIdOptions } from "./ids/index.ts";

package/src/highways/gates/model.ts

@@ -0,0 +1,129 @@
+import { polylineLength } from "../../geom.ts";
+import type { Graph } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import type { WayOptions } from "../../ways.ts";
+import { follow } from "../follow.ts";
+import type { Highway, HighwayInput, HighwayMember, HighwayPlan } from "../model.ts";
+import { wayOptionsOf } from "../router.ts";
+
+/**
+ * A gate: a rule that keeps, drops or changes the highways of a plan. `gateStrategy` puts a gate after a highway strategy.
+ * A gate does not move a spine. It takes members out of a highway, drops a highway or changes the id of a highway.
+ */
+export interface Gate<G extends object> {
+  /** The name of the gate. The strategy of a gate has the name `<strategy>+<gate>`. */
+  readonly name: string;
+  /** One or two sentences that tell what the gate does. */
+  readonly describe: string;
+  /** The values of the options of the gate. Their keys must not be keys of the options of the strategy before the gate. */
+  readonly defaults: G;
+  readonly schema: OptionSchema<G>;
+  /** This function gives the plan after the gate. `way` holds the options of the way finder of the strategy. */
+  apply(input: HighwayInput, plan: HighwayPlan, options: Readonly<G>, way: WayOptions): HighwayPlan;
+}
+
+/**
+ * This function puts a gate after a highway strategy. The new strategy has the name `<strategy>+<gate>`, and the options of both.
+ * The strategy gets its own options, and the gate gets the plan of the strategy and the options of the gate.
+ * Thus a gate can follow each plan, for example `corridors+breakeven` or `shared-ways+stretch`. Gates can follow gates.
+ */
+export function gateStrategy<O extends object, G extends object>(strategy: Strategy<"highway", O>, gate: Gate<G>): Strategy<"highway", O & G> {
+  const keys = Object.keys(gate.defaults);
+  for (const k of keys) if (k in strategy.defaults) throw new Error(`The gate "${gate.name}" has the option "${k}", and the strategy "${strategy.name}" has it too.`);
+  return defineStrategy<"highway", O & G>({
+    step: "highway",
+    name: `${strategy.name}+${gate.name}`,
+    describe: `${strategy.describe} ${gate.describe}`,
+    defaults: { ...strategy.defaults, ...gate.defaults } as O & G,
+    schema: { ...(strategy.schema ?? {}), ...gate.schema } as OptionSchema<O & G>,
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    run: (input: HighwayInput, options: Readonly<O & G>): HighwayPlan => {
+      const own: Record<string, unknown> = {};
+      const mine: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(options)) (keys.includes(k) ? mine : own)[k] = v;
+      return gate.apply(input, strategy.run(input, own as Partial<O>), mine as G, wayOptionsOf(options));
+    },
+  });
+}
+
+/**
+ * This function gives the plan with only the members that `keep` accepts. A highway with fewer than two members goes away.
+ * The lanes keep their order, and each highway keeps its id, its key and its spine.
+ */
+export function keepMembers(plan: HighwayPlan, keep: (h: Highway, m: HighwayMember) => boolean): HighwayPlan {
+  const highways: Highway[] = [];
+  for (const h of plan.highways) {
+    const members = h.members.filter((m) => keep(h, m));
+    if (members.length < 2) continue;
+    if (members.length === h.members.length) {
+      highways.push(h);
+      continue;
+    }
+    const stay = new Set(members.map((m) => m.edge));
+    highways.push({ ...h, lanes: h.lanes.filter((e) => stay.has(e)), members });
+  }
+  return { highways };
+}
+
+/** The lengths of the route of one edge of a plan. */
+export interface EdgeLengths {
+  /** The length of the route along the plan, after `follow`. */
+  readonly route: number;
+  /** The length of the route without a highway: the route of the router `corners`. */
+  readonly alone: number;
+}
+
+/**
+ * This function gives the length of the route of each edge of a plan, along the plan and alone. `follow` routes each edge of a plan on its own.
+ * Thus the route of an edge does not change when another edge leaves the plan.
+ */
+export function edgeLengths(graph: Graph, plan: HighwayPlan, way: WayOptions): Map<string, EdgeLengths> {
+  const edges = new Set(plan.highways.flatMap((h) => h.members.map((m) => m.edge)));
+  const sub: Graph = { nodes: graph.nodes, edges: graph.edges.filter((e) => edges.has(e.id)) };
+  const along = follow(sub, plan, way);
+  const alone = follow(sub, { highways: [] }, way);
+  const lengthOf = new Map(alone.routes.map((r) => [r.edge, polylineLength(r.points)]));
+  return new Map(along.routes.map((r) => [r.edge, { route: polylineLength(r.points), alone: lengthOf.get(r.edge) ?? 0 }]));
+}
+
+/** This function gives the ids of the edges that both graphs have. */
+export function commonEdges(a: Graph, b: Graph): Set<string> {
+  const ids = new Set(b.edges.map((e) => e.id));
+  return new Set(a.edges.map((e) => e.id).filter((id) => ids.has(id)));
+}
+
+/** This function gives the Jaccard index of two sets of edges: the common edges over all edges. Two empty sets give 0. */
+export function jaccard(a: ReadonlySet<string>, b: ReadonlySet<string>): number {
+  let common = 0;
+  for (const x of a) if (b.has(x)) common++;
+  const all = a.size + b.size - common;
+  return all === 0 ? 0 : common / all;
+}
+
+/**
+ * This function matches the highways of a plan with the highways of an earlier plan. It pairs the highways with the largest Jaccard index of their edges first.
+ * A pair needs an index of `min` or more. Each highway is in one pair at most. The result maps the index of a new highway to the index of its old highway.
+ * Only the edges of `edges` count, when this set is present: for example the edges of both graphs.
+ */
+export function matchHighways(before: HighwayPlan, after: HighwayPlan, min: number, edges?: ReadonlySet<string>): Map<number, number> {
+  const setOf = (h: Highway): Set<string> => new Set(h.members.map((m) => m.edge).filter((e) => edges?.has(e) ?? true));
+  const old = before.highways.map(setOf);
+  const now = after.highways.map(setOf);
+  const pairs: [j: number, i: number, i0: number][] = [];
+  now.forEach((a, i) =>
+    old.forEach((b, i0) => {
+      const j = jaccard(a, b);
+      if (j >= min && j > 0) pairs.push([j, i, i0]);
+    }),
+  );
+  pairs.sort((p, q) => q[0] - p[0] || p[1] - q[1] || p[2] - q[2]);
+  const out = new Map<number, number>();
+  const used = new Set<number>();
+  for (const [, i, i0] of pairs) {
+    if (out.has(i) || used.has(i0)) continue;
+    out.set(i, i0);
+    used.add(i0);
+  }
+  return out;
+}

package/src/highways/gates/stretch/index.ts

@@ -0,0 +1,39 @@
+import type { WayOptions } from "../../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../../model.ts";
+import { edgeLengths, keepMembers, type Gate } from "../model.ts";
+
+/** The options of the gate `stretch` (HWY-048). */
+export interface StretchOptions {
+  /** An edge stays on its highways when its route is at most this number times its route alone, plus `pad`. The default is 1.2. */
+  readonly budget: number;
+  /** The added length that each edge can use, in units of the board. The default is 0. */
+  readonly pad: number;
+}
+
+/** The default options of the gate `stretch`. */
+export const STRETCH_DEFAULTS: Readonly<StretchOptions> = Object.freeze({ budget: 1.2, pad: 0 });
+
+/**
+ * This function applies the stretch budget of HWY-048 to a plan: the join test of each edge.
+ * An edge stays on its highways only when its route along the plan is at most `budget` times its route alone, plus `pad`.
+ * The route alone is the route of the router `corners`. An edge that fails leaves each of its highways and goes alone, so the highways do not bend for it.
+ * `follow` routes each edge on its own, so the test of one edge does not change with the other edges. One pass is enough.
+ */
+export function stretchPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StretchOptions>, way: WayOptions = {}): HighwayPlan {
+  const lengths = edgeLengths(input.graph, plan, way);
+  const out = new Set<string>();
+  for (const [edge, l] of lengths) if (l.route > options.budget * l.alone + options.pad + 1e-9) out.add(edge);
+  return out.size === 0 ? plan : keepMembers(plan, (_, m) => !out.has(m.edge));
+}
+
+/** The gate `stretch` (HWY-048): an edge joins a highway only when its route stays in a budget of its route alone. */
+export const stretchGate: Gate<StretchOptions> = {
+  name: "stretch",
+  describe: "The gate `stretch` (HWY-048) keeps an edge on a highway only when its route is at most `budget` times its route alone, plus `pad`.",
+  defaults: STRETCH_DEFAULTS,
+  schema: {
+    budget: { type: "number", min: 1, max: 2, step: 0.05, marks: [1.1, 1.2, 1.3, 1.5], default: 1.2, describe: "The largest ratio of the route along the plan to the route alone." },
+    pad: { type: "number", min: 0, max: 40, step: 5, default: 0, describe: "The added length that each edge can use, in units of the board." },
+  },
+  apply: stretchPlan,
+};

package/src/highways/grouped.ts

@@ -0,0 +1,123 @@
+import { dist, polylineLength, type Point } from "../geom.ts";
+import { orderLanes } from "../segments.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+import { tidyPlan } from "./base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "./model.ts";
+import { sharedWaysPlan } from "./shared-ways/index.ts";
+import { edgePlugs } from "./stretches.ts";
+
+/**
+ * The spine of a group of edges. With `shared`, the edges of each group go through the router `shared` with the group as their key.
+ * Each stretch that they share is a highway. With `trunk`, each group gets one trunk between two terminals, with a leg from each plug.
+ */
+export type GroupSpine = "shared" | "trunk";
+
+/** The values of `GroupSpine`. */
+export const GROUP_SPINES: readonly GroupSpine[] = Object.freeze(["shared", "trunk"]);
+
+/** The group of one edge: its key, and `flip` when the edge goes from the second end of the group to the first end. */
+export interface EdgeGroup {
+  readonly key: string;
+  readonly flip: boolean;
+}
+
+/** The options of `groupedPlan`. */
+export interface GroupedOptions extends WayOptions {
+  readonly spine: GroupSpine;
+  /** A group has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /**
+   * With the spine `trunk`, an edge rides the trunk only when each of its legs is this share of the span or shorter.
+   * The span is the distance between the two terminals. `Infinity` sets no limit.
+   */
+  readonly legMax?: number;
+}
+
+/**
+ * This function gives the geometric median of points (the Weber point), with the iterations of Weiszfeld.
+ * The point has the least sum of the distances to the points.
+ */
+export function weberPoint(points: readonly Point[], iterations = 32): Point {
+  if (points.length === 0) throw new Error("The list has no point.");
+  let p = { x: points.reduce((s, q) => s + q.x, 0) / points.length, y: points.reduce((s, q) => s + q.y, 0) / points.length };
+  for (let k = 0; k < iterations; k++) {
+    let wx = 0;
+    let wy = 0;
+    let w = 0;
+    for (const q of points) {
+      const d = dist(p, q);
+      if (d < 1e-9) return q;
+      wx += q.x / d;
+      wy += q.y / d;
+      w += 1 / d;
+    }
+    const next = { x: wx / w, y: wy / w };
+    if (dist(next, p) < 1e-6) return next;
+    p = next;
+  }
+  return p;
+}
+
+/**
+ * This function gives the highways of the groups of edges. Only the edges in `groups` ride a highway, and each group needs `minSize` edges.
+ * The spine `shared` gives the shared stretches of the router `shared` with the group as the key.
+ * The spine `trunk` gives one trunk for each group, through the corner graph between two terminals.
+ * A terminal is the Weber point of the points out of the plugs at one end of the group. A terminal in a box moves to the nearest of those points.
+ */
+export function groupedPlan(input: HighwayInput, groups: ReadonlyMap<string, EdgeGroup>, o: Readonly<GroupedOptions>): HighwayPlan {
+  const min = Math.max(2, o.minSize);
+  const size = new Map<string, number>();
+  for (const g of groups.values()) size.set(g.key, (size.get(g.key) ?? 0) + 1);
+  const big = (edge: string): EdgeGroup | undefined => {
+    const g = groups.get(edge);
+    return g && (size.get(g.key) ?? 0) >= min ? g : undefined;
+  };
+  const way: WayOptions = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  if (o.spine === "shared") return sharedWaysPlan(input, { ...way, rule: (e) => big(e.id)?.key });
+
+  const finder = new WayFinder(input.graph.nodes, way);
+  const byKey = new Map<string, { edge: string; flip: boolean; a: Point; b: Point; ps: Point; pt: Point }[]>();
+  for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+    const g = big(edge.id);
+    if (!g) continue;
+    const os = finder.out(ps);
+    const ot = finder.out(pt);
+    const item = g.flip ? { edge: edge.id, flip: true, a: ot, b: os, ps: ps.point, pt: pt.point } : { edge: edge.id, flip: false, a: os, b: ot, ps: ps.point, pt: pt.point };
+    const list = byKey.get(g.key);
+    if (list) list.push(item);
+    else byKey.set(g.key, [item]);
+  }
+  const pad = finder.margin / 2;
+  const terminal = (points: readonly Point[]): Point => {
+    const p = weberPoint(points);
+    if (!finder.obstacles.inside(p, pad)) return p;
+    let best = points[0]!;
+    for (const q of points) if (dist(q, p) < dist(best, p)) best = q;
+    return best;
+  };
+  const highways: Highway[] = [];
+  const legMax = o.legMax ?? Infinity;
+  for (const [key, list] of byKey) {
+    if (list.length < min) continue;
+    const ta = terminal(list.map((x) => x.a));
+    const tb = terminal(list.map((x) => x.b));
+    const span = dist(ta, tb);
+    if (span <= finder.margin) continue;
+    const riders = list.filter((x) => dist(x.a, ta) <= legMax * span && dist(x.b, tb) <= legMax * span);
+    if (riders.length < min) continue;
+    const raw = finder.corners.path(ta, tb);
+    if (!raw) continue;
+    const spine = finder.corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= 1e-6) continue;
+    const last = spine.length - 1;
+    const lanes = orderLanes(
+      spine,
+      riders.map((x) => ({ edge: x.edge, points: x.flip ? [x.ps, x.b, ...[...spine].reverse(), x.a, x.pt] : [x.ps, x.a, ...spine, x.b, x.pt] })),
+      "bundle",
+    );
+    const byEdge = new Map(riders.map((x) => [x.edge, x]));
+    const members: HighwayMember[] = lanes.map((edge) => (byEdge.get(edge)!.flip ? memberAt(spine, edge, last, 0) : memberAt(spine, edge, 0, last)));
+    highways.push({ id: `h${highways.length}`, key, spine, lanes, members });
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/growth/index.ts

@@ -0,0 +1,148 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes, nearestPlace, tidyPlan } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The order of the edges in the growth: the longest first route first, or the order of the graph. */
+export type GrowthOrder = "length" | "input";
+
+/** The options of the highway strategy `growth` (HWY-055 of the note on highways). */
+export interface GrowthOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The order of the edges. The default is `length`. */
+  readonly order: GrowthOrder;
+  /** The cost of the part on a spine, as a share of its length. The ramps cost their full length. The default is 0.5. */
+  readonly share: number;
+  /** An edge joins a highway only when its way along it is this value times its first route or shorter. The default is 1.3. */
+  readonly stretch: number;
+  /** A spine end extends when this number of its lanes or more go on together. The default is 3. */
+  readonly extendLanes: number;
+  /** The lanes go on together when their ends are this distance from their center or nearer, in units of the board. The default is 2. */
+  readonly extendRadius: number;
+  /** A highway with this number of edges or more stays in the plan. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `growth`. */
+export const GROWTH_DEFAULTS: Readonly<GrowthOptions> = Object.freeze({ order: "length", share: 0.5, stretch: 1.3, extendLanes: 3, extendRadius: 2, minSize: 2 });
+
+interface Grown {
+  spine: Point[];
+  members: { edge: string; on: number; off: number }[];
+}
+
+interface Rider {
+  readonly edge: string;
+  readonly ps: Point;
+  readonly pt: Point;
+  readonly a: Point;
+  readonly b: Point;
+  readonly len: number;
+}
+
+/**
+ * This function gives the highways of local growth (HWY-055). The edges come one by one, by default the longest first route first.
+ * Each edge joins the highway with the largest saving: its first route less its ramps and `share` of its part on the spine. Without a saving, the edge starts a highway on its own way.
+ * After the growth, a spine end can go on to the center of the far ends of its lanes.
+ * This occurs when `extendLanes` of them or more are near that center and the line is clear.
+ */
+export function growthPlan(input: HighwayInput, o: Readonly<GrowthOptions>): HighwayPlan {
+  const graph = input.graph;
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const pad = finder.margin / 2;
+  const routes = firstRoutes(input);
+  const riders: Rider[] = edgePlugs(graph).map(({ edge, ps, pt }) => {
+    const route = routes.get(edge.id);
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    return { edge: edge.id, ps: ps.point, pt: pt.point, a, b, len: route ? polylineLength(route) : dist(ps.point, pt.point) };
+  });
+  if (o.order === "length") riders.sort((p, q) => q.len - p.len || (p.edge < q.edge ? -1 : p.edge > q.edge ? 1 : 0));
+  const grown: Grown[] = [];
+  const short = finder.margin;
+  for (const r of riders) {
+    let best = -1;
+    let bestSave = 0;
+    let bestOn = 0;
+    let bestOff = 0;
+    grown.forEach((h, hi) => {
+      const on = nearestPlace(h.spine, r.a);
+      const off = nearestPlace(h.spine, r.b);
+      const part = lengthBetween(h.spine, Math.min(on, off), Math.max(on, off));
+      if (part <= short) return;
+      const ramps = dist(r.a, pointAt(h.spine, on)) + dist(pointAt(h.spine, off), r.b);
+      if (ramps + part > o.stretch * r.len) return;
+      const save = r.len - (ramps + o.share * part);
+      if (save > bestSave) [best, bestSave, bestOn, bestOff] = [hi, save, on, off];
+    });
+    if (best >= 0) {
+      grown[best]!.members.push({ edge: r.edge, on: bestOn, off: bestOff });
+      continue;
+    }
+    const raw = finder.corners.path(r.a, r.b);
+    if (!raw) continue;
+    const spine = finder.corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= short) continue;
+    grown.push({ spine, members: [{ edge: r.edge, on: 0, off: spine.length - 1 }] });
+  }
+
+  // A spine end goes on while enough of its lanes go on together.
+  const byEdge = new Map(riders.map((r) => [r.edge, r]));
+  const radius = o.extendRadius * boardUnit(graph);
+  const need = Math.max(2, Math.round(o.extendLanes));
+  for (const h of grown) {
+    for (const end of ["first", "last"] as const) {
+      const last = h.spine.length - 1;
+      const at = end === "first" ? 0 : last;
+      // The far point of each lane at this end: the point out of the plug that the lane goes to or comes from.
+      const far: { m: Grown["members"][number]; side: "on" | "off"; p: Point }[] = [];
+      for (const m of h.members) {
+        const r = byEdge.get(m.edge)!;
+        if (m.on === at) far.push({ m, side: "on", p: r.a });
+        else if (m.off === at) far.push({ m, side: "off", p: r.b });
+      }
+      if (far.length < need) continue;
+      const c = { x: far.reduce((s, f) => s + f.p.x, 0) / far.length, y: far.reduce((s, f) => s + f.p.y, 0) / far.length };
+      const near = far.filter((f) => dist(f.p, c) <= radius);
+      const tip = h.spine[at]!;
+      if (near.length < need || dist(tip, c) <= short) continue;
+      if (finder.obstacles.inside(c, pad) || !finder.obstacles.clear(tip, c, pad)) continue;
+      if (end === "first") {
+        h.spine.unshift(c);
+        for (const m of h.members) [m.on, m.off] = [m.on + 1, m.off + 1];
+        for (const f of near) f.m[f.side] = 0;
+      } else {
+        h.spine.push(c);
+        for (const f of near) f.m[f.side] = last + 1;
+      }
+    }
+  }
+
+  const highways: Highway[] = [];
+  grown.forEach((h, hi) => {
+    if (h.members.length < Math.max(2, o.minSize)) return;
+    const spine = h.spine;
+    const back = [...spine].reverse();
+    const lanes = orderLanes(
+      spine,
+      h.members.map((m) => {
+        const r = byEdge.get(m.edge)!;
+        return { edge: m.edge, points: m.on <= m.off ? [r.ps, r.a, ...spine, r.b, r.pt] : [r.ps, r.a, ...back, r.b, r.pt] };
+      }),
+      "bundle",
+    );
+    const byLane = new Map(h.members.map((m) => [m.edge, m]));
+    const members: HighwayMember[] = lanes.map((edge) => {
+      const m = byLane.get(edge)!;
+      return memberAt(spine, edge, m.on, m.off);
+    });
+    highways.push({ id: `h${hi}`, key: `g${hi}`, spine, lanes, members });
+  });
+  return tidyPlan({ highways });
+}