@mark1russell7/highways 0.8.0 → 0.9.0

package/src/routers/corners.ts

@@ -3,6 +3,7 @@ import { nodeIndex, type Edge, type Graph, type Node, type Result, type Route, t
 import { placePlug, type Plug } from "../plugs.ts";
 import { justifyPlugs } from "../plugs/justify.ts";
 import { sidePlugs } from "../plugs/side.ts";
+import type { PlugPair, Strategy } from "../strategies/model.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
 /** The ways to place a free plug of the corner router. */
@@ -24,6 +25,13 @@ export interface CornersOptions extends WayOptions {
    * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
    */
   readonly plugGap?: number;
+  /**
+   * The plug rule: a strategy of the step `plugs` that places the plugs of each edge. It takes the place of the option `plugs`.
+   * Without it, the router places the plugs with the option `plugs`. An edge without plugs from the strategy gets the plugs of `facing`.
+   */
+  readonly plug?: Strategy<"plugs">;
+  /** The options of the strategy `plug`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly plugOptions?: object;
 }
 
 /**
@@ -38,7 +46,7 @@ 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)) {
+      if (!options.plug && (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);
@@ -51,12 +59,17 @@ export function cornersRouter(options: CornersOptions): Router {
       }
       // 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][] = [];
+      const placed = options.plug ? plugsByEdge(options.plug.run({ graph, ways }, options.plugOptions)) : undefined;
       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, 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))];
+        const own = placed?.get(e.id)?.shift();
+        const [ps, pt]: [Plug, Plug] = own
+          ? [own.source, own.target]
+          : options.plugs === "side" && !placed
+            ? 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!);
@@ -67,6 +80,17 @@ export function cornersRouter(options: CornersOptions): Router {
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
 
+/** This function gives the plugs of a plug strategy by the edge id. Two edges with one id take the entries of that id in order. */
+function plugsByEdge(list: readonly PlugPair[]): Map<string, PlugPair[]> {
+  const out = new Map<string, PlugPair[]>();
+  for (const p of list) {
+    const own = out.get(p.edge);
+    if (own) own.push(p);
+    else out.set(p.edge, [p]);
+  }
+  return out;
+}
+
 /**
  * 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.

package/src/routers/sections.ts

@@ -1,9 +1,10 @@
 import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
 import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
-import { LEVEL_LINK_DEFAULTS, levelLinks, type ItemPair, type LevelLinkOptions } from "../levels.ts";
+import { LEVEL_LINK_DEFAULTS, type LevelLinkOptions } from "../levels.ts";
+import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.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, checkSections, levelCut, SECTION_DEFAULTS, treeDepth, type Section, type SectionOptions } from "../sections.ts";
+import { allSections, buildSections, checkSections, SECTION_DEFAULTS, 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";
@@ -45,6 +46,14 @@ export interface SectionsOptions extends LevelLinkOptions, SectionOptions {
    * The default is each depth, from 0 to the depth of the deepest section.
    */
   readonly levels?: readonly number[];
+  /**
+   * The level rule: a strategy of the step `levels` that makes the zoom levels from the tree and the routes.
+   * Without it, the router uses the strategy `depths` (`depthLevels`). The strategy gets the options `levels`, `margin`, `k`, `tightMargin`, `plugInset` and `throughCost` of the router,
+   * and then `levelOptions`.
+   */
+  readonly level?: Strategy<"levels">;
+  /** The options of the strategy `level`. They go over the level options of the router. */
+  readonly levelOptions?: object;
   /** 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. */
@@ -210,7 +219,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         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)!), options.laneOrder) });
       }
-      return { routes, runs, levels: makeLevels(graph, root, routeOf, options) };
+      return { routes, runs, levels: makeLevels(graph, root, routes, options) };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
@@ -224,43 +233,16 @@ function groupNodes(graph: Graph, options: SectionsOptions): Section {
   return root;
 }
 
+/** The keys of the router options that the level rule gets. */
+const LEVEL_KEYS = ["levels", "margin", "k", "tightMargin", "plugInset", "throughCost"] as const;
+
 /**
- * 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.
+ * This function gives the zoom levels of the router: the levels of the strategy `level`, or else the levels of `depthLevels`.
+ * The strategy gets the level options of the router that have a value, and then `levelOptions`.
  */
-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++) {
-    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 = owner[iu]!;
-      const b = owner[iv]!;
-      if (a === b) continue;
-      const ida = items[a]!.id;
-      const idb = items[b]!.id;
-      const key = `${ida}\u0000${idb}`;
-      const link = links.get(key);
-      if (link) {
-        link.count++;
-        continue;
-      }
-      links.set(key, { source: ida, target: idb, count: 1, edge: e.id });
-    }
-    const pairs: ItemPair[] = [...links.values()].map(({ source, target, count }) => ({ source, target, count }));
-    if (d > deepest)
-      levels.push({ depth: d, items, links: [...links.values()].map(({ edge, ...l }) => ({ ...l, points: routeOf.get(edge)?.points ?? [] })) });
-    else levels.push({ depth: d, items, links: levelLinks(items, pairs, options) });
-  }
-  return levels;
+function makeLevels(graph: Graph, root: Section, routes: readonly Route[], options: SectionsOptions): Level[] {
+  if (!options.level) return depthLevels({ graph, root, routes }, options);
+  const own: Record<string, unknown> = {};
+  for (const key of LEVEL_KEYS) if (options[key] !== undefined) own[key] = options[key];
+  return options.level.run({ graph, root, routes }, { ...(own as DepthLevelOptions), ...options.levelOptions });
 }

package/src/routers/shared.ts

@@ -2,12 +2,14 @@ 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 { channelWidth } from "../channels.ts";
 import { orderRun } from "../lane-order.ts";
+import { stretchLaneOrders, type LaneStretchOrder } from "../lane-orders/stretch/index.ts";
 import { byText } from "../compare.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";
+import { groupRuleOf, type GroupRuleName } from "./trunks.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";
@@ -22,12 +24,22 @@ export type ShareMerge = "corner" | "snell";
 export interface SharedOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
-  /** The edges with one key share their ways. Without a rule, all edges share. An edge without a key shares with no edge. */
-  readonly rule?: GroupRule;
+  /**
+   * The edges with one key share their ways. The option takes a rule or the name of a built-in rule (`GROUP_RULE_NAMES`).
+   * Without a rule, or with `all`, all edges share. An edge without a key shares with no edge.
+   */
+  readonly rule?: GroupRule | GroupRuleName;
   /** 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 lane order of each stretch of runs (LANE-STRETCH). With `none`, the default, each run gets its order alone.
+   * With `consensus`, `periphery` or `sifting`, the runs that follow each other on the routes share one order. Only the lane order `bundle` reads it.
+   */
+  readonly stretchOrder?: LaneStretchOrder;
+  /** The number of passes of the stretch order `sifting`, from 1 to 4. The default is 2. */
+  readonly siftPasses?: number;
   /**
    * 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).
@@ -113,9 +125,11 @@ export function sharedRouter(options: SharedOptions): Router {
   const reuseExponent = Math.max(0, options.reuseExponent ?? 1);
   const capacity = Math.max(0, options.capacity ?? 0);
   const laneWidth = Math.max(0, options.laneWidth ?? 4);
+  // The name `all` is the same as no rule.
+  const rule = options.rule === undefined || options.rule === "all" ? undefined : groupRuleOf(options.rule);
   const keyOf = (e: Edge): string => {
-    if (!options.rule) return "*";
-    return options.rule(e) ?? `\u0000${e.id}`;
+    if (!rule) return "*";
+    return rule(e) ?? `\u0000${e.id}`;
   };
   const router: Router = {
     name: options.name,
@@ -238,20 +252,38 @@ export function sharedRouter(options: SharedOptions): Router {
       }
 
       // The users of each link, with the links to the ends. Two edges from one plug share the link from it.
-      const users = new Map<string, Map<string, string[]>>();
+      const N = corners.points.length + ends.size + 1;
+      const pairOf = (a: number, b: number): number => (a < b ? a * N + b : b * N + a);
+      const users = new Map<string, Map<number, string[]>>();
       for (const w of order) {
         if (!w.found) continue;
         let mine = users.get(w.key);
         if (!mine) users.set(w.key, (mine = new Map()));
         for (let i = 1; i < w.ids.length; i++) {
-          const a = w.ids[i - 1]!;
-          const b = w.ids[i]!;
-          const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+          const k = pairOf(w.ids[i - 1]!, w.ids[i]!);
           const list = mine.get(k);
           if (list) list.push(w.edge.id);
           else mine.set(k, [w.edge.id]);
         }
       }
+      // The signature of each link (ROUTE-SCALE): 0 for a link with fewer than 2 users, else the number of the sorted list of its users.
+      // Each link gets its signature one time. Two links get the same number only when they have the same sorted list, so the runs do not change.
+      const texts = new Map<string, number>();
+      const sigs = new Map<string, Map<number, number>>();
+      for (const [key, mine] of users) {
+        const own = new Map<number, number>();
+        for (const [k, list] of mine) {
+          if (list.length < 2) {
+            own.set(k, 0);
+            continue;
+          }
+          const text = [...list].sort(byText).join("\u0001");
+          let n = texts.get(text);
+          if (n === undefined) texts.set(text, (n = texts.size + 1));
+          own.set(k, n);
+        }
+        sigs.set(key, own);
+      }
 
       // Each way breaks into stretches where the set of edges on the links stays the same.
       // A shared stretch loses its needless corners one time, so it has the same points in each of its routes.
@@ -259,13 +291,8 @@ export function sharedRouter(options: SharedOptions): Router {
       const points = new Map<string, Point[]>();
       for (const w of all) {
         if (!w.found) continue;
-        const used = users.get(w.key)!;
-        const sig = (i: number): string => {
-          const a = w.ids[i]!;
-          const b = w.ids[i + 1]!;
-          const list = used.get(a < b ? `${a}:${b}` : `${b}:${a}`)!;
-          return list.length < 2 ? "" : [...list].sort(byText).join("\u0001");
-        };
+        const own = sigs.get(w.key)!;
+        const sig = (i: number): number => own.get(pairOf(w.ids[i]!, w.ids[i + 1]!))!;
         const out: Point[] = [w.ps.point];
         const append = (piece: readonly Point[]): void => {
           for (const p of piece) if (dist(p, out[out.length - 1]!) > 1e-9) out.push(p);
@@ -275,7 +302,7 @@ export function sharedRouter(options: SharedOptions): Router {
           const s = sig(i);
           if (i + 1 < w.seq.length - 1 && sig(i + 1) === s) continue;
           const raw = w.seq.slice(start, i + 2);
-          if (s === "") append(corners.pull(raw));
+          if (s === 0) append(corners.pull(raw));
           else {
             const a = w.ids[start]!;
             const b = w.ids[i + 1]!;
@@ -298,10 +325,15 @@ export function sharedRouter(options: SharedOptions): Router {
       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()) {
-        const edges = options.laneOrder === "run" ? laneOrderOfRun(run) : orderLanes(run.points, run.ways.map((w) => routeOf.get(w.edge.id)!), "bundle");
+      const list = [...runs.values()];
+      const routesOf = (run: Run): Route[] => run.ways.map((w) => routeOf.get(w.edge.id)!);
+      // With a stretch order, the runs that follow each other on the routes share one lane order (LANE-STRETCH).
+      const method = options.laneOrder === "run" ? "none" : (options.stretchOrder ?? "none");
+      const stretch = method === "none" ? undefined : stretchLaneOrders(list.map((run) => ({ points: run.points, routes: routesOf(run) })), { method, passes: options.siftPasses ?? 2 });
+      list.forEach((run, i) => {
+        const edges = options.laneOrder === "run" ? laneOrderOfRun(run) : (stretch?.[i] ?? orderLanes(run.points, routesOf(run), "bundle"));
         shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges });
-      }
+      });
       return { routes, runs: shared };
     },
   };

package/src/routers/trunks.ts

@@ -9,8 +9,8 @@ import { balancedFan, fanPath, gilbertPoint } from "./fan.ts";
 export interface TrunksOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
-  /** The grouping rule. The edges from one plug with one key share a trunk. */
-  readonly rule: GroupRule;
+  /** The grouping rule, or the name of a built-in rule (`GROUP_RULE_NAMES`). The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule | GroupRuleName;
   /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
   readonly split?: number;
   /** A group with fewer edges stays unbundled. The default is 2. */
@@ -55,6 +55,23 @@ export const byCollection: GroupRule = (e) => {
   return typeof c === "string" ? c : undefined;
 };
 
+/** The names of the built-in grouping rules of the edges. With `collection`, the rule is `byCollection`. With `all`, each edge has one key. */
+export type GroupRuleName = "collection" | "all";
+
+/** The names of the built-in grouping rules, in the order of a control. */
+export const GROUP_RULE_NAMES: readonly GroupRuleName[] = ["collection", "all"];
+
+/** The rule `all`: each edge has the same key. */
+const allEdges: GroupRule = () => "*";
+
+/** This function gives the rule of a name of `GROUP_RULE_NAMES`. It gives a rule of the caller as it is. It throws a `RangeError` for an unknown name. */
+export function groupRuleOf(rule: GroupRule | GroupRuleName): GroupRule {
+  if (typeof rule === "function") return rule;
+  if (rule === "collection") return byCollection;
+  if (rule === "all") return allEdges;
+  throw new RangeError(`There is no grouping rule "${String(rule)}". The names are ${GROUP_RULE_NAMES.join(" and ")}.`);
+}
+
 /**
  * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
  * A group with fewer than `minSize` edges does not appear.
@@ -189,6 +206,7 @@ export function sharedWays(routes: readonly Route[], from: number): { points: Po
  * The edges outside the groups go as in the corner router.
  */
 export function trunksRouter(options: TrunksOptions): Router {
+  const rule = groupRuleOf(options.rule);
   const router: Router = {
     name: options.name,
     route(graph: Graph): Result {
@@ -200,7 +218,7 @@ export function trunksRouter(options: TrunksOptions): Router {
       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)) {
+      for (const [id, group] of groupEdges(graph.edges, rule, options.minSize ?? 2)) {
         const first = group[0]!;
         const s = byId.get(first.source.node);
         const targets = group.map((e) => byId.get(e.target.node));

package/src/segments.ts

@@ -1,5 +1,5 @@
 import { dist, type Point } from "./geom.ts";
-import { orderPlaced, type Placed } from "./lane-order.ts";
+import { findRun, orderPlaced, placeRoutes } from "./lane-order.ts";
 import type { Result, Route } from "./model.ts";
 
 /** A piece of drawn way. A shared segment carries several edges, in lane order. A private segment carries one edge. */
@@ -34,16 +34,6 @@ export interface SegmentGraph {
 
 const SAME = 1e-6;
 
-/** This function gives the index where `p` holds the points of `part` in a row, from `from` on, or -1. */
-function indexOf(p: readonly Point[], part: readonly Point[], from: number): number {
-  for (let i = from; i + part.length <= p.length; i++) {
-    let ok = true;
-    for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j]!, part[j]!) <= SAME;
-    if (ok) return i;
-  }
-  return -1;
-}
-
 /**
  * This function breaks each route into segments. The runs and the trunks of the bundles become shared segments.
  * The other parts of each route become private segments. The segments of a path, in order, give the points of its route again.
@@ -68,10 +58,10 @@ export function segmentsOf(result: Result): SegmentGraph {
     // The place of each shared segment in the route, in the order of the route.
     const found: { at: number; end: number; ref: SegmentRef }[] = [];
     for (const s of onEdge.get(route.edge) ?? []) {
-      let at = indexOf(p, s.points, 0);
+      let at = findRun(p, s.points, 0);
       let reverse = false;
       if (at < 0) {
-        at = indexOf(p, [...s.points].reverse(), 0);
+        at = findRun(p, [...s.points].reverse(), 0);
         reverse = true;
       }
       if (at >= 0) found.push({ at, end: at + s.points.length - 1, ref: { segment: s.id, reverse, lane: s.lane } });
@@ -174,6 +164,8 @@ export function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<stri
 /** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
 function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Route[] {
   const byId = new Map(graph.segments.map((s) => [s.id, s]));
+  // Each segment gets its spacing one time (ROUTE-SCALE). A key of `runKey` sorts the edges of the segment, and a busy segment is on many paths.
+  const spacings = new Map<Segment, number>();
   const routes: Route[] = [];
   for (const path of graph.paths) {
     const ends = pathPoints(graph, path);
@@ -181,7 +173,8 @@ function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Rout
     for (const ref of path.segments) {
       const s = byId.get(ref.segment);
       if (!s) continue;
-      const spacing = spacingOf(s);
+      let spacing = spacings.get(s);
+      if (spacing === undefined) spacings.set(s, (spacing = spacingOf(s)));
       const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
       for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]!) > SAME) out.push(q);
     }
@@ -218,18 +211,7 @@ export type RunOrder = "bundle" | "run";
  * On a run with a cycle, the order depends on the order of `routes`. The item LANE-STRETCH is to remove the cycles.
  */
 export function orderLanes(run: readonly Point[], routes: readonly Route[], order: RunOrder = "run"): string[] {
-  const placed: Placed[] = [];
-  const lost: string[] = [];
-  for (const r of routes) {
-    let at = indexOf(r.points, run, 0);
-    if (at >= 0) placed.push({ edge: r.edge, p: r.points, s: at, e: at + run.length - 1 });
-    else {
-      const p = [...r.points].reverse();
-      at = indexOf(p, run, 0);
-      if (at >= 0) placed.push({ edge: r.edge, p, s: at, e: at + run.length - 1 });
-      else lost.push(r.edge);
-    }
-  }
+  const { placed, lost } = placeRoutes(run, routes);
   const lanes = orderPlaced(placed, order);
   return [...lanes.map((x) => x.edge), ...lost.sort()];
 }

package/src/strategies/builtins.ts

@@ -66,7 +66,9 @@ import { TRACLUS_DEFAULTS, traclusPlan, type TraclusOptions } from "../highways/
 import { WEISZFELD_DEFAULTS, weiszfeldPlan, type WeiszfeldOptions } from "../highways/weiszfeld/index.ts";
 import { WSPD_DEFAULTS, wspdPlan, type WspdOptions } from "../highways/wspd/index.ts";
 import { ZIPPER_DEFAULTS, zipperPlan, type ZipperOptions } from "../highways/zipper/index.ts";
+import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
 import type { Graph, Result, Router } from "../model.ts";
+import { facingEnds } from "../plugs/facing/index.ts";
 import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
 import { levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
 import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
@@ -76,10 +78,12 @@ import { sharedRouter, type SharedOptions } from "../routers/shared.ts";
 import { straightRouter } from "../routers/straight.ts";
 import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunks.ts";
 import { buildSections, SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
+import { runPipeline, type PipelineOptions } from "../whole/pipeline/index.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 import type { OptionSchema } from "./options.ts";
 import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
-import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+import { DEPTHS_SCHEMA, PIPELINE_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
 
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
@@ -150,7 +154,7 @@ export const routerStrategies: {
     sharedRouter,
     SHARED_SCHEMA,
   ),
-  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter, SHARED_SCHEMA),
+  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter, SHARED_ALL_SCHEMA),
   sections: routerStrategy<RouterPreset<SectionsOptions>>(
     "sections",
     "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.",
@@ -895,6 +899,51 @@ export const highwayStrategies: {
   "corridors+ids": gateStrategy(corridors, stableIdGate),
 });
 
+/** The built-in plug rules: the strategies of the step `plugs`. The router `corners` routes between their plugs with its option `plug`. */
+export const plugStrategies: {
+  readonly facing: Strategy<"plugs", object>;
+} = Object.freeze({
+  facing: defineStrategy({
+    step: "plugs",
+    name: "facing",
+    describe: "Each free plug faces the other end of its edge, on the side of the larger component of the direction. It is the default of the router `corners`.",
+    defaults: {},
+    schema: {},
+    run: (input) => facingEnds(input),
+  }),
+});
+
+/** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
+export const levelStrategies: {
+  readonly depths: Strategy<"levels", DepthLevelOptions>;
+} = Object.freeze({
+  depths: defineStrategy<"levels", DepthLevelOptions>({
+    step: "levels",
+    name: "depths",
+    describe: "One zoom level for each depth of the tree, and a last level with each node alone. A link of a level goes around the other items. It is the default of the router `sections`.",
+    defaults: {},
+    schema: DEPTHS_SCHEMA,
+    run: (input, o) => depthLevels(input, o),
+  }),
+});
+
+/**
+ * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
+ * Without options, it routes the graph with the router `corners`.
+ */
+export const wholeStrategies: {
+  readonly pipeline: Strategy<"whole", PipelineOptions>;
+} = Object.freeze({
+  pipeline: defineStrategy<"whole", PipelineOptions>({
+    step: "whole",
+    name: "pipeline",
+    describe: "One setting of the steps. The room opens the board, then the router or the highway plan routes it with the rules that the router reads.",
+    defaults: { router: routerStrategies.corners as Strategy<"router"> },
+    schema: PIPELINE_SCHEMA,
+    run: (graph, o) => runPipeline(graph, o),
+  }),
+});
+
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 export const BUILT_IN_STRATEGIES: readonly AnyStrategy[] = Object.freeze([
   ...Object.values(groupStrategies),
@@ -902,6 +951,9 @@ export const BUILT_IN_STRATEGIES: readonly AnyStrategy[] = Object.freeze([
   ...Object.values(highwayStrategies),
   ...Object.values(curveStrategies),
   ...Object.values(roomStrategies),
+  ...Object.values(plugStrategies),
+  ...Object.values(levelStrategies),
+  ...Object.values(wholeStrategies),
 ]);
 
 /** The registry of the built-in strategies. The benchmark and the site take their lists from it. */