@mark1russell7/highways 0.4.0 → 0.4.2

package/src/room/lanes.ts

@@ -15,6 +15,19 @@ export type LaneOrder = "links" | "ends" | "crossings";
 /** The lane orders of `gapLanes`, in the order of the benchmark. */
 export const LANE_ORDERS: readonly LaneOrder[] = ["links", "ends", "crossings"];
 
+/**
+ * The rule that gives each piece of a gap its lane (its track), after the lane order.
+ *
+ * - `stack`: a piece goes one lane past each piece before it in the order that it overlaps. Thus two pieces that overlap keep their order.
+ * - `left-edge`: the constrained left-edge rule of chip routing (EDA-004). Two pieces that overlap keep their order only where a swap adds crossings.
+ *   The rule fills the lowest lane first, with the pieces sorted by their start. Two pieces that do not overlap can share a lane.
+ * - `free`: the left-edge rule without the order. It gives the fewest lanes, but it can add crossings.
+ */
+export type LaneTracks = "stack" | "left-edge" | "free";
+
+/** The lane rules of `gapLanes`, in the order of the benchmark. */
+export const LANE_TRACKS: readonly LaneTracks[] = ["stack", "left-edge", "free"];
+
 /** The options of `gapLanes`. */
 export interface GapLaneOptions {
   /** The largest distance between two lanes. A narrow gap puts its lanes nearer. The default is 4. */
@@ -23,6 +36,22 @@ export interface GapLaneOptions {
   readonly order?: LaneOrder;
   /** Two box edges nearer than this distance make one boundary of the sweep, as in `boardGaps`. The default is 0.5. */
   readonly snap?: number;
+  /** The rule that gives each piece its lane. The default is `stack`. */
+  readonly tracks?: LaneTracks;
+}
+
+/** The lanes of one gap: the axis and the place of the gap, and the number of lanes that its pieces use. */
+export interface GapLaneCount {
+  readonly axis: "x" | "y";
+  readonly at: number;
+  /** The width of the gap. */
+  readonly width: number;
+  /** The number of lanes of the gap. */
+  readonly lanes: number;
+  /** The number of pieces in the gap: the legs of the links that run along it. */
+  readonly pieces: number;
+  /** The largest number of pieces that overlap at one place of the gap. No rule gives fewer lanes. */
+  readonly density: number;
 }
 
 /** A piece of a link: a leg of the link that runs along a gap. */
@@ -47,9 +76,21 @@ const ROUNDS = 8;
  * When a move puts a link through more boxes than before, the link keeps its points.
  */
 export function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options: GapLaneOptions = {}): LevelLink[] {
+  return laneGaps(items, links, options).links;
+}
+
+/** This function gives the lanes of each gap that holds a piece of a link, with the options of `gapLanes`. A gap without a piece is not in the list. */
+export function gapLaneCounts(items: readonly Boxed[], links: readonly LevelLink[], options: GapLaneOptions = {}): GapLaneCount[] {
+  return laneGaps(items, links, options).counts;
+}
+
+/** This function does the work of `gapLanes` and `gapLaneCounts`. It gives the moved links and the lanes of each gap. */
+function laneGaps(items: readonly Boxed[], links: readonly LevelLink[], options: GapLaneOptions): { links: LevelLink[]; counts: GapLaneCount[] } {
   const spacing = Math.max(0, options.spacing ?? 4);
   const order = options.order ?? "crossings";
+  const tracks = options.tracks ?? "stack";
   const moved = links.map((l) => l.points.map((p) => ({ x: p.x, y: p.y })));
+  const counts: GapLaneCount[] = [];
   for (const g of boardGaps(items, options.snap)) {
     if (g.width <= EPS) continue;
     const across = g.axis;
@@ -80,15 +121,9 @@ export function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], o
     });
     if (pieces.length === 0) continue;
     const list = orderPieces(pieces, order);
