@mark1russell7/highways 0.1.5 → 0.3.0

package/src/room/levels/index.ts

@@ -0,0 +1,155 @@
+import type { ItemPair } from "../../levels.ts";
+import type { LevelItem } from "../../model.ts";
+import { levelCut, treeDepth, type Section } from "../../sections.ts";
+import { boardGaps, openGaps, roomDemand, withBends, type Boxed, type Gap, type RoomLink, type RoomOptions } from "../index.ts";
+
+/**
+ * The boards of the zoom levels of `levelRoom`.
+ *
+ * - `shared`: each level uses the board of the nearest level. No box moves between two levels. A far level gets the area of the nearest level.
+ * - `each`: each level has its own board. A far level opens only the gaps of its own links, and a nearer level adds to them.
+ *   Thus the items of a far level are nearer together, but a box moves in its parent when the level changes.
+ */
+export type LevelBoard = "each" | "shared";
+
+/** The options of `levelRoom`: the options of `roomDemand` for each level, and the levels that get room. */
+export interface LevelRoomOptions extends RoomOptions {
+  /** The depths of the tree that get room for their links. The default is each depth from 1 to the depth of the deepest section. */
+  readonly depths?: readonly number[];
+  /** With `true`, the last level, with each node alone, also gets room for the links between the nodes. The default is `false`. */
+  readonly nodes?: boolean;
+  /** The board of each level. The default is `shared`. */
+  readonly board?: LevelBoard;
+}
+
+/** One zoom level of `levelRoom`: its items at their open places, its links and its demand. */
+export interface RoomLevel<T extends Boxed> {
+  readonly depth: number;
+  /** The items of the level, with the bounding box of their nodes at the places of this level. */
+  readonly items: LevelItem[];
+  /** The links between the items of the level. A link counts the links of the nodes between its two items. */
+  readonly pairs: ItemPair[];
+  /** The demand of the level on the board that it gets from the level before it. A level without room has no gaps. */
+  readonly gaps: Gap[];
+  /** The nodes at the places of this level. */
+  readonly nodes: T[];
+}
+
+/** The room of each zoom level, and the board of the nearest level. */
+export interface LevelRoom<T extends Boxed> {
+  /** The levels from depth 0 to the level with each node alone, in order. */
+  readonly levels: RoomLevel<T>[];
+  /** The gaps of the board of the nodes. `openGaps(nodes, gaps)` gives the nodes of the nearest level. */
+  readonly gaps: Gap[];
+  /** The nodes of the nearest level. */
+  readonly items: T[];
+}
+
+const DEFAULT_SNAP = 0.5;
+
+/**
+ * This function gives the links between the items of a level. Each pair of items gets one link, in the order of the first link of the pair.
+ * The count of a link is the sum of the counts of its node links. A link inside one item does not count.
+ */
+export function levelPairs(items: readonly LevelItem[], owner: readonly number[], indexOf: ReadonlyMap<string, number>, links: readonly RoomLink[]): ItemPair[] {
+  const byPair = new Map<string, { source: string; target: string; count: number }>();
+  for (const l of links) {
+    const iu = indexOf.get(l.source);
+    const iv = indexOf.get(l.target);
+    if (iu === undefined || iv === undefined) continue;
+    const a = owner[iu]!;
+    const b = owner[iv]!;
+    if (a === b) continue;
+    const key = a < b ? `${a} ${b}` : `${b} ${a}`;
+    const known = byPair.get(key);
+    if (known) known.count += l.count ?? 1;
+    else byPair.set(key, { source: items[a]!.id, target: items[b]!.id, count: l.count ?? 1 });
+  }
+  return [...byPair.values()];
+}
+
+/**
+ * This function gives the room of each zoom level of a tree of sections. The indices of the nodes of the tree are the indices of `nodes`.
+ * The far levels open first, and each nearer level keeps their growth.
+ *
+ * At each level, `roomDemand` measures the links of that level on the board of the level before it. Then the nodes move with `openGaps`.
+ * The nodes move by one monotone shift on each axis, so each level keeps the order and the alignment of the boxes.
+ * A nearer level only adds growth, so no gap of a far level gets narrower, and a box moves with its parent.
+ */
+export function levelRoom<T extends Boxed>(nodes: readonly T[], links: readonly RoomLink[], root: Section, options: LevelRoomOptions = {}): LevelRoom<T> {
+  const snap = options.snap ?? DEFAULT_SNAP;
+  const deepest = treeDepth(root);
+  const depths = new Set(options.depths ?? Array.from({ length: deepest }, (_, i) => i + 1));
+  if (options.nodes) depths.add(deepest + 1);
+  const indexOf = new Map(nodes.map((n, i) => [n.id, i]));
+  const levels: RoomLevel<T>[] = [];
+  let current: T[] = [...nodes];
+  // The edges of the bends join nodes, not the items of a level. So the bends get room on the board of the nodes, at the last level.
+  const { bends, ...room } = options;
+  for (let d = 0; d <= deepest + 1; d++) {
+    let gaps: Gap[] = [];
+    let cut = levelCut(current, root, d);
+    const pairs = levelPairs(cut.items, cut.owner, indexOf, links);
+    if (depths.has(d) && pairs.length > 0) {
+      gaps = roomDemand(cut.items, pairs, room);
+      // The shift of each gap applies to the nodes, so a node moves with its item, and the items of a far level stay apart.
+      if (gaps.some((g) => g.need > g.width)) {
+        current = openGaps(current, gaps, snap);
+        cut = levelCut(current, root, d);
+      }
+    }
+    if (bends && d === deepest + 1) {
+      const bent = withBends(current, links, boardGaps(current, snap), bends, snap);
+      if (bent.some((g) => g.need > g.width)) {
+        current = openGaps(current, bent, snap);
+        cut = levelCut(current, root, d);
+      }
+    }
+    levels.push({ depth: d, items: cut.items, pairs, gaps, nodes: current });
+  }
+  const shared = (options.board ?? "shared") === "shared";
+  const out = shared ? levels.map((l) => ({ ...l, items: levelCut(current, root, l.depth).items, nodes: current })) : levels;
+  return { levels: out, gaps: nodeGaps(nodes, current, levels, snap), items: current };
+}
+
+/**
+ * This function gives the gaps of the board of the nodes that move each node from `from` to `to`.
+ * The growth of a gap is the shift of the nodes after it, less the shift of the nodes before it. Its lanes are the most lanes of a level gap there.
+ */
+function nodeGaps<T extends Boxed>(from: readonly T[], to: readonly T[], levels: readonly RoomLevel<T>[], snap: number): Gap[] {
+  const indexOf = new Map(from.map((n, i) => [n.id, i]));
+  const gaps = boardGaps(from, snap);
+  const shift = (id: string, axis: "x" | "y"): number => {
+    const i = indexOf.get(id)!;
+    return to[i]!.box[axis] - from[i]!.box[axis];
+  };
+  // The lanes of each level gap go to the gap of the nodes at the left (or top) edge of its first item after it.
+  const lanes = new Map<number, number>();
+  const boundaryOf = new Map<string, number>();
+  gaps.forEach((g, k) => {
+    for (const id of g.after) boundaryOf.set(`${g.axis} ${id}`, k);
+  });
+  for (const level of levels) {
+    const byId = new Map(level.items.map((i) => [i.id, i]));
+    for (const g of level.gaps) {
+      if (g.lanes === 0) continue;
+      for (const id of g.after) {
+        const item = byId.get(id);
+        if (!item) continue;
+        // The first node of the item on the axis of the gap starts the item.
+        let first = item.nodes[0]!;
+        for (const n of item.nodes) if (from[indexOf.get(n)!]!.box[g.axis] < from[indexOf.get(first)!]!.box[g.axis]) first = n;
+        const k = boundaryOf.get(`${g.axis} ${first}`);
+        if (k !== undefined) lanes.set(k, Math.max(lanes.get(k) ?? 0, g.lanes));
+      }
+    }
+  }
+  const last: Record<"x" | "y", number> = { x: 0, y: 0 };
+  return gaps.map((g, k) => {
+    let s = Infinity;
+    for (const id of g.after) s = Math.min(s, shift(id, g.axis));
+    const growth = Math.max(0, s - last[g.axis]);
+    last[g.axis] = Math.max(last[g.axis], s);
+    return { ...g, lanes: lanes.get(k) ?? 0, need: g.width + growth };
+  });
+}

