@mark1russell7/highways 0.4.0 → 0.4.1

package/src/repair/walk.ts

@@ -0,0 +1,220 @@
+import { TOLERANCE } from "../bench/properties.ts";
+import { dist, inflate, segmentHitsBox, type Box, type Point } from "../geom.ts";
+import type { Grid } from "../grid.ts";
+import type { Node } from "../model.ts";
+import { nearestSide } from "../plugs.ts";
+
+/** The sides of a box, as the indexes of two corners: north, east, south and west. */
+const SIDES: readonly (readonly [number, number])[] = [
+  [0, 1],
+  [1, 2],
+  [3, 2],
+  [0, 3],
+];
+const SIDE_INDEX = { north: 0, east: 1, south: 2, west: 3 } as const;
+
+/** This function gives the four corners of a box: top left, top right, bottom right and bottom left. */
+function corners(b: Box): Point[] {
+  return [
+    { x: b.x, y: b.y },
+    { x: b.x + b.w, y: b.y },
+    { x: b.x + b.w, y: b.y + b.h },
+    { x: b.x, y: b.y + b.h },
+  ];
+}
+
+const EPS = 1e-6;
+const keyOf = (p: Point): string => `${Math.round(p.x * 1000)},${Math.round(p.y * 1000)}`;
+
+/** This function tells if the point `c` is on the axis-parallel segment `pq`. */
+function onSide(c: Point, p: Point, q: Point): boolean {
+  if (Math.abs(p.y - q.y) <= EPS) return Math.abs(c.y - p.y) <= EPS && c.x >= Math.min(p.x, q.x) - EPS && c.x <= Math.max(p.x, q.x) + EPS;
+  return Math.abs(c.x - p.x) <= EPS && c.y >= Math.min(p.y, q.y) - EPS && c.y <= Math.max(p.y, q.y) + EPS;
+}
+
+/** This function drops each point that is on the straight line between the point before it and the point after it. */
+function straighten(p: readonly Point[]): Point[] {
+  const out: Point[] = [];
+  for (const v of p) {
+    if (out.length > 0 && dist(out[out.length - 1]!, v) <= EPS) continue;
+    while (out.length >= 2) {
+      const a = out[out.length - 2]!;
+      const b = out[out.length - 1]!;
+      const cross = (b.x - a.x) * (v.y - b.y) - (b.y - a.y) * (v.x - b.x);
+      const dot = (b.x - a.x) * (v.x - b.x) + (b.y - a.y) * (v.y - b.y);
+      if (Math.abs(cross) > EPS || dot < 0) break;
+      out.pop();
+    }
+    out.push(v);
+  }
+  return out;
+}
+
+/**
+ * The boundary walk of the repair step (RULE-046): a graph of the sides of the boxes.
+ * The vertices are the corners of the boxes. The edges are the parts of each side between two corners on it.
+ * A walk on this graph goes along the boundaries of the boxes, and not through a box. Thus it joins two boxes also when the boxes touch.
+ * The graph drops each part of a side that goes through another box, so overlapping boxes do not open a way.
+ */
+export class BoundaryWalk {
+  readonly #points: Point[] = [];
+  readonly #index = new Map<string, number>();
+  readonly #next: { readonly to: number; readonly d: number }[][] = [];
+  /** The vertices on each side of each node, in the order along the side. */
+  readonly #sides = new Map<Node, number[][]>();
+
+  /** This constructor makes the graph of the sides of the nodes. `grid` holds the nodes by their boxes. */
+  constructor(nodes: readonly Node[], grid: Grid<Node>) {
+    for (const n of nodes) for (const c of corners(n.box)) this.#vertex(c);
+    for (const n of nodes) {
+      const cs = corners(n.box);
+      const lists: number[][] = [];
+      for (const [i, j] of SIDES) {
+        const p = cs[i]!;
+        const q = cs[j]!;
+        const on = new Set<number>([this.#vertex(p), this.#vertex(q)]);
+        const area = { x: Math.min(p.x, q.x) - 1, y: Math.min(p.y, q.y) - 1, w: Math.abs(q.x - p.x) + 2, h: Math.abs(q.y - p.y) + 2 };
+        grid.query(area, (m) => {
+          for (const c of corners(m.box)) if (onSide(c, p, q)) on.add(this.#vertex(c));
+        });
+        const list = [...on].sort((u, v) => dist(p, this.#points[u]!) - dist(p, this.#points[v]!) || u - v);
+        lists.push(list);
+        for (let k = 1; k < list.length; k++) {
+          const u = list[k - 1]!;
+          const v = list[k]!;
+          const a = this.#points[u]!;
+          const b = this.#points[v]!;
+          if (dist(a, b) <= EPS || this.#blocked(grid, a, b)) continue;
+          this.#link(u, v);
+        }
+      }
+      this.#sides.set(n, lists);
+    }
+  }
+
+  /** This method gives the index of the vertex at the point, and adds the vertex if it is new. */
+  #vertex(p: Point): number {
+    const k = keyOf(p);
+    let i = this.#index.get(k);
+    if (i === undefined) {
+      i = this.#points.length;
+      this.#points.push(p);
+      this.#next.push([]);
+      this.#index.set(k, i);
+    }
+    return i;
+  }
+
+  #link(u: number, v: number): void {
+    const d = dist(this.#points[u]!, this.#points[v]!);
+    if (this.#next[u]!.some((e) => e.to === v)) return;
+    this.#next[u]!.push({ to: v, d });
+    this.#next[v]!.push({ to: u, d });
+  }
+
+  /** This method tells if the segment goes through a box, as the rule `no-pass-through` tests it. */
+  #blocked(grid: Grid<Node>, a: Point, b: Point): boolean {
+    return grid.someSegment(a, b, 0, (n) => segmentHitsBox(a, b, inflate(n.box, -TOLERANCE)));
+  }
+
+  /** This method finds the side of `node` that is nearest to `p`. It gives the two vertices of that side that are next to `p`. */
+  #around(node: Node, p: Point): number[] {
+    const list = this.#sides.get(node)?.[SIDE_INDEX[nearestSide(node.box, p)]];
+    if (!list || list.length === 0) return [];
+    const from = this.#points[list[0]!]!;
+    const at = dist(from, p);
+    let k = 0;
+    while (k < list.length && dist(from, this.#points[list[k]!]!) < at) k++;
+    return [list[k - 1], list[k]].filter((v): v is number => v !== undefined);
+  }
+
+  /**
+   * This method gives a way along the boundaries of the boxes. The way goes from the point `a` on the box of `s` to the point `b` on the box of `t`.
+   * A point that is not on its box goes first to the nearest point of the boundary.
+   * The method gives `undefined` when no way joins the two boxes.
+   */
+  path(a: Point, s: Node, b: Point, t: Node): Point[] | undefined {
+    const a1 = nearestOnBoundary(s.box, a);
+    const b1 = nearestOnBoundary(t.box, b);
+    const n = this.#points.length;
+    const src = n;
+    const dst = n + 1;
+    const extra = new Map<number, { readonly to: number; readonly d: number }[]>();
+    const add = (u: number, v: number, d: number): void => {
+      if (!extra.has(u)) extra.set(u, []);
+      extra.get(u)!.push({ to: v, d });
+    };
+    for (const v of this.#around(s, a1)) add(src, v, dist(a1, this.#points[v]!));
+    for (const v of this.#around(t, b1)) add(v, dst, dist(b1, this.#points[v]!));
+    if (!extra.has(src)) return undefined;
+    const pointOf = (i: number): Point => (i === src ? a1 : i === dst ? b1 : this.#points[i]!);
+    const best = new Float64Array(n + 2).fill(Infinity);
+    const prev = new Int32Array(n + 2).fill(-1);
+    best[src] = 0;
+    const heap: [number, number][] = [[0, src]];
+    const less = (x: [number, number], y: [number, number]): boolean => x[0] < y[0] || (x[0] === y[0] && x[1] < y[1]);
+    const pop = (): [number, number] => {
+      const top = heap[0]!;
+      const last = heap.pop()!;
+      if (heap.length > 0) {
+        heap[0] = last;
+        let i = 0;
+        for (;;) {
+          const l = 2 * i + 1;
+          const r = l + 1;
+          let m = i;
+          if (l < heap.length && less(heap[l]!, heap[m]!)) m = l;
+          if (r < heap.length && less(heap[r]!, heap[m]!)) m = r;
+          if (m === i) break;
+          [heap[i], heap[m]] = [heap[m]!, heap[i]!];
+          i = m;
+        }
+      }
+      return top;
+    };
+    const push = (x: [number, number]): void => {
+      heap.push(x);
+      let i = heap.length - 1;
+      while (i > 0) {
+        const p = (i - 1) >> 1;
+        if (!less(heap[i]!, heap[p]!)) break;
+        [heap[i], heap[p]] = [heap[p]!, heap[i]!];
+        i = p;
+      }
+    };
+    while (heap.length > 0) {
+      const [d, u] = pop();
+      if (d > best[u]!) continue;
+      if (u === dst) break;
+      const edges = [...(u < n ? this.#next[u]! : []), ...(extra.get(u) ?? [])];
+      for (const e of edges) {
+        const nd = d + e.d;
+        if (nd < best[e.to]!) {
+          best[e.to] = nd;
+          prev[e.to] = u;
+          push([nd, e.to]);
+        }
+      }
+    }
+    if (prev[dst] === -1) return undefined;
+    const way: Point[] = [];
+    for (let i = dst; i !== -1; i = prev[i]!) way.push(pointOf(i));
+    way.reverse();
+    return straighten([a, ...way, b]);
+  }
+}
+
+/** This function gives the point of the boundary of the box that is nearest to `p`. A point on the boundary gives itself. */
+export function nearestOnBoundary(box: Box, p: Point): Point {
+  const x0 = box.x;
+  const y0 = box.y;
+  const x1 = box.x + box.w;
+  const y1 = box.y + box.h;
+  const inside = p.x > x0 && p.x < x1 && p.y > y0 && p.y < y1;
+  if (!inside) return { x: Math.min(x1, Math.max(x0, p.x)), y: Math.min(y1, Math.max(y0, p.y)) };
+  const side = nearestSide(box, p);
+  if (side === "north") return { x: p.x, y: y0 };
+  if (side === "south") return { x: p.x, y: y1 };
+  if (side === "west") return { x: x0, y: p.y };
+  return { x: x1, y: p.y };
+}

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[] = [