-    // A piece goes one lane past each piece before it in the order that it overlaps. Thus two pieces that overlap keep their order.
-    const lane: number[] = [];
-    let n = 0;
-    list.forEach((P, i) => {
-      let k = 0;
-      for (let j = 0; j < i; j++) if (overlaps(list[j]!, P)) k = Math.max(k, lane[j]! + 1);
-      lane.push(k);
-      n = Math.max(n, k + 1);
-    });
+    const lane = tracks === "stack" ? stackLanes(list) : leftEdgeLanes(list, tracks === "left-edge");
+    const n = lane.reduce((m, k) => Math.max(m, k + 1), 0);
+    counts.push({ axis: g.axis, at: g.at, width: g.width, lanes: n, pieces: list.length, density: density(list) });
     const step = Math.min(spacing, g.width / (n + 1));
     const mid = (lo + hi) / 2;
     list.forEach((P, i) => {
@@ -99,7 +134,71 @@ export function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], o
   }
   const boxes = new Grid<Box>(Math.max(20, meanSide(items)));
   for (const i of items) boxes.add(i.box, i.box);
-  return links.map((l, i) => (hits(boxes, moved[i]!) > hits(boxes, l.points) ? l : { ...l, points: moved[i]! }));
+  return { links: links.map((l, i) => (hits(boxes, moved[i]!) > hits(boxes, l.points) ? l : { ...l, points: moved[i]! })), counts };
+}
+
+/** This function gives the lanes of the rule `stack`. A piece goes one lane past each piece before it in the order that it overlaps. */
+function stackLanes(list: readonly Piece[]): number[] {
+  const lane: number[] = [];
+  list.forEach((P, i) => {
+    let k = 0;
+    for (let j = 0; j < i; j++) if (overlaps(list[j]!, P)) k = Math.max(k, lane[j]! + 1);
+    lane.push(k);
+  });
+  return lane;
+}
+
+/**
+ * This function gives the lanes of the left-edge rule (Hashimoto and Stevens, 1971) for the pieces in lane order.
+ * With `constrained`, a piece stays below a later piece that it overlaps when the swap of the two adds crossings (`cost`).
+ * These constraints follow the lane order, so they have no cycle. Each pass fills one lane, from the near side.
+ * A pass takes the free pieces whose constraints are met, in the order of their start. It puts each piece that does not overlap the last piece of the lane.
+ */
+function leftEdgeLanes(list: readonly Piece[], constrained: boolean): number[] {
+  const n = list.length;
+  const below: number[][] = list.map(() => []);
+  const wait = new Array<number>(n).fill(0);
+  if (constrained)
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++) {
+        const P = list[i]!;
+        const Q = list[j]!;
+        if (overlaps(P, Q) && cost(Q, P) > cost(P, Q)) {
+          below[i]!.push(j);
+          wait[j]!++;
+        }
+      }
+  const byStart = list.map((_, i) => i).sort((a, b) => list[a]!.lo - list[b]!.lo || a - b);
+  const lane = new Array<number>(n).fill(-1);
+  let placed = 0;
+  for (let track = 0; placed < n; track++) {
+    const now: number[] = [];
+    let end = -Infinity;
+    for (const i of byStart) {
+      if (lane[i]! >= 0 || wait[i]! > 0 || list[i]!.lo < end - EPS) continue;
+      now.push(i);
+      end = list[i]!.hi;
+    }
+    for (const i of now) lane[i] = track;
+    for (const i of now) for (const j of below[i]!) wait[j]!--;
+    placed += now.length;
+  }
+  return lane;
+}
+
+/** This function gives the largest number of pieces that overlap at one place. Pieces that only touch do not overlap. */
+function density(list: readonly Piece[]): number {
+  const events: [number, number][] = [];
+  for (const P of list) events.push([P.lo, 1], [P.hi, -1]);
+  // At one place, an end comes before a start, so pieces that only touch do not overlap.
+  events.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let open = 0;
+  let most = 0;
+  for (const [, d] of events) {
+    open += d;
+    most = Math.max(most, open);
+  }
+  return most;
 }
 
 const overlaps = (P: Piece, Q: Piece): boolean => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;

package/src/routers/corners.ts

@@ -1,14 +1,29 @@
-import { center } from "../geom.ts";
-import { nodeIndex, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
-import { placePlug } from "../plugs.ts";
+import { center, type Point } from "../geom.ts";
+import { nodeIndex, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { justifyPlugs } from "../plugs/justify.ts";
+import { sidePlugs } from "../plugs/side.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
+/** The ways to place a free plug of the corner router. */
+export type PlugPlace = "facing" | "side";
+
 /** The options of the corner router. */
 export interface CornersOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
+  /**
+   * The place of a free plug. The default is `facing`: the plug faces the other end (`placePlug`).
+   * With `side`, the search starts from the whole free side, and the plug goes where the way leaves the side (`sidePlugs`, WILD-001).
+   */
+  readonly plugs?: PlugPlace;
+  /**
+   * The least gap between two free plugs of one side. The default is 0: each plug stays where it is.
+   * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
+   */
+  readonly plugGap?: number;
 }
 
 /**
@@ -23,16 +38,68 @@ export function cornersRouter(options: CornersOptions): Router {
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const routes: Route[] = [];
+      if ((options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
+        for (const e of graph.edges) {
+          const s = byId.get(e.source.node);
+          const t = byId.get(e.target.node);
+          if (!s || !t) continue;
+          const ps = placePlug(s, e.source, center(t.box));
+          const pt = placePlug(t, e.target, center(s.box));
+          routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+        }
+        return { routes };
+      }
+      // First the plugs of each edge, then the gaps of the plugs of each side, then the ways between the plugs.
+      const ends: [Edge, Node, Node, Plug, Plug][] = [];
       for (const e of graph.edges) {
         const s = byId.get(e.source.node);
         const t = byId.get(e.target.node);
         if (!s || !t) continue;
-        const ps = placePlug(s, e.source, center(t.box));
-        const pt = placePlug(t, e.target, center(s.box));
-        routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+        const [ps, pt] =
+          options.plugs === "side" ? sidePlugs(ways, s, e.source, t, e.target) : [placePlug(s, e.source, center(t.box)), placePlug(t, e.target, center(s.box))];
+        ends.push([e, s, t, ps, pt]);
       }
+      if ((options.plugGap ?? 0) > 0) spacePlugs(ends, options.plugGap!);
+      for (const [e, s, t, ps, pt] of ends) routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
       return { routes };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
+
+/**
+ * This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
+ * The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
+ */
+function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number): void {
+  const inset = 6;
+  // The free plugs of each side: the index of the edge, the end (3 for the source, 4 for the target) and the point of the other end.
+  const sides = new Map<string, { node: Node; normal: Point; items: [number, 3 | 4, Point][] }>();
+  ends.forEach(([e, s, t, ps, pt], i) => {
+    for (const [end, node, plug, other, k] of [
+      [e.source, s, ps, pt, 3],
+      [e.target, t, pt, ps, 4],
+    ] as const) {
+      const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+      if (port?.at !== undefined) continue;
+      const key = JSON.stringify([node.id, plug.normal.x, plug.normal.y]);
+      let side = sides.get(key);
+      if (!side) sides.set(key, (side = { node, normal: plug.normal, items: [] }));
+      side.items.push([i, k, other.point]);
+    }
+  });
+  for (const { node, normal, items } of sides.values()) {
+    if (items.length < 2) continue;
+    const along = normal.x !== 0 ? "y" : "x";
+    const b = node.box;
+    const start = along === "y" ? b.y : b.x;
+    const len = along === "y" ? b.h : b.w;
+    const m = Math.min(inset, len / 4);
+    const ideal = items.map(([i, k]) => ends[i]![k].point[along]);
+    const placed = justifyPlugs(ideal, start + m, start + len - m, gap, (j) => items[j]![2][along]);
+    items.forEach(([i, k], j) => {
+      const old = ends[i]![k];
+      ends[i]![k] = { point: along === "y" ? { x: old.point.x, y: placed[j]! } : { x: placed[j]!, y: old.point.y }, normal: old.normal };
+    });
+  }
+}