package/src/routers/sections.ts

@@ -1,14 +1,19 @@
 import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
-import { center, dist, pointSegmentDistance, polylineLength, type Box, type Point } from "../geom.ts";
-import { levelLinks, type ItemPair } from "../levels.ts";
-import { nodeIndex, type Graph, type Level, type LevelItem, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
+import { LEVEL_LINK_DEFAULTS, levelLinks, type ItemPair, type LevelLinkOptions } from "../levels.ts";
+import { nodeIndex, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
-import { allSections, buildSections, treeDepth, type Section, type SectionOptions } from "../sections.ts";
-import { orderLanes } from "../segments.ts";
-import { WayFinder, type WayOptions } from "../ways.ts";
+import { allSections, buildSections, checkSections, levelCut, SECTION_DEFAULTS, treeDepth, type Section, type SectionOptions } from "../sections.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
+import type { Strategy } from "../strategies/model.ts";
+import { WayFinder } from "../ways.ts";
 
-/** The options of the router with sections. */
-export interface SectionsOptions extends WayOptions, SectionOptions {
+/**
+ * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
+ * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
+ * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
+ */
+export interface SectionsOptions extends LevelLinkOptions, SectionOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /**
@@ -16,19 +21,52 @@ export interface SectionsOptions extends WayOptions, SectionOptions {
    * and fewer shared ways. Without it, a way passes each hub from its node up.
    */
   readonly hubs?: number;
-  /** A way through the hubs can be at most this many times as long as the line between its plugs. Else the edge goes directly. The default is 2. */
+  /**
+   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
+   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
+   */
   readonly stretch?: number;
+  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
+  readonly stretchPad?: number;
+  /**
+   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
+   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   */
+  readonly hubSlack?: number;
+  /**
+   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
+   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   */
+  readonly group?: Strategy<"group">;
+  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly groupOptions?: object;
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+  /** The lane order of the runs. With `run`, the default, each run gets its order alone. With `bundle`, two edges keep one order on each run of their common stretch. */
+  readonly laneOrder?: RunOrder;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
-const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
+/** The default values of the numbers of `SectionsOptions`: the limits of the hubs, of the tree and of the level links. */
+export const SECTIONS_DEFAULTS: Readonly<Required<Pick<SectionsOptions, "cap" | "maxDepth" | "collapse" | "tightMargin" | "plugInset" | "throughCost" | "hubs" | "stretch" | "stretchPad" | "hubSlack">>> =
+  Object.freeze({
+    cap: SECTION_DEFAULTS.cap,
+    maxDepth: SECTION_DEFAULTS.maxDepth,
+    collapse: SECTION_DEFAULTS.collapse,
+    tightMargin: LEVEL_LINK_DEFAULTS.tightMargin,
+    plugInset: LEVEL_LINK_DEFAULTS.plugInset,
+    throughCost: LEVEL_LINK_DEFAULTS.throughCost,
+    hubs: Infinity,
+    stretch: 2,
+    stretchPad: 4,
+    hubSlack: 2 * BACKTRACK_MIN,
+  });
 
-/**
- * A hub can be this many units farther from the target than the nearest approach of the way before it.
- * A hub farther away goes out and back, so the way skips it.
- */
-const HUB_SLACK = 2 * BACKTRACK_MIN;
+const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
 
 /**
  * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
@@ -45,12 +83,14 @@ export function sectionsRouter(options: SectionsOptions): Router {
   const router: Router = {
     name: options.name,
     route(graph: Graph): Result {
-      const stretch = options.stretch ?? 2;
+      const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
+      const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
+      const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;
       const byId = nodeIndex(graph);
       const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
       const ways = new WayFinder(graph.nodes, options);
       const corners = ways.corners;
-      const root = buildSections(graph.nodes, options);
+      const root = groupNodes(graph, options);
       const parent = new Map<Section, Section>();
       const leafOf: Section[] = [];
       for (const s of allSections(root)) {
@@ -82,7 +122,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         let last = from;
         for (const c of list) {
           const h = hub(c);
-          if (dist(h, to) > near + HUB_SLACK) continue;
+          if (dist(h, to) > near + hubSlack) continue;
           near = Math.min(near, pointSegmentDistance(to, last, h));
           last = h;
           kept.push(c);
@@ -132,7 +172,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         const b = up(lv);
         const common = new Set(b);
         const lca = a.find((x) => common.has(x))!;
-        const keep = options.hubs ?? Infinity;
+        const keep = options.hubs ?? SECTIONS_DEFAULTS.hubs;
         const side = (list: Section[]): Section[] => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
         const end = ways.out(pt);
         const start = ways.out(ps);
@@ -151,7 +191,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         append(piece(chain[chain.length - 1]!.id, hub(chain[chain.length - 1]!), at(end), end, used));
         append([pt.point]);
         // A way through the hubs that is too long, or that goes out and back, gives way to the direct way.
-        if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin || goesOutAndBack(out)) {
+        if (polylineLength(out) > stretch * dist(ps.point, pt.point) + stretchPad * ways.margin || goesOutAndBack(out)) {
           routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
           continue;
         }
@@ -168,7 +208,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
       for (const [key, p] of pieces) {
         const list = users.get(key) ?? [];
         if (list.length < 2 || p.length < 2) continue;
-        runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!)) });
+        runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!), options.laneOrder) });
       }
       return { routes, runs, levels: makeLevels(graph, root, routeOf, options) };
     },
@@ -176,56 +216,39 @@ export function sectionsRouter(options: SectionsOptions): Router {
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
 
+/** This function gives the tree of sections of the grouping rule. It examines the tree of a strategy (`checkSections`). */
+function groupNodes(graph: Graph, options: SectionsOptions): Section {
+  if (!options.group) return buildSections(graph.nodes, options);
+  const root = options.group.run(graph, options.groupOptions);
+  checkSections(root, graph.nodes.length);
+  return root;
+}
+
 /**
  * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
+ * With the option `levels`, only those depths get a level with groups.
  * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
  * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
  * In the last level, the points of a link are the route of its first edge.
  */
-function makeLevels(graph: Graph, root: Section, routeOf: ReadonlyMap<string, Route>, options: WayOptions): Level[] {
+function makeLevels(graph: Graph, root: Section, routeOf: ReadonlyMap<string, Route>, options: SectionsOptions): Level[] {
   const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
   const levels: Level[] = [];
   const deepest = treeDepth(root);
+  const shown = options.levels && new Set(options.levels);
   for (let d = 0; d <= deepest + 1; d++) {
-    const items: LevelItem[] = [];
-    const itemOf: (Section | number)[] = [];
-    const boxOf = (list: readonly number[]): Box => {
-      let x0 = Infinity;
-      let y0 = Infinity;
-      let x1 = -Infinity;
-      let y1 = -Infinity;
-      for (const i of list) {
-        const b = graph.nodes[i]!.box;
-        x0 = Math.min(x0, b.x);
-        y0 = Math.min(y0, b.y);
-        x1 = Math.max(x1, b.x + b.w);
-        y1 = Math.max(y1, b.y + b.h);
-      }
-      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
-    };
-    const visit = (s: Section): void => {
-      if (s.depth >= d) {
-        items.push({ id: s.id, box: boxOf(s.nodes), nodes: s.nodes.map((i) => graph.nodes[i]!.id) });
-        for (const i of s.nodes) itemOf[i] = s;
-      } else if (s.children.length > 0) for (const c of s.children) visit(c);
-      else
-        for (const i of s.nodes) {
-          const n = graph.nodes[i]!;
-          items.push({ id: n.id, box: n.box, nodes: [n.id] });
-          itemOf[i] = i;
-        }
-    };
-    if (graph.nodes.length > 0) visit(root);
+    if (shown && d <= deepest && !shown.has(d)) continue;
+    const { items, owner } = levelCut(graph.nodes, root, d);
     const links = new Map<string, { source: string; target: string; count: number; edge: string }>();
     for (const e of graph.edges) {
       const iu = indexOfNode.get(e.source.node);
       const iv = indexOfNode.get(e.target.node);
       if (iu === undefined || iv === undefined) continue;
-      const a = itemOf[iu]!;
-      const b = itemOf[iv]!;
+      const a = owner[iu]!;
+      const b = owner[iv]!;
       if (a === b) continue;
-      const ida = typeof a === "number" ? graph.nodes[a]!.id : a.id;
-      const idb = typeof b === "number" ? graph.nodes[b]!.id : b.id;
+      const ida = items[a]!.id;
+      const idb = items[b]!.id;
       const key = `${ida}\u0000${idb}`;
       const link = links.get(key);
       if (link) {

package/src/routers/shared.ts

@@ -1,6 +1,7 @@
 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 { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
 /** The options of the router with shared ways. */
@@ -11,6 +12,8 @@ export interface SharedOptions extends WayOptions {
   readonly rule?: GroupRule;
   /** The cost of a link that an edge with the same key uses already, as a share of its length. The default is 0.5. */
   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 benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -171,8 +174,10 @@ export function sharedRouter(options: SharedOptions): Router {
       const routes: Route[] = [];
       for (const w of all) routes.push({ edge: w.edge.id, points: points.get(w.edge.id) ?? [w.ps.point, w.pt.point] });
       const shared: SharedRun[] = [];
+      const routeOf = new Map(routes.map((r) => [r.edge, r]));
       for (const run of runs.values()) {
-        shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges: laneOrderOfRun(run) });
+        const edges = options.laneOrder === "run" ? laneOrderOfRun(run) : orderLanes(run.points, run.ways.map((w) => routeOf.get(w.edge.id)!), "bundle");
+        shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges });
       }
       return { routes, runs: shared };
     },
@@ -181,7 +186,7 @@ export function sharedRouter(options: SharedOptions): Router {
 }
 
 /**
- * This function gives the lane order of a run (metro-line order). Two edges of the run go together past its last corner
+ * 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.
  * Two edges can part only before the first corner. Then the edge that comes from more to the left gets the lane more to the left.
  */

package/src/routers/trunks.ts

@@ -1,6 +1,7 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
 /** The options of the trunk router. */
@@ -13,10 +14,20 @@ export interface TrunksOptions extends WayOptions {
   readonly split?: number;
   /** A group with fewer edges stays unbundled. The default is 2. */
   readonly minSize?: number;
+  /** The lane order of a trunk. With `bundle`, the default, the branches part in lane order. With `run`, the first leg of each branch tells the order. */
+  readonly laneOrder?: RunOrder;
+  /**
+   * The place where each lane leaves the trunk. With `part`, the default, a lane leaves where its way parts from the ways of the other lanes.
+   * A lane that turns back over the trunk leaves at an earlier point of the trunk. With `split`, each lane leaves at the split point, as in version 0.2.0.
+   */
+  readonly leave?: TrunkLeave;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
+/** The place where the lanes of a trunk leave it: where their ways part, or at the split point. */
+export type TrunkLeave = "part" | "split";
+
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 export const byCollection: GroupRule = (e) => {
   const c = e.data?.["collection"];
@@ -74,6 +85,83 @@ export function splitPoint(start: Point, targets: readonly Point[], split: numbe
 
 const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
 
+/** The place where a branch leaves its trunk. */
+export interface TrunkExit {
+  /** The place along the trunk: the index of a point of the trunk, plus the share of the next leg. Point `i` of the trunk is at `i`. */
+  readonly at: number;
+  /** The point where the branch leaves the trunk. */
+  readonly point: Point;
+  /** The branch past `point`, to the plug of the target. */
+  readonly rest: readonly Point[];
+}
+
+/**
+ * This function gives the place where a branch leaves its trunk. The branch starts at the last point of the trunk and ends at the plug of the target.
+ *
+ * A branch that turns back over the trunk, by more than 90 degrees, leaves at the point of the trunk before.
+ * It does so when it goes back along the trunk to that point. It also does so when `clear` tells that the line from that point is free.
+ * The first two legs of the trunk stay. When the branch still turns back, it leaves the last leg at the foot of its next point, if the line from there is free.
+ * Each step makes the route shorter or keeps its length.
+ *
+ * The function gives `undefined` when the foot on the second leg of the trunk is less than `min` past the start of that leg.
+ * Then the target is behind or beside the plug, and the edge does not go well in the bundle.
+ */
+export function leaveTrunk(trunk: readonly Point[], branch: readonly Point[], clear: (a: Point, b: Point) => boolean, min = 0): TrunkExit | undefined {
+  const back = (a: Point, b: Point, q: Point): boolean => (b.x - a.x) * (q.x - b.x) + (b.y - a.y) * (q.y - b.y) < 0;
+  let at = trunk.length - 1;
+  let rest = branch.slice(1);
+  while (at >= 3 && rest.length >= 2) {
+    const a = trunk[at - 1]!;
+    if (!back(a, trunk[at]!, rest[0]!)) break;
+    const next = dist(rest[0]!, a) <= 1e-9 ? rest.slice(1) : rest;
+    if (next === rest && !clear(a, rest[0]!)) break;
+    rest = next;
+    at -= 1;
+  }
+  const exit: TrunkExit = { at, point: trunk[at]!, rest };
+  if (at < 1 || rest.length < 2 || !back(trunk[at - 1]!, trunk[at]!, rest[0]!)) return exit;
+  const a = trunk[at - 1]!;
+  const b = trunk[at]!;
+  const q = rest[0]!;
+  const u = ((q.x - a.x) * (b.x - a.x) + (q.y - a.y) * (b.y - a.y)) / ((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  if (at <= 2 ? u * Math.hypot(b.x - a.x, b.y - a.y) < min : u <= 0) return at <= 2 ? undefined : exit;
+  const foot = { x: a.x + u * (b.x - a.x), y: a.y + u * (b.y - a.y) };
+  return at >= 2 && clear(foot, q) ? { at: at - 1 + u, point: foot, rest } : exit;
+}
+
+/** This function gives the number of points at the start of each route that all the routes share. */
+function commonStart(routes: readonly Route[], from: number): number {
+  const first = routes[0]!.points;
+  let n = from;
+  while (n < first.length && routes.every((r) => n < r.points.length && dist(r.points[n]!, first[n]!) <= 1e-9)) n++;
+  return n;
+}
+
+/**
+ * This function gives the shared ways of the routes of one bundle past the trunk. The routes share their first `from` points.
+ * At the last of these points, the routes part. The routes that go on to one next point share a way to the point where they part again.
+ * Each shared way has two edges or more, in the order of the routes.
+ */
+export function sharedWays(routes: readonly Route[], from: number): { points: Point[]; edges: string[] }[] {
+  const out: { points: Point[]; edges: string[] }[] = [];
+  const next = new Map<string, Route[]>();
+  for (const r of routes) {
+    const q = r.points[from];
+    if (!q) continue;
+    const key = `${q.x},${q.y}`;
+    const list = next.get(key);
+    if (list) list.push(r);
+    else next.set(key, [r]);
+  }
+  for (const list of next.values()) {
+    if (list.length < 2) continue;
+    const end = commonStart(list, from);
+    out.push({ points: list[0]!.points.slice(from - 1, end), edges: list.map((r) => r.edge) });
+    out.push(...sharedWays(list, end));
+  }
+  return out;
+}
+
 /**
  * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
  * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
@@ -85,8 +173,12 @@ export function trunksRouter(options: TrunksOptions): Router {
     route(graph: Graph): Result {
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
-      const points = new Map<string, Point[]>();
+      const points = new Map<string, readonly Point[]>();
       const bundles: Bundle[] = [];
+      const runs: SharedRun[] = [];
+      const part = (options.leave ?? "part") === "part";
+      // A branch leaves the trunk early only on a line that keeps out of the boxes as far as the corner graph does.
+      const clear = (a: Point, b: Point): boolean => ways.obstacles.clear(a, b, ways.margin / 2);
       for (const [id, group] of groupEdges(graph.edges, options.rule, options.minSize ?? 2)) {
         const first = group[0]!;
         const s = byId.get(first.source.node);
@@ -105,13 +197,46 @@ export function trunksRouter(options: TrunksOptions): Router {
         const len = dist(prev, end);
         const dir = len > 0 ? { x: (end.x - prev.x) / len, y: (end.y - prev.y) / len } : plug.normal;
         const branches: { edge: string; next: Point }[] = [];
+        const own: Route[] = [];
+        const exits: { edge: string; exit: TrunkExit }[] = [];
         group.forEach((e, i) => {
           const pt = placePlug(targets[i]!, e.target, end);
           const branch = dedupe(ways.toPlug(end, pt) ?? [end, pt.point]);
-          points.set(e.id, dedupe([...trunk, ...branch.slice(1)]));
-          branches.push({ edge: e.id, next: branch[1] ?? pt.point });
+          if (!part) {
+            own.push({ edge: e.id, points: dedupe([...trunk, ...branch.slice(1)]) });
+            branches.push({ edge: e.id, next: branch[1] ?? pt.point });
+            return;
+          }
+          // An edge whose target is behind the plug goes alone, as an edge outside the groups.
+          const exit = leaveTrunk(trunk, branch, clear, 2 * ways.margin);
+          if (exit) exits.push({ edge: e.id, exit });
         });
-        bundles.push({ id: `b${bundles.length}`, key: id.split("\u0000")[2]!, node: s.id, edges: laneOrder(dir, end, branches), trunk });
+        const key = id.split("\u0000")[2]!;
+        if (!part) {
+          for (const r of own) points.set(r.edge, r.points);
+          const edges = options.laneOrder === "run" || trunk.length < 2 ? laneOrder(dir, end, branches) : orderLanes(trunk, own, "bundle");
+          bundles.push({ id: `b${bundles.length}`, key, node: s.id, edges, trunk });
+          continue;
+        }
+        // A group that keeps fewer than `minSize` edges stays unbundled.
+        if (exits.length < (options.minSize ?? 2)) continue;
+        // The trunk gets a point at each place where a branch leaves it. Thus each route holds the points of the trunk up to its exit.
+        const stops = new Map<number, Point>(trunk.map((p, i) => [i, p]));
+        for (const { exit } of exits) if (!stops.has(exit.at)) stops.set(exit.at, exit.point);
+        const line = [...stops].sort((x, y) => x[0] - y[0]);
+        for (const { edge, exit } of exits) {
+          const p = dedupe([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
+          points.set(edge, p);
+          own.push({ edge, points: p });
+        }
+        // The bundle keeps the points that all the routes share. Past them, the routes that go on together share a run.
+        const order = options.laneOrder ?? "bundle";
+        const common = own[0]!.points.slice(0, commonStart(own, 0));
+        bundles.push({ id: `b${bundles.length}`, key, node: s.id, edges: orderLanes(common, own, order), trunk: common });
+        for (const way of sharedWays(own, common.length)) {
+          const users = own.filter((r) => way.edges.includes(r.edge));
+          runs.push({ id: `r${runs.length}`, key, points: way.points, edges: orderLanes(way.points, users, order) });
+        }
       }
       const routes: Route[] = [];
       for (const e of graph.edges) {
@@ -127,7 +252,7 @@ export function trunksRouter(options: TrunksOptions): Router {
         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, bundles };
+      return runs.length > 0 ? { routes, bundles, runs } : { routes, bundles };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };