@mark1russell7/highways 0.8.1 → 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,
@@ -311,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 } });
@@ -221,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. */

package/src/strategies/model.ts

@@ -2,10 +2,12 @@ import type { CurveSegment } from "../curves/model.ts";
 import type { CurveSpace } from "../curves/space.ts";
 import type { Point } from "../geom.ts";
 import type { HighwayInput, HighwayPlan } from "../highways/model.ts";
-import type { Graph, Result, Router } from "../model.ts";
+import type { Graph, Level, Result, Route, Router } from "../model.ts";
+import type { Plug } from "../plugs.ts";
 import type { Boxed, Gap, RoomLink } from "../room/index.ts";
 import type { Section } from "../sections.ts";
 import type { SegmentGraph } from "../segments.ts";
+import type { WayFinder } from "../ways.ts";
 import type { OptionSchema } from "./options.ts";
 
 /** The input of a curve strategy: one polyline and the context of its route. */
@@ -48,21 +50,57 @@ export interface RoomInput {
   readonly sections?: Section;
 }
 
+/** The input of a plug strategy: the graph, and optionally the way finder of the router that reads the plugs. */
+export interface PlugInput {
+  readonly graph: Graph;
+  /** The ways around the nodes of the graph, for a strategy that reads the free space. The default strategy `facing` does not read it. */
+  readonly ways?: WayFinder;
+}
+
+/** The plugs of the two ends of one edge: the output of a plug strategy for that edge. */
+export interface PlugPair {
+  readonly edge: string;
+  readonly source: Plug;
+  readonly target: Plug;
+}
+
+/** The input of a level strategy: the graph, the tree of sections of its grouping rule and the routes of the router. */
+export interface LevelInput {
+  readonly graph: Graph;
+  /** The tree of sections. The indices of its nodes are the indices of `graph.nodes`. */
+  readonly root: Section;
+  /** The routes of the router. The default strategy `depths` gives the links of the last level the points of these routes. */
+  readonly routes: readonly Route[];
+}
+
+/** The output of a strategy of the step `whole`: the board that the routes go on, and the routes. */
+export interface WholeOutput {
+  /** The board: the graph, or the graph with the gaps that a room strategy opened. It has the edges of the input. */
+  readonly graph: Graph;
+  readonly result: Result;
+}
+
 /**
  * The steps that have strategies, with the fixed input and output type of each step.
  *
  * - `group`: a graph in, the tree of sections out. The router `sections` makes its hubs and its zoom levels from this tree.
+ * - `plugs`: a graph in, the plugs of the two ends of each edge out. The router `corners` routes between these plugs.
  * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
  * - `highway`: a graph and optionally its first routes in, a highway plan out. `follow` routes the edges along the plan.
+ * - `levels`: a graph, its tree of sections and its routes in, the zoom levels out. The router `sections` gives them in its result.
  * - `curve`: a polyline in, the segments of a curve out.
  * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ * - `whole`: a graph in, the board and its routes out. A strategy of this step runs the other steps.
  */
 export interface StepTypes {
   readonly group: { readonly input: Graph; readonly output: Section };
+  readonly plugs: { readonly input: PlugInput; readonly output: PlugPair[] };
   readonly router: { readonly input: Graph; readonly output: Result };
   readonly highway: { readonly input: HighwayInput; readonly output: HighwayPlan };
+  readonly levels: { readonly input: LevelInput; readonly output: Level[] };
   readonly curve: { readonly input: CurveInput; readonly output: CurveSegment[] };
   readonly room: { readonly input: RoomInput; readonly output: Gap[] };
+  readonly whole: { readonly input: Graph; readonly output: WholeOutput };
 }
 
 /** The name of a step that has strategies. */
@@ -74,8 +112,12 @@ export type StepInput<S extends Step> = StepTypes[S]["input"];
 /** The output type of a step. */
 export type StepOutput<S extends Step> = StepTypes[S]["output"];
 
-/** The steps that have strategies, in the order of the pipeline. */
-export const STEPS: readonly Step[] = ["group", "router", "highway", "curve", "room"];
+/**
+ * The steps that have strategies, in the order of the pipeline.
+ * The plugs come before the router, because the router searches its ways between them. The levels come after the routes, because the last level reads them.
+ * The step `whole` runs the other steps, so it comes last.
+ */
+export const STEPS: readonly Step[] = ["group", "plugs", "router", "highway", "levels", "curve", "room", "whole"];
 
 /**
  * A strategy: one way to do one step, with a name and a description.
@@ -147,16 +189,16 @@ export function defineStrategy<S extends Step, O extends object>(definition: Str
 /**
  * A registry: the strategies of each step, in order. A registry is data. No import changes it.
  * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
- * The lists `group` and `highway` are optional in the type, so a registry from version 0.1.5 or 0.3.0 stays a registry. `createRegistry` always gives them.
+ * The lists `group`, `highway`, `plugs`, `levels` and `whole` are optional in the type, so a registry of an older version stays a registry. `createRegistry` always gives them.
  */
-export type Registry = { readonly [S in Exclude<Step, "group" | "highway">]: readonly Strategy<S>[] } & {
-  readonly group?: readonly Strategy<"group">[];
-  readonly highway?: readonly Strategy<"highway">[];
-};
+export type Registry = { readonly [S in Exclude<Step, OptionalStep>]: readonly Strategy<S>[] } & { readonly [S in OptionalStep]?: readonly Strategy<S>[] };
+
+/** The steps whose lists are optional in a `Registry`: the steps that came after version 0.1.5. */
+type OptionalStep = "group" | "highway" | "plugs" | "levels" | "whole";
 
 /** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
 export function createRegistry(strategies: readonly AnyStrategy[]): Registry {
-  const out: { [S in Step]: Strategy<S>[] } = { group: [], router: [], highway: [], curve: [], room: [] };
+  const out: { [S in Step]: Strategy<S>[] } = { group: [], plugs: [], router: [], highway: [], levels: [], curve: [], room: [], whole: [] };
   for (const s of strategies) {
     const list = out[s.step] as AnyStrategy[] | undefined;
     if (!list) throw new Error(`There is no step "${String(s.step)}". The steps are ${STEPS.join(", ")}.`);
@@ -165,16 +207,19 @@ export function createRegistry(strategies: readonly AnyStrategy[]): Registry {
   }
   return Object.freeze({
     group: Object.freeze(out.group),
+    plugs: Object.freeze(out.plugs),
     router: Object.freeze(out.router),
     highway: Object.freeze(out.highway),
+    levels: Object.freeze(out.levels),
     curve: Object.freeze(out.curve),
     room: Object.freeze(out.room),
+    whole: Object.freeze(out.whole),
   });
 }
 
 /** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
 export function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry {
-  return createRegistry([...(registry.group ?? []), ...registry.router, ...(registry.highway ?? []), ...registry.curve, ...registry.room, ...strategies]);
+  return createRegistry([...STEPS.flatMap((step) => listStrategies(registry, step) as readonly AnyStrategy[]), ...strategies]);
 }
 
 /** This function gives the strategies of one step of a registry, in order. */