@mark1russell7/highways 0.8.1 → 0.9.1

package/src/routers/shared.ts

@@ -1,13 +1,15 @@
 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 { nodeIndex, resolvePorts, 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).
@@ -65,6 +77,21 @@ export interface SharedOptions extends WayOptions {
   readonly maxNodes?: number;
 }
 
+/**
+ * The negotiation of the router `attraction` (HWY-044, PathFinder turned around). Each pass routes each edge again from no ways.
+ * A link costs `len (1 - attraction h) (1 + weight max(0, use - cap))` more than in `shared`, with `h` the history of the link.
+ */
+export interface SharedNegotiation {
+  /** The number of passes, 1 or more. */
+  readonly passes: number;
+  /** The pull of the history of a link, from 0 to 1. */
+  readonly attraction: number;
+  /** The cost weight of each edge over the capacity of a link, 0 or more. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width, and 1 or more. */
+  readonly laneWidth: number;
+}
+
 /** A way of one edge through the corner graph. */
 export interface Way {
   readonly edge: Edge;
@@ -102,7 +129,7 @@ function turn(from: Point, base: Point, to: Point): number {
  * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
  * The result gives each stretch as a run, with the order of its lanes.
  */
-export function sharedRouter(options: SharedOptions): Router {
+export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation): Router {
   const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
   const flow = options.cost === "flow";
   const alpha = Math.min(1, Math.max(0.1, options.alpha ?? 0.6));
@@ -113,13 +140,16 @@ 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,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const corners = ways.corners;
@@ -158,8 +188,11 @@ export function sharedRouter(options: SharedOptions): Router {
         if (wd === undefined) widths.set(k, (wd = channelWidth(ways.obstacles, corners.points[i]!, corners.points[j]!)));
         return wd;
       };
-      /** This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`. */
-      const route = (w: Way, before?: ReadonlyMap<number, number>): void => {
+      /**
+       * This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`.
+       * `history` holds the history of each link of the key, for the negotiation of `attraction`.
+       */
+      const route = (w: Way, before?: ReadonlyMap<number, number>, history?: ReadonlyMap<number, number>): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
@@ -178,6 +211,20 @@ export function sharedRouter(options: SharedOptions): Router {
           cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
           floor /= (1 + reuse * most) ** reuseExponent;
         }
+        if (negotiation !== undefined && history !== undefined) {
+          const plain = cost;
+          const a = negotiation.attraction;
+          const b = negotiation.capacityWeight;
+          let most = 0;
+          for (const h of history.values()) most = Math.max(most, h);
+          cost = (i, j, d) => {
+            const k = link(i, j);
+            const use = (mine.get(k)?.length ?? 0) + 1;
+            const cap = Math.max(1, Math.floor(widthOf(i, j) / negotiation.laneWidth));
+            return plain(i, j, d) * (1 - a * (history.get(k) ?? 0)) * (1 + b * Math.max(0, use - cap));
+          };
+          floor *= 1 - a * most;
+        }
         const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
         if (!way) return;
         w.found = true;
@@ -193,9 +240,39 @@ export function sharedRouter(options: SharedOptions): Router {
           if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b))!.length));
         }
       };
-      for (const w of order) route(w);
+      /**
+       * This function gives the passes of the negotiation (HWY-044). After each pass, the history of each link grows by `use / m`,
+       * with `m` the edges of the key, up to `0.9 / attraction`. Each later pass routes each edge again from no ways.
+       */
+      const negotiate = (list: readonly Way[]): void => {
+        const nego = negotiation!;
+        const histories = new Map<string, Map<number, number>>();
+        const size = new Map<string, number>();
+        for (const w of list) size.set(w.key, (size.get(w.key) ?? 0) + 1);
+        const most = nego.attraction > 0 ? 0.9 / nego.attraction : Infinity;
+        for (let pass = 0; pass < Math.max(1, Math.floor(nego.passes)); pass++) {
+          if (pass > 0) {
+            for (const [key, links] of discounted) {
+              let h = histories.get(key);
+              if (!h) histories.set(key, (h = new Map()));
+              const m = size.get(key) ?? 1;
+              for (const [k, users] of links) h.set(k, Math.min(most, (h.get(k) ?? 0) + users.length / m));
+            }
+            discounted.clear();
+            top.clear();
+            for (const w of list) {
+              w.found = false;
+              w.seq = [];
+              w.ids = [];
+            }
+          }
+          for (const w of list) route(w, undefined, histories.get(w.key) ?? new Map());
+        }
+      };
+      if (negotiation !== undefined) negotiate(order);
+      else for (const w of order) route(w);
       // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