package/src/routers/fan.ts

@@ -0,0 +1,145 @@
+import { dist, type Point } from "../geom.ts";
+
+/**
+ * This function gives the Gilbert split point of a trunk with `targets.length` edges (EDA-030). The point makes the flow cost least:
+ * `len(start, s) * k^alpha + Σ_j len(s, t_j)`, with `k` the number of targets. Weighted Weiszfeld steps find it.
+ * The distance from `start` stays from `lo` to `hi` times the distance to the center of the targets.
+ * It is also at most half of the distance to the nearest target.
+ * The point moves back toward `start` out of the boxes, in steps of `step`.
+ */
+export function gilbertPoint(
+  start: Point,
+  targets: readonly Point[],
+  alpha: number,
+  free: (p: Point) => boolean,
+  step: number,
+  lo = 0.2,
+  hi = 0.8,
+): Point {
+  if (targets.length === 0) return start;
+  const k = targets.length;
+  const c = { x: targets.reduce((s, p) => s + p.x, 0) / k, y: targets.reduce((s, p) => s + p.y, 0) / k };
+  const L = dist(start, c);
+  if (L === 0) return start;
+  const w0 = k ** Math.min(1, Math.max(0, alpha));
+  let s = { x: start.x + (c.x - start.x) * 0.5, y: start.y + (c.y - start.y) * 0.5 };
+  for (let it = 0; it < 32; it++) {
+    let sx = 0;
+    let sy = 0;
+    let sw = 0;
+    const pull = (p: Point, w: number): void => {
+      const d = Math.max(1e-6, dist(s, p));
+      sx += (w * p.x) / d;
+      sy += (w * p.y) / d;
+      sw += w / d;
+    };
+    pull(start, w0);
+    for (const t of targets) pull(t, 1);
+    const n = { x: sx / sw, y: sy / sw };
+    const moved = dist(n, s);
+    s = n;
+    if (moved < 1e-3) break;
+  }
+  // The clamp keeps the split from `lo` to `hi` of the way, and at most half of the way to the nearest target.
+  const r = dist(start, s);
+  const most = Math.min(hi * L, 0.5 * Math.min(...targets.map((p) => dist(start, p))));
+  const want = Math.min(most, Math.max(lo * L, r));
+  const dir = r > 1e-9 ? { x: (s.x - start.x) / r, y: (s.y - start.y) / r } : { x: (c.x - start.x) / L, y: (c.y - start.y) / L };
+  const at = (t: number): Point => ({ x: start.x + dir.x * t, y: start.y + dir.y * t });
+  let d = want;
+  while (d > 0 && !free(at(d))) d -= step;
+  return d > 0 ? at(d) : start;
+}
+
+/** One point of a balancing-factor tree. */
+export interface FanPoint {
+  readonly point: Point;
+  /** The index of the point before, toward the root. The root has -1. */
+  parent: number;
+  /** The length of the tree from the root to this point. */
+  pl: number;
+  /** A new branch can join the tree at this point, and on the link from its parent. A plug of a target is not open. */
+  readonly open: boolean;
+}
+
+/** The result of `balancedFan`: the points of the tree, and the index of the last point of the route of each target. */
+export interface Fan {
+  readonly points: readonly FanPoint[];
+  readonly leaf: readonly number[];
+}
+
+/**
+ * This function grows a balancing-factor tree from `root` to the targets (NAT-017, after Cuntz and others, 2010).
+ * At each step, the target `t` joins the place `v` of the tree with the least `|v - goal(t)| + bf * PL(v)`.
+ * `PL(v)` is the length of the tree from the root to `v`.
+ * A place is a point of the tree, or the foot of `goal(t)` on a link of the tree. `bf` 0 gives the least ink, and a large `bf` gives direct routes.
+ * `branch(v, t)` gives the way from `v` to the plug of the target `t`: its first point is `v`, and its last point is the plug.
+ */
+export function balancedFan(root: Point, goals: readonly Point[], bf: number, branch: (from: Point, t: number) => Point[]): Fan {
+  const points: FanPoint[] = [{ point: root, parent: -1, pl: 0, open: true }];
+  const leaf: number[] = goals.map(() => -1);
+  const left = new Set(goals.map((_, i) => i));
+  while (left.size > 0) {
+    let best = Infinity;
+    let pick = -1;
+    let at = -1;
+    let foot: { point: Point; pl: number } | undefined;
+    for (const t of left) {
+      const g = goals[t]!;
+      for (let v = 0; v < points.length; v++) {
+        const p = points[v]!;
+        if (!p.open) continue;
+        const c = dist(p.point, g) + bf * p.pl;
+        if (c < best - 1e-9) {
+          best = c;
+          pick = t;
+          at = v;
+          foot = undefined;
+        }
+        // The foot of the goal on the link from the parent of v to v.
+        if (p.parent < 0) continue;
+        const a = points[p.parent]!.point;
+        const b = p.point;
+        const L = dist(a, b);
+        if (L <= 1e-9) continue;
+        const u = ((g.x - a.x) * (b.x - a.x) + (g.y - a.y) * (b.y - a.y)) / (L * L);
+        if (u <= 1e-6 || u >= 1 - 1e-6) continue;
+        const f = { x: a.x + u * (b.x - a.x), y: a.y + u * (b.y - a.y) };
+        const pl = points[p.parent]!.pl + u * L;
+        const cf = dist(f, g) + bf * pl;
+        if (cf < best - 1e-9) {
+          best = cf;
+          pick = t;
+          at = v;
+          foot = { point: f, pl };
+        }
+      }
+    }
+    left.delete(pick);
+    let from = at;
+    if (foot) {
+      // The foot splits the link from the parent of `at` to `at`.
+      points.push({ point: foot.point, parent: points[at]!.parent, pl: foot.pl, open: true });
+      from = points.length - 1;
+      points[at]!.parent = from;
+    }
+    const way = branch(points[from]!.point, pick);
+    let prev = from;
+    for (let i = 1; i < way.length; i++) {
+      const q = way[i]!;
+      const base = points[prev]!;
+      if (dist(q, base.point) <= 1e-9) continue;
+      points.push({ point: q, parent: prev, pl: base.pl + dist(base.point, q), open: i < way.length - 1 });
+      prev = points.length - 1;
+    }
+    leaf[pick] = prev;
+  }
+  return { points, leaf };
+}
+
+/** This function gives the points of the tree from the root to the point `i`. */
+export function fanPath(fan: Fan, i: number): Point[] {
+  const out: Point[] = [];
+  for (let j = i; j >= 0; j = fan.points[j]!.parent) out.push(fan.points[j]!.point);
+  return out.reverse();
+}

package/src/routers/index.ts

@@ -9,9 +9,9 @@ import { byCollection, trunksRouter } from "./trunks.ts";
 export { boxExit, straightRouter } from "./straight.ts";
 export { plugsRouter } from "./plugs.ts";
 export { cornersRouter, type CornersOptions } from "./corners.ts";
-export { sharedRouter, type SharedOptions } from "./shared.ts";
+export { sharedRouter, type ShareCost, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";
-export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunksOptions } from "./trunks.ts";
+export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunkFan, type TrunkSplit, type TrunksOptions } from "./trunks.ts";
 
 /** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 export const ROUTERS: readonly Router[] = [

package/src/routers/shared.ts

@@ -1,8 +1,19 @@
 import { center, dist, type Point } from "../geom.ts";
 import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
+import { buildSections, type Section } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
+import { snellMerges } from "./snell.ts";
+
+/** The cost of a link that edges of one key share: a fixed discount, or the flow cost `len * f^alpha` (EDA-029). */
+export type ShareCost = "fixed" | "flow";
+
+/** The order of the edges of one key: the longest first, the shortest first, the most load first, or the order of the input (NAT-024). */
+export type ShareOrder = "span" | "shortest" | "load" | "input";
+
+/** The place where a route joins or leaves a run: at a corner of the graph, or at the Snell angle (NAT-035). */
+export type ShareMerge = "corner" | "snell";
 
 /** The options of the router with shared ways. */
 export interface SharedOptions extends WayOptions {
@@ -14,11 +25,31 @@ export interface SharedOptions extends WayOptions {
   readonly discount?: number;
   /** The lane order of the runs. With `bundle`, the default, two edges keep one order on each run of their common stretch. With `run`, each run gets its order alone. */
   readonly laneOrder?: RunOrder;
+  /**
+   * The cost of a shared link. With `fixed`, the default, a link that the key uses already costs `discount` times its length.
+   * With `flow`, one more edge on a link with `f` edges costs `len * ((f + 1)^alpha - f^alpha)` (EDA-029).
+   */
+  readonly cost?: ShareCost;
+  /** The exponent of the flow cost, from 0.1 to 1. A smaller value gives more sharing. The default is 0.6. Only the cost `flow` uses it. */
+  readonly alpha?: number;
+  /** The number of passes. In each pass after the first, each edge leaves its links and finds its way again with the others fixed (HWY-039). The default is 1. */
+  readonly passes?: number;
+  /**
+   * The order of the edges of one key. With `span`, the default, the longest edge goes first. With `shortest`, the shortest edge goes first.
+   * With `load`, the edge with the most edges between its two sections goes first. With `input`, the edges keep the order of the graph (NAT-024).
+   */
+  readonly order?: ShareOrder;
+  /**
+   * The place where a route joins or leaves a run. With `corner`, the default, it is a corner of the graph.
+   * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
+   */
+  readonly merge?: ShareMerge;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
-interface Way {
+/** A way of one edge through the corner graph. */
+export interface Way {
   readonly edge: Edge;
   readonly key: string;
   readonly ps: Plug;
@@ -58,6 +89,11 @@ function turn(from: Point, base: Point, to: Point): number {
  */
 export function sharedRouter(options: SharedOptions): Router {
   const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
+  const flow = options.cost === "flow";
+  const alpha = Math.min(1, Math.max(0.1, options.alpha ?? 0.6));
+  // The cost share of a link for one more edge, when `f` edges of the key use it already. The share falls when `f` grows.
+  const share = (f: number): number => (f <= 0 ? 1 : flow ? (f + 1) ** alpha - f ** alpha : discount);
+  const passes = Math.max(1, Math.floor(options.passes ?? 1));
   const keyOf = (e: Edge): string => {
     if (!options.rule) return "*";
     return options.rule(e) ?? `\u0000${e.id}`;
@@ -90,17 +126,21 @@ export function sharedRouter(options: SharedOptions): Router {
         all.push({ edge: e, key: keyOf(e), ps, pt, seq: [], ids: [], found: false });
       }
 
-      // The edges of one key go one after the other, the longest first, so that the short edges join the long ways.
+      // The edges of one key go one after the other, by default the longest first, so that the short edges join the long ways.
       const discounted = new Map<string, Map<number, string[]>>();
-      const order = [...all].sort(
-        (p, q) => byText(p.key, q.key) || dist(q.ps.point, q.pt.point) - dist(p.ps.point, p.pt.point) || byText(p.edge.id, q.edge.id),
-      );
-      for (const w of order) {
+      const order = orderWays(all, options.order ?? "span", graph);
+      // The largest number of edges on one link of each key. The cost share of that number is the floor of the search.
+      const top = new Map<string, number>();
+      const route = (w: Way): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
-        const way = corners.path(ways.out(w.ps), ways.out(w.pt), (i, j, d) => (mine.has(link(i, j)) ? d * discount : d), discount);
-        if (!way) continue;
+        const floor = flow ? share(top.get(w.key) ?? 0) : discount;
+        const cost = flow
+          ? (i: number, j: number, d: number): number => d * share(mine.get(link(i, j))?.length ?? 0)
+          : (i: number, j: number, d: number): number => (mine.has(link(i, j)) ? d * discount : d);
+        const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
+        if (!way) return;
         w.found = true;
         w.seq = way;
         w.ids = way.map((p, i) => (i === 0 || i === way.length - 1 ? endId(p) : index.get(p)!));
@@ -111,7 +151,37 @@ export function sharedRouter(options: SharedOptions): Router {
           const list = mine.get(link(a, b));
           if (list) list.push(w.edge.id);
           else mine.set(link(a, b), [w.edge.id]);
+          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);
+      // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
+      for (let pass = 1; pass < passes; pass++) {
+        for (const w of order) {
+          if (!w.found) continue;
+          const mine = discounted.get(w.key)!;
+          for (let i = 1; i < w.ids.length; i++) {
+            const a = w.ids[i - 1]!;
+            const b = w.ids[i]!;
+            if (a >= corners.points.length || b >= corners.points.length) continue;
+            const k = link(a, b);
+            const list = mine.get(k);
+            if (!list) continue;
+            const at = list.indexOf(w.edge.id);
+            if (at >= 0) list.splice(at, 1);
+            if (list.length === 0) mine.delete(k);
+          }
+          w.found = false;
+          w.seq = [];
+          w.ids = [];
+          route(w);
+        }
+      }
+
+      // With `merge: snell`, each route that joins or leaves a run moves its merge point along the run to the Snell angle.
+      if (options.merge === "snell") {
+        const pad = ways.margin / 2;
+        snellMerges(order, corners.points.length + ends.size, (a, b) => ways.obstacles.clear(a, b, pad), (f) => Math.min(0.95, share(f)));
       }
 
       // The users of each link, with the links to the ends. Two edges from one plug share the link from it.
@@ -185,6 +255,35 @@ export function sharedRouter(options: SharedOptions): Router {
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
 
+/**
+ * This function gives the order of the ways for the router `shared`. The ways of one key stay together, in the order of the keys.
+ * In a key, the order is `order`, and the edge id breaks each tie. The order `load` counts the edges of the key between the same two sections.
+ */
+function orderWays(all: readonly Way[], order: ShareOrder, graph: Graph): Way[] {
+  const span = (w: Way): number => dist(w.ps.point, w.pt.point);
+  if (order === "input") {
+    const at = new Map(all.map((w, i) => [w, i]));
+    return [...all].sort((p, q) => byText(p.key, q.key) || at.get(p)! - at.get(q)!);
+  }
+  if (order === "shortest") return [...all].sort((p, q) => byText(p.key, q.key) || span(p) - span(q) || byText(p.edge.id, q.edge.id));
+  if (order === "span") return [...all].sort((p, q) => byText(p.key, q.key) || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+  // The leaf section of each node, then the number of edges of each key between each pair of leaves.
+  const leafOf = new Map<string, string>();
+  const walk = (s: Section): void => {
+    if (s.children.length === 0) for (const i of s.nodes) leafOf.set(graph.nodes[i]!.id, s.id);
+    for (const c of s.children) walk(c);
+  };
+  walk(buildSections(graph.nodes));
+  const pair = (w: Way): string => {
+    const a = leafOf.get(w.edge.source.node) ?? "";
+    const b = leafOf.get(w.edge.target.node) ?? "";
+    return `${w.key}\u0000${a < b ? a : b}\u0000${a < b ? b : a}`;
+  };
+  const load = new Map<string, number>();
+  for (const w of all) load.set(pair(w), (load.get(pair(w)) ?? 0) + 1);
+  return [...all].sort((p, q) => byText(p.key, q.key) || load.get(pair(q))! - load.get(pair(p))! || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+}
+
 /**
  * This function gives the lane order of a run with the option `laneOrder: "run"` (metro-line order). Two edges of the run go together past its last corner
  * until they part. The edge that turns more to the left there gets the lane more to the left.