@mark1russell7/highways 0.4.1 → 0.5.0

package/src/highways/spiral/index.ts

@@ -0,0 +1,205 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { nodeIndex, type Node } from "../../model.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 { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `spiral` (HWY-017 with EDA-035 of the notes). */
+export interface SpiralOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The spiral angle, in degrees: the largest angle between a branch and the line to the root. The default is 25. */
+  readonly alpha: number;
+  /** A node with this number of edges or more gets a spiral tree. The default is 4. */
+  readonly minTargets: number;
+  /** The number of points of the arc of each branch. The default is 4. */
+  readonly arc: number;
+}
+
+/** The default options of the strategy `spiral`. */
+export const SPIRAL_DEFAULTS: Readonly<Required<Omit<SpiralOptions, "margin" | "k">>> = Object.freeze({ alpha: 25, minTargets: 4, arc: 4 });
+
+/** One node of a spiral tree, in polar coordinates around the root. A leaf has an edge, and a join has two children. */
+export interface SpiralNode {
+  readonly r: number;
+  readonly theta: number;
+  readonly point: Point;
+  /** A join with this node is this distance or more nearer to the root than the node. A leaf keeps its box clear so. A join has 0. */
+  readonly clear: number;
+  readonly edge?: string;
+  readonly children: readonly SpiralNode[];
+}
+
+const TAU = 2 * Math.PI;
+
+/** This function gives the angle `t` in the range from 0 to 2 pi. */
+const wrap = (t: number): number => ((t % TAU) + TAU) % TAU;
+
+/**
+ * This function gives the join of the nodes `p` and `q` of a spiral tree with the angle `alpha`. It gives `undefined` when no join is possible.
+ * Each node can reach the points inside its two spirals toward the root: `|theta - theta_p| <= tan(alpha) ln(r_p / r)`.
+ * The join is the point farthest from the root that both nodes reach, and that is `clear` nearer to the root than each node.
+ * At that radius, the join is at the middle of the angles that both nodes reach.
+ */
+export function spiralJoin(p: SpiralNode, q: SpiralNode, alpha: number, root: Point): { r: number; theta: number; point: Point } | undefined {
+  const t = Math.tan(alpha);
+  // The angle from p to q, counterclockwise, in the range from -pi to pi.
+  let delta = wrap(q.theta - p.theta);
+  if (delta > Math.PI) delta -= TAU;
+  const gap = Math.abs(delta);
+  if (gap >= Math.PI || t <= 0) return undefined;
+  const near = p.r <= q.r ? p : q;
+  const far = p.r <= q.r ? q : p;
+  const meet = t * Math.log(far.r / near.r) >= gap ? near.r : Math.exp((Math.log(p.r) + Math.log(q.r) - gap / t) / 2);
+  const r = Math.min(meet, p.r - p.clear, q.r - q.clear);
+  if (!(r > 0)) return undefined;
+  // In the frame where p is at 0 and q is at `gap`, p reaches [-rp, rp] and q reaches [gap - rq, gap + rq].
+  const rp = t * Math.log(p.r / r);
+  const rq = t * Math.log(q.r / r);
+  const lo = Math.max(-rp, gap - rq);
+  const hi = Math.min(rp, gap + rq);
+  if (lo > hi + 1e-9) return undefined;
+  const theta = wrap(p.theta + Math.sign(delta) * ((lo + hi) / 2));
+  return { r, theta, point: { x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) } };
+}
+
+/**
+ * This function gives the spiral tree of the leaves around the root (Buchin, Speckmann and Verbeek 2011), with the greedy sweep.
+ * The sweep goes from the far leaves to the root. A leaf joins the wavefront at its radius. Two nodes that are next to each other in angle join at their join point.
+ * The join with the largest radius goes first. No join occurs below the radius `rMin`. The function gives the nodes of the wavefront at the end.
+ */
+export function spiralTree(leaves: readonly SpiralNode[], alpha: number, root: Point, rMin: number): SpiralNode[] {
+  const waiting = [...leaves].sort((a, b) => b.r - a.r || (a.edge! < b.edge! ? -1 : 1));
+  const front: SpiralNode[] = [];
+  const insert = (n: SpiralNode): void => {
+    let i = 0;
+    while (i < front.length && front[i]!.theta <= n.theta) i++;
+    front.splice(i, 0, n);
+  };
+  for (;;) {
+    let best: { i: number; r: number; theta: number; point: Point } | undefined;
+    if (front.length >= 2)
+      for (let i = 0; i < front.length; i++) {
+        if (front.length === 2 && i === 1) break;
+        const j = (i + 1) % front.length;
+        const join = spiralJoin(front[i]!, front[j]!, alpha, root);
+        if (join && join.r >= rMin && (!best || join.r > best.r)) best = { i, ...join };
+      }
+    const next = waiting[0];
+    if (next && (!best || next.r >= best.r)) {
+      insert(waiting.shift()!);
+      continue;
+    }
+    if (!best) return front;
+    const i = best.i;
+    const j = (i + 1) % front.length;
+    const node: SpiralNode = { r: best.r, theta: best.theta, point: best.point, clear: 0, children: [front[i]!, front[j]!] };
+    for (const k of [i, j].sort((a, b) => b - a)) front.splice(k, 1);
+    insert(node);
+  }
+}
+
+/** This function gives the leaves under a node of a spiral tree, in the order of the tree. */
+function leavesOf(n: SpiralNode): string[] {
+  return n.edge !== undefined ? [n.edge] : n.children.flatMap(leavesOf);
+}
+
+/**
+ * This function gives the highways of the spiral trees (HWY-017, EDA-035). Each node with `minTargets` edges or more is the root of a fan.
+ * The nodes with more edges go first, and each edge is in one fan at most. The far plug of each edge is a leaf of the tree of its fan.
+ * Each branch of a tree with two leaves or more is a highway. Its spine is an arc of a logarithmic spiral, or a way through the corner graph where the arc hits a box.
+ * An edge rides the branches from the root to its leaf, or from its leaf to the root when the root is its target.
+ */
+export function spiralPlan(input: HighwayInput, o: Readonly<SpiralOptions>): 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 byId = nodeIndex(graph);
+  const plugs = edgePlugs(graph);
+  const degree = new Map<string, number>();
+  for (const { edge } of plugs) {
+    if (edge.source.node === edge.target.node) continue;
+    for (const n of [edge.source.node, edge.target.node]) degree.set(n, (degree.get(n) ?? 0) + 1);
+  }
+  const hubs = [...degree].filter(([, d]) => d >= o.minTargets).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+  const alpha = (Math.max(1, Math.min(80, o.alpha)) * Math.PI) / 180;
+  const arcPoints = Math.max(2, Math.round(o.arc));
+  const used = new Set<string>();
+  const highways: Highway[] = [];
+
+  /** This function gives the spine from the point `a` to the point `b`. The spine is a spiral arc in free space, or a way through the corner graph. */
+  const spineOf = (root: Point, a: { r: number; theta: number; point: Point }, b: { r: number; theta: number; point: Point }): Point[] | undefined => {
+    if (finder.obstacles.inside(a.point, pad) || finder.obstacles.inside(b.point, pad)) return undefined;
+    let dt = wrap(b.theta - a.theta);
+    if (dt > Math.PI) dt -= TAU;
+    const arc: Point[] = [a.point];
+    for (let s = 1; s < arcPoints - 1; s++) {
+      const u = s / (arcPoints - 1);
+      const r = a.r * Math.pow(b.r / a.r, u);
+      const theta = a.theta + dt * u;
+      arc.push({ x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) });
+    }
+    arc.push(b.point);
+    if (finder.obstacles.clearPath(arc, pad)) return arc;
+    const way = finder.corners.path(a.point, b.point);
+    return way ? finder.corners.pull(way) : undefined;
+  };
+
+  for (const [hubId] of hubs) {
+    const hub: Node | undefined = byId.get(hubId);
+    if (!hub) continue;
+    const root = center(hub.box);
+    const rMin = Math.hypot(hub.box.w, hub.box.h) / 2 + 2 * finder.margin;
+    const fan = plugs.filter(({ edge }) => !used.has(edge.id) && edge.source.node !== edge.target.node && (edge.source.node === hubId || edge.target.node === hubId));
+    if (fan.length < o.minTargets) continue;
+    const out = new Map<string, boolean>();
+    const near = new Map<string, Point>();
+    const far = new Map<string, Point>();
+    const leaves: SpiralNode[] = fan.map(({ edge, ps, pt }) => {
+      const outward = edge.source.node === hubId;
+      out.set(edge.id, outward);
+      near.set(edge.id, outward ? ps.point : pt.point);
+      const p = outward ? pt.point : ps.point;
+      far.set(edge.id, p);
+      const box = byId.get(outward ? edge.target.node : edge.source.node)!.box;
+      const clear = Math.hypot(box.w, box.h) / 2 + finder.margin;
+      return { r: Math.max(1e-6, dist(root, p)), theta: wrap(Math.atan2(p.y - root.y, p.x - root.x)), point: p, clear, edge: edge.id, children: [] };
+    });
+    for (const { edge } of fan) used.add(edge.id);
+    const tops = spiralTree(leaves, alpha, root, rMin);
+    // The branches: each link from a node to a child with two leaves or more, from the root down.
+    interface Branch {
+      readonly spine: Point[];
+      readonly edges: string[];
+      readonly depth: number;
+    }
+    const branches: Branch[] = [];
+    const walk = (parent: { r: number; theta: number; point: Point }, child: SpiralNode, depth: number): void => {
+      if (child.edge !== undefined) return;
+      const spine = dist(parent.point, child.point) > finder.margin ? spineOf(root, parent, child) : undefined;
+      if (spine && spine.length >= 2) branches.push({ spine, edges: leavesOf(child), depth });
+      for (const c of child.children) if (dist(c.point, child.point) > 1e-9) walk(child, c, depth + 1);
+      // A child at the point of the join (the nearer node of a join) goes on from the same point.
+      for (const c of child.children) if (dist(c.point, child.point) <= 1e-9) for (const g of c.children) walk(child, g, depth + 1);
+    };
+    for (const top of tops) {
+      if (top.edge !== undefined) continue;
+      // The trunk from the hub: it starts at the radius `rMin` on the line to the top node.
+      const start = { r: rMin, theta: top.theta, point: { x: root.x + rMin * Math.cos(top.theta), y: root.y + rMin * Math.sin(top.theta) } };
+      walk(top.r > rMin + finder.margin ? start : top, top, 0);
+    }
+    for (const b of branches) {
+      if (b.edges.length < 2) continue;
+      const last = b.spine.length - 1;
+      const tripOf = (edge: string): Point[] => [near.get(edge)!, ...b.spine, far.get(edge)!];
+      const lanes = orderLanes(
+        b.spine,
+        b.edges.map((edge) => ({ edge, points: tripOf(edge) })),
+        "bundle",
+      );
+      const members: HighwayMember[] = lanes.map((edge) => (out.get(edge) ? memberAt(b.spine, edge, 0, last, b.depth) : memberAt(b.spine, edge, last, 0, -b.depth)));
+      highways.push({ id: `h${highways.length}`, key: `spiral:${hubId}`, spine: b.spine, lanes, members });
+    }
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/stretches.ts

@@ -0,0 +1,141 @@
+import { center, dist, type Point } from "../geom.ts";
+import { nodeIndex, type Edge, type Graph } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { orderLanes } from "../segments.ts";
+import { tidyPlan } from "./base.ts";
+import { memberAt, type Highway, type HighwayMember, type HighwayPlan } from "./model.ts";
+
+/** An edge with its two plugs, as the router `corners` places them. */
+export interface EdgePlugs {
+  readonly edge: Edge;
+  readonly ps: Plug;
+  readonly pt: Plug;
+}
+
+/** This function gives the plugs of each edge of the graph, in the order of the edges. An edge with an unknown node is not in the list. */
+export function edgePlugs(graph: Graph): EdgePlugs[] {
+  const byId = nodeIndex(graph);
+  const out: EdgePlugs[] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    out.push({ edge: e, ps: placePlug(s, e.source, center(t.box)), pt: placePlug(t, e.target, center(s.box)) });
+  }
+  return out;
+}
+
+/** The way of one edge through the corner graph, with a key. Only the ways with one key share a highway. */
+export interface KeyedWay {
+  readonly edge: string;
+  readonly key: string;
+  /** The points of the way, without the plugs. Two ways share a link when the link has the same two points. */
+  readonly points: readonly Point[];
+}
+
+/** The options of `sharedStretches`. */
+export interface SharedStretchOptions {
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /** This function tells if a link can be part of a highway. Without it, each link can. */
+  readonly link?: (a: Point, b: Point) => boolean;
+  /** This function removes the needless corners of a spine. Without it, the spine keeps each point of the stretch. */
+  readonly pull?: (points: readonly Point[]) => Point[];
+}
+
+const pointKey = (p: Point): string => `${p.x},${p.y}`;
+const linkKey = (a: string, b: string): string => (a < b ? `${a}|${b}` : `${b}|${a}`);
+
+/** This function removes each point of a polyline that is equal to the point before it. */
+const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
+
+/**
+ * This function gives a highway for each stretch that two ways or more of one key share. A way is a polyline through the corner graph.
+ * Each way breaks into stretches where the set of the ways on its links stays the same. The router `shared` makes its runs in the same way.
+ * A stretch with fewer than `minSize` ways is not a highway. Each way joins the spine at one end of the stretch and leaves it at the other end.
+ * The `seq` of each member follows the order of the stretches along the way.
+ */
+export function sharedStretches(ways: readonly KeyedWay[], o: Readonly<SharedStretchOptions>): HighwayPlan {
+  const min = Math.max(2, o.minSize);
+  const clean = ways.map((w) => ({ ...w, points: dedupe(w.points) }));
+  const users = new Map<string, string[]>();
+  const usable = (a: Point, b: Point): boolean => o.link?.(a, b) ?? true;
+  for (const w of clean) {
+    const own = new Set<string>();
+    for (let i = 1; i < w.points.length; i++) {
+      const a = w.points[i - 1]!;
+      const b = w.points[i]!;
+      if (usable(a, b)) own.add(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`);
+    }
+    for (const k of own) {
+      const list = users.get(k);
+      if (list) list.push(w.edge);
+      else users.set(k, [w.edge]);
+    }
+  }
+  interface Stretch {
+    readonly key: string;
+    readonly points: readonly Point[];
+    readonly members: { edge: string; forward: boolean; at: number }[];
+  }
+  const stretches = new Map<string, Stretch>();
+  const wayOf = new Map<string, readonly Point[]>();
+  for (const w of clean) {
+    wayOf.set(w.edge, w.points);
+    const sig = (i: number): string => {
+      const a = w.points[i]!;
+      const b = w.points[i + 1]!;
+      if (!usable(a, b)) return "";
+      const list = users.get(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`) ?? [];
+      return list.length < min ? "" : [...list].sort().join("\u0001");
+    };
+    let start = 0;
+    for (let i = 0; i < w.points.length - 1; i++) {
+      const s = sig(i);
+      if (i + 1 < w.points.length - 1 && sig(i + 1) === s) continue;
+      const from = start;
+      start = i + 1;
+      if (s === "") continue;
+      const a = pointKey(w.points[from]!);
+      const b = pointKey(w.points[i + 1]!);
+      if (a === b) continue;
+      const id = `${w.key}\u0000${s}\u0000${linkKey(a, b)}`;
+      const piece = w.points.slice(from, i + 2);
+      let found = stretches.get(id);
+      if (!found) stretches.set(id, (found = { key: w.key, points: a < b ? piece : [...piece].reverse(), members: [] }));
+      if (!found.members.some((m) => m.edge === w.edge)) found.members.push({ edge: w.edge, forward: a < b, at: from });
+    }
+  }
+  // The order of the stretches of each way gives the `seq` of its members.
+  const kept = [...stretches.values()].filter((s) => s.members.length >= min);
+  const order = new Map<string, { s: number; at: number }[]>();
+  kept.forEach((s, si) => {
+    for (const m of s.members) {
+      const list = order.get(m.edge);
+      if (list) list.push({ s: si, at: m.at });
+      else order.set(m.edge, [{ s: si, at: m.at }]);
+    }
+  });
+  const seq = new Map<string, number>();
+  for (const [edge, list] of order) {
+    list.sort((p, q) => p.at - q.at || p.s - q.s);
+    list.forEach((x, k) => seq.set(`${x.s}\u0000${edge}`, k));
+  }
+  const highways: Highway[] = kept.map((s, si) => {
+    const spine = o.pull ? o.pull(s.points) : [...s.points];
+    const last = spine.length - 1;
+    const lanes = orderLanes(
+      s.points,
+      s.members.map((m) => ({ edge: m.edge, points: wayOf.get(m.edge)! })),
+      "bundle",
+    );
+    const byEdge = new Map(s.members.map((m) => [m.edge, m]));
+    const members: HighwayMember[] = lanes.map((edge) => {
+      const m = byEdge.get(edge)!;
+      const k = seq.get(`${si}\u0000${edge}`) ?? 0;
+      return m.forward ? memberAt(spine, edge, 0, last, k) : memberAt(spine, edge, last, 0, k);
+    });
+    return { id: `h${si}`, key: s.key, spine, lanes, members };
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/stubs/index.ts

@@ -0,0 +1,117 @@
+import { center, dist, pointBoxDistance, type Point } from "../../geom.ts";
+import { nodeIndex, type Node } from "../../model.ts";
+import { pointOnSide, SIDE_NORMAL, sideToward } from "../../plugs.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, tidyPlan, tripsOf, type HighwayBase } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayPlan } from "../model.ts";
+
+/** The ends of the edges that get stubs: the source ends, the target ends, or both. */
+export type StubEnds = "source" | "target" | "both";
+
+/** The options of the highway strategy `stubs` (HWY-015 with WILD-005 of the notes). */
+export interface StubOptions {
+  /** The plan that the stubs go into. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The ends of one side of a box whose directions are in a window of this angle share a stub, in degrees. The default is 30. */
+  readonly omega: number;
+  /** The length of a stub is this share of the distance to the nearest other end. The default is 0.25. */
+  readonly sigma: number;
+  /** The ends that get stubs. The default is `both`. */
+  readonly ends: StubEnds;
+  /** A stub has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `stubs`. */
+export const STUB_DEFAULTS: Readonly<StubOptions> = Object.freeze({ from: "shared-ways", omega: 30, sigma: 0.25, ends: "both", minSize: 2 });
+
+/** One end of an edge that can get a stub. */
+interface StubEnd {
+  readonly edge: string;
+  readonly node: Node;
+  readonly other: Node;
+  /** The angle from the normal of the side to the direction of the other node, in radians. A negative angle turns to the left. */
+  readonly turn: number;
+  /** The first merge point of the edge in the plan, from this end, or `undefined`. */
+  readonly merge: Point | undefined;
+}
+
+/**
+ * This function gives the highways of the plan `from`, with a stub at the ends of the edges (HWY-015, WILD-005).
+ * The ends on one side of one box are sorted by the direction of their other node. A run of ends in a window of `omega` makes a group.
+ * Each group of `minSize` ends or more shares one plug and one stub along the normal of the side. Then the edges fan out.
+ *
+ * The length of the stub is `sigma` times the distance to the nearest other node, and half that distance at most.
+ * It is two times the margin of the way finder at least, and the stub stays out of the other boxes. Else the group gets no stub.
+ * An end with a fixed plug or a side of its own gets no stub. An end whose first highway starts on its box, or near it, keeps the plan.
+ */
+export function stubPlan(input: HighwayInput, o: Readonly<StubOptions>): HighwayPlan {
+  const graph = input.graph;
+  const plan = basePlan(input, o.from);
+  const trips = tripsOf(plan);
+  const byId = nodeIndex(graph);
+  const ways = new WayFinder(graph.nodes);
+  const margin = ways.margin;
+  const omega = (Math.max(0, o.omega) * Math.PI) / 180;
+  const groups = new Map<string, StubEnd[]>();
+  const add = (kind: "source" | "target", node: Node, other: Node, edge: string, merge: Point | undefined): void => {
+    const side = sideToward(node.box, center(other.box));
+    const n = SIDE_NORMAL[side];
+    const c = center(node.box);
+    const d = center(other.box);
+    const dx = d.x - c.x;
+    const dy = d.y - c.y;
+    const turn = Math.atan2(n.x * dy - n.y * dx, n.x * dx + n.y * dy);
+    const key = `${node.id}\u0000${kind}\u0000${side}`;
+    const list = groups.get(key);
+    const end: StubEnd = { edge, node, other, turn, merge };
+    if (list) list.push(end);
+    else groups.set(key, [end]);
+  };
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t || s === t) continue;
+    const trip = trips.get(e.id);
+    if (o.ends !== "target" && e.source.port === undefined) add("source", s, t, e.id, trip?.[0]?.m.merge);
+    if (o.ends !== "source" && e.target.port === undefined) add("target", t, s, e.id, trip?.[trip.length - 1]?.m.split);
+  }
+
+  const stubs: Highway[] = [];
+  for (const [key, list] of [...groups].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))) {
+    const [, kind, side] = key.split("\u0000") as [string, "source" | "target", keyof typeof SIDE_NORMAL];
+    list.sort((a, b) => a.turn - b.turn || (a.edge < b.edge ? -1 : 1));
+    // The runs of ends in a window of omega.
+    const runs: StubEnd[][] = [];
+    for (const end of list) {
+      const run = runs[runs.length - 1];
+      if (run && end.turn - run[0]!.turn <= omega) run.push(end);
+      else runs.push([end]);
+    }
+    for (const run of runs) {
+      if (run.length < Math.max(2, o.minSize)) continue;
+      const node = run[0]!.node;
+      const n = SIDE_NORMAL[side];
+      const toward = { x: run.reduce((s, r) => s + center(r.other.box).x, 0) / run.length, y: run.reduce((s, r) => s + center(r.other.box).y, 0) / run.length };
+      const plug = pointOnSide(node.box, side, toward);
+      const span = Math.min(...run.map((r) => dist(plug, center(r.other.box))));
+      const gap = Math.min(...run.map((r) => pointBoxDistance(plug, r.other.box)));
+      let len = Math.min(Math.max(0, o.sigma) * span, gap / 2);
+      const skip = new Set([node]);
+      const tip = (l: number): Point => ({ x: plug.x + n.x * l, y: plug.y + n.y * l });
+      while (len >= 2 * margin && !ways.obstacles.clear(tip(margin / 2), tip(len), margin / 2, skip)) len /= 2;
+      if (len < 2 * margin) continue;
+      // An end whose highway starts on the box, or near the tip, keeps the plan.
+      const kept = run.filter((r) => r.merge === undefined || pointBoxDistance(r.merge, node.box) > 2 * len);
+      if (kept.length < Math.max(2, o.minSize)) continue;
+      const end = tip(len);
+      const spine = kind === "source" ? [plug, end] : [end, plug];
+      // Lane 0 is on the left of the spine. At a source, the left lane turns most to the left. At a target, the order turns over.
+      const lanes = kept.map((r) => r.edge);
+      if (kind === "target") lanes.reverse();
+      const seq = kind === "source" ? -1 : Number.MAX_SAFE_INTEGER;
+      stubs.push({ id: "", key: `stub:${node.id}:${kind}:${side}`, spine, lanes, members: lanes.map((edge) => memberAt(spine, edge, 0, 1, seq)) });
+    }
+  }
+  return tidyPlan({ highways: [...plan.highways, ...stubs] });
+}