-      for (let pass = 1; pass < passes; pass++) {
+      for (let pass = 1; negotiation === undefined && pass < passes; pass++) {
         if (reuse > 0) {
           // Winding Roads (HWY-005): each edge finds its way again from no ways, and the busy links of the pass before pull it.
           const before = new Map<string, Map<number, number>>();
@@ -311,10 +388,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/straight.ts

@@ -1,5 +1,5 @@
 import { center, type Box, type Point } from "../geom.ts";
-import { fixedPortPoint, nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { fixedPortPoint, nodeIndex, resolvePorts, type Graph, type Result, type Route, type Router } from "../model.ts";
 
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export function boxExit(box: Box, toward: Point): Point {
@@ -19,7 +19,8 @@ export function boxExit(box: Box, toward: Point): Point {
  */
 export const straightRouter: Router = {
   name: "straight",
-  route(graph: Graph): Result {
+  route(input: Graph): Result {
+    const graph = resolvePorts(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/trunks.ts

@@ -1,5 +1,5 @@
 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, type SharedRun } from "../model.ts";
+import { nodeIndex, resolvePorts, 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";
@@ -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,9 +206,11 @@ 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 {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const points = new Map<string, readonly Point[]>();
@@ -200,7 +219,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

@@ -44,6 +44,11 @@ import { TERRITORY_DEFAULTS, territoryPlan, type TerritoryOptions } from "../hig
 import { CONSENSUS_DEFAULTS, consensusPlan, type ConsensusOptions } from "../highways/consensus/index.ts";
 import { P_HUB_DEFAULTS, pHubPlan, type PHubOptions } from "../highways/p-hub/index.ts";
 import { SCALE_SPACE_DEFAULTS, scaleSpacePlan, type ScaleSpaceOptions } from "../highways/scale-space/index.ts";
+import { GAP_DEFAULTS, gapPlan, type GapOptions } from "../highways/gaps/index.ts";
+import { INTERCHANGE_DEFAULTS, interchangePlan, type InterchangeOptions } from "../highways/interchanges/index.ts";
+import { SEARCH_DEFAULTS, searchPlan, type SearchOptions } from "../highways/search/index.ts";
+import { STEINER_DEFAULTS, steinerPlan, type SteinerOptions } from "../highways/steiner/index.ts";
+import { STREET_DEFAULTS, streetPlan, type StreetOptions } from "../highways/streets/index.ts";
 import { RIDGE_DEFAULTS, ridgePlan, type RidgeOptions } from "../highways/ridges/index.ts";
 import { SOFT_KEY_DEFAULTS, softKeyPlan, type SoftKeyOptions } from "../highways/soft-keys/index.ts";
 import { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FlowFieldOptions } from "../highways/flow-field/index.ts";
@@ -66,7 +71,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 +83,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, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_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 +159,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.",
@@ -458,6 +467,11 @@ export const highwayStrategies: {
   readonly consensus: Strategy<"highway", ConsensusOptions>;
   readonly "p-hub": Strategy<"highway", PHubOptions>;
   readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
+  readonly steiner: Strategy<"highway", SteinerOptions>;
+  readonly gaps: Strategy<"highway", GapOptions>;
+  readonly streets: Strategy<"highway", StreetOptions>;
+  readonly search: Strategy<"highway", SearchOptions>;
+  readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -888,6 +902,51 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<ScaleSpaceOptions>) => scaleSpacePlan(input, o),
   }),
+  steiner: defineStrategy({
+    step: "highway",
+    name: "steiner",
+    describe: "Obstacle-avoiding rectilinear Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree, and the stretches that edges share become highways.",
+    defaults: { ...STEINER_DEFAULTS } as SteinerOptions,
+    schema: STEINER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SteinerOptions>) => steinerPlan(input, o),
+  }),
+  gaps: defineStrategy({
+    step: "highway",
+    name: "gaps",
+    describe: "Gap highways (HWY-057). The free middle lines of the gaps are streets, and a street that enough edges choose becomes a highway.",
+    defaults: { ...GAP_DEFAULTS } as GapOptions,
+    schema: GAP_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<GapOptions>) => gapPlan(input, o),
+  }),
+  streets: defineStrategy({
+    step: "highway",
+    name: "streets",
+    describe: "Orthogonal streets by a greedy set cover (HWY-058). Each step takes the street that its new edges ride the most per unit of its length.",
+    defaults: { ...STREET_DEFAULTS } as StreetOptions,
+    schema: STREET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<StreetOptions>) => streetPlan(input, o),
+  }),
+  search: defineStrategy({
+    step: "highway",
+    name: "search",
+    describe: "A local search over the set of highways (HWY-059). The annealing adds, drops and moves highways, edges and points on a score of the bundle measures.",
+    defaults: { ...SEARCH_DEFAULTS } as SearchOptions,
+    schema: SEARCH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SearchOptions>) => searchPlan(input, o),
+  }),
+  interchanges: defineStrategy({
+    step: "highway",
+    name: "interchanges",
+    describe: "A network of highways with interchanges (HWY-060). Each edge rides up to a number of highways, with a cost for each change.",
+    defaults: { ...INTERCHANGE_DEFAULTS } as InterchangeOptions,
+    schema: INTERCHANGE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<InterchangeOptions>) => interchangePlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -895,6 +954,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 +1006,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. */