@mark1russell7/highways 0.1.4 → 0.2.0

package/src/room/lanes.ts

@@ -0,0 +1,175 @@
+import { segmentHitsBox, type Box, type Point } from "../geom.ts";
+import { Grid } from "../grid.ts";
+import type { LevelLink } from "../model.ts";
+import { boardGaps, type Boxed } from "./index.ts";
+
+/**
+ * The lane order of the pieces of the links in one gap.
+ *
+ * - `links`: the order of the list of links. This order reads nothing of the board.
+ * - `ends`: the pieces that turn to the near side at their two ends come first. The pieces that turn to the far side come last.
+ * - `crossings`: the order with the fewest crossings between the pieces of the gap and the legs at their ends. A local search finds it.
+ */
+export type LaneOrder = "links" | "ends" | "crossings";
+
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+export const LANE_ORDERS: readonly LaneOrder[] = ["links", "ends", "crossings"];
+
+/** The options of `gapLanes`. */
+export interface GapLaneOptions {
+  /** The largest distance between two lanes. A narrow gap puts its lanes nearer. The default is 4. */
+  readonly spacing?: number;
+  /** The lane order in each gap. The default is `crossings`. */
+  readonly order?: LaneOrder;
+  /** Two box edges nearer than this distance make one boundary of the sweep, as in `boardGaps`. The default is 0.5. */
+  readonly snap?: number;
+}
+
+/** A piece of a link: a leg of the link that runs along a gap. */
+interface Piece {
+  /** The index of the link. */
+  readonly link: number;
+  /** The index of the last point of the leg. The leg goes from the point `seg - 1` to the point `seg`. */
+  readonly seg: number;
+  /** The span of the leg along the gap. */
+  readonly lo: number;
+  readonly hi: number;
+  /** For each end of the leg: its place along the gap, and the side (-1 or 1) across the gap where the link turns. */
+  readonly turns: readonly (readonly [number, number])[];
+}
+
+const EPS = 1e-6;
+const ROUNDS = 8;
+
+/**
+ * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+ * A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+ * When a move puts a link through more boxes than before, the link keeps its points.
+ */
+export function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options: GapLaneOptions = {}): LevelLink[] {
+  const spacing = Math.max(0, options.spacing ?? 4);
+  const order = options.order ?? "crossings";
+  const moved = links.map((l) => l.points.map((p) => ({ x: p.x, y: p.y })));
+  for (const g of boardGaps(items, options.snap)) {
+    if (g.width <= EPS) continue;
+    const across = g.axis;
+    const along = g.axis === "x" ? "y" : "x";
+    const lo = g.at - g.width;
+    const hi = g.at;
+    const pieces: Piece[] = [];
+    links.forEach((l, li) => {
+      const p = l.points;
+      // The first and the last legs hold the plugs, so they do not move.
+      for (let i = 2; i <= p.length - 2; i++) {
+        const a = p[i - 1]!;
+        const b = p[i]!;
+        if (Math.abs(a[across] - b[across]) > EPS || a[across] <= lo + EPS || a[across] >= hi - EPS) continue;
+        if (Math.abs(a[along] - b[along]) <= EPS) continue;
+        const side = (q: Point, r: Point): number => Math.sign(r[across] - q[across]);
+        pieces.push({
+          link: li,
+          seg: i,
+          lo: Math.min(a[along], b[along]),
+          hi: Math.max(a[along], b[along]),
+          turns: [
+            [a[along], side(a, p[i - 2]!)],
+            [b[along], side(b, p[i + 1]!)],
+          ],
+        });
+      }
+    });
+    if (pieces.length === 0) continue;
+    const list = orderPieces(pieces, order);
+    // A piece goes one lane past each piece before it in the order that it overlaps. Thus two pieces that overlap keep their order.
+    const lane: number[] = [];
+    let n = 0;
+    list.forEach((P, i) => {
+      let k = 0;
+      for (let j = 0; j < i; j++) if (overlaps(list[j]!, P)) k = Math.max(k, lane[j]! + 1);
+      lane.push(k);
+      n = Math.max(n, k + 1);
+    });
+    const step = Math.min(spacing, g.width / (n + 1));
+    const mid = (lo + hi) / 2;
+    list.forEach((P, i) => {
+      const v = mid + (lane[i]! - (n - 1) / 2) * step;
+      moved[P.link]![P.seg - 1]![across] = v;
+      moved[P.link]![P.seg]![across] = v;
+    });
+  }
+  const boxes = new Grid<Box>(Math.max(20, meanSide(items)));
+  for (const i of items) boxes.add(i.box, i.box);
+  return links.map((l, i) => (hits(boxes, moved[i]!) > hits(boxes, l.points) ? l : { ...l, points: moved[i]! }));
+}
+
+const overlaps = (P: Piece, Q: Piece): boolean => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;
+
+/**
+ * This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
+ * A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
+ */
+function cost(P: Piece, Q: Piece): number {
+  let c = 0;
+  for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS && y < Q.hi - EPS) c++;
+  for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS && y < P.hi - EPS) c++;
+  return c;
+}
+
+/** This function gives the pieces of one gap in lane order, from the near side to the far side. */
+function orderPieces(pieces: readonly Piece[], order: LaneOrder): Piece[] {
+  if (order === "links") return [...pieces];
+  const sum = (P: Piece): number => P.turns.reduce((s, [, side]) => s + side, 0);
+  const list = [...pieces].sort((P, Q) => sum(P) - sum(Q) || P.link - Q.link || P.seg - Q.seg);
+  if (order === "ends") return list;
+  // The local search moves one piece to the place that removes the most crossings, until no move removes one.
+  const n = list.length;
+  const index = new Map(list.map((P, i) => [P, i]));
+  const c: number[][] = list.map((P) => list.map((Q) => (P !== Q && overlaps(P, Q) ? cost(P, Q) : 0)));
+  const at = (P: Piece, Q: Piece): number => c[index.get(P)!]![index.get(Q)!]!;
+  for (let round = 0; round < ROUNDS; round++) {
+    let better = false;
+    for (let i = 0; i < n; i++) {
+      const x = list[i]!;
+      // The change of the crossings when `x` moves to the place `k`, for each `k`.
+      let best = 0;
+      let to = i;
+      let d = 0;
+      for (let k = i - 1; k >= 0; k--) {
+        d += at(x, list[k]!) - at(list[k]!, x);
+        if (d < best) [best, to] = [d, k];
+      }
+      d = 0;
+      for (let k = i + 1; k < n; k++) {
+        d += at(list[k]!, x) - at(x, list[k]!);
+        if (d < best) [best, to] = [d, k];
+      }
+      if (to !== i) {
+        list.splice(i, 1);
+        list.splice(to, 0, x);
+        better = true;
+      }
+    }
+    if (!better) break;
+  }
+  return list;
+}
+
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items: readonly Boxed[]): number {
+  let s = 0;
+  for (const i of items) s += Math.max(i.box.w, i.box.h);
+  return items.length ? s / items.length : 1;
+}
+
+/** This function counts the legs of a polyline that go through a box, for each box. */
+function hits(boxes: Grid<Box>, p: readonly Point[]): number {
+  let n = 0;
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    boxes.querySegment(a, b, 0, (box) => {
+      if (segmentHitsBox(a, b, box)) n++;
+    });
+  }
+  return n;
+}

package/src/routers/index.ts

@@ -13,7 +13,7 @@ export { sharedRouter, type SharedOptions } from "./shared.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";
 export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunksOptions } from "./trunks.ts";
 
-/** The routers that the benchmark races. */
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 export const ROUTERS: readonly Router[] = [
   straightRouter,
   plugsRouter,

package/src/routers/sections.ts

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

package/src/sections.ts

@@ -18,15 +18,21 @@ export interface SectionOptions {
   readonly cap?: number;
   /** The tree stops at this depth. The default is 16. */
   readonly maxDepth?: number;
+  /** A cell shrinks to one quarter at most this many times without a split. Then it stops. The default is 32. */
+  readonly collapse?: number;
 }
 
+/** The default values of `SectionOptions`. */
+export const SECTION_DEFAULTS: Readonly<Required<SectionOptions>> = Object.freeze({ cap: 8, maxDepth: 16, collapse: 32 });
+
 /**
  * This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
  * When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
  */
 export function buildSections(nodes: readonly Node[], options: SectionOptions = {}): Section {
-  const cap = Math.max(1, options.cap ?? 8);
-  const maxDepth = options.maxDepth ?? 16;
+  const cap = Math.max(1, options.cap ?? SECTION_DEFAULTS.cap);
+  const maxDepth = options.maxDepth ?? SECTION_DEFAULTS.maxDepth;
+  const collapse = options.collapse ?? SECTION_DEFAULTS.collapse;
   const centers = nodes.map((n) => center(n.box));
   let x0 = Infinity;
   let y0 = Infinity;
@@ -41,7 +47,7 @@ export function buildSections(nodes: readonly Node[], options: SectionOptions =
   const root: Box = nodes.length ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : { x: 0, y: 0, w: 0, h: 0 };
   const make = (id: string, depth: number, cell: Box, list: readonly number[]): Section => {
     let box = cell;
-    for (let guard = 0; list.length > cap && depth < maxDepth && guard < 32; guard++) {
+    for (let guard = 0; list.length > cap && depth < maxDepth && guard < collapse; guard++) {
       const mx = box.x + box.w / 2;
       const my = box.y + box.h / 2;
       const parts: number[][] = [[], [], [], []];
@@ -80,3 +86,40 @@ export function allSections(root: Section): Section[] {
 export function treeDepth(root: Section): number {
   return root.children.reduce((d, c) => Math.max(d, treeDepth(c)), root.depth);
 }
+
+/**
+ * This function examines a tree of sections from a grouping rule. It throws an error when the tree is not valid for `count` nodes.
+ * In a valid tree, each node is in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+ */
+export function checkSections(root: Section, count: number): void {
+  const seen = new Array<number>(count).fill(0);
+  const ids = new Set<string>();
+  const fail = (s: Section, what: string): never => {
+    throw new Error(`The tree of sections is not valid at the section "${s.id}": ${what}.`);
+  };
+  if (root.depth !== 0) fail(root, "the root has a depth that is not 0");
+  if (root.nodes.length !== count) fail(root, `the root has ${root.nodes.length} nodes, and the graph has ${count}`);
+  const walk = (s: Section): void => {
+    if (ids.has(s.id)) fail(s, "two sections have this id");
+    ids.add(s.id);
+    if (s.children.length === 0) {
+      for (const i of s.nodes) {
+        if (!Number.isInteger(i) || i < 0 || i >= count) fail(s, `the node index ${i} is not in the graph`);
+        seen[i]!++;
+      }
+      return;
+    }
+    let total = 0;
+    const own = new Set(s.nodes);
+    for (const c of s.children) {
+      if (c.depth !== s.depth + 1) fail(c, "a child is not one level deeper than its parent");
+      for (const i of c.nodes) if (!own.has(i)) fail(c, `the node index ${i} is not in the parent`);
+      total += c.nodes.length;
+      walk(c);
+    }
+    if (total !== s.nodes.length) fail(s, "the children do not split the nodes of the section");
+  };
+  walk(root);
+  const lost = seen.findIndex((n) => n !== 1);
+  if (lost >= 0) fail(root, `the node index ${lost} is in ${seen[lost]} leaves, not in one`);
+}

package/src/strategies/builtins.ts

@@ -0,0 +1,194 @@
+import { arcCurve, type ArcOptions } from "../curves/arc/index.ts";
+import { roundedCurve, type RoundedOptions } from "../curves/rounded/index.ts";
+import { splineCurve, type SplineOptions } from "../curves/spline/index.ts";
+import { straightCurve } from "../curves/straight/index.ts";
+import { byDataGroup, keyGroups, type KeyOptions } from "../groups/keys/index.ts";
+import { quadtreeGroups } from "../groups/quadtree/index.ts";
+import type { Graph, Result, Router } from "../model.ts";
+import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
+import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
+import { plugsRouter } from "../routers/plugs.ts";
+import { sectionsRouter, type SectionsOptions } from "../routers/sections.ts";
+import { sharedRouter, type SharedOptions } from "../routers/shared.ts";
+import { straightRouter } from "../routers/straight.ts";
+import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunks.ts";
+import { SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
+import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type Registry, type Strategy } from "./model.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">;
+
+/** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
+function routerStrategy<O extends object>(
+  name: string,
+  describe: string,
+  maxNodes: number,
+  defaults: O,
+  make: (options: O & { readonly name: string }) => Router,
+): Strategy<"router", O> {
+  return defineStrategy({ step: "router", name, describe, defaults, maxNodes, run: (graph: Graph, options: Readonly<O>): Result => make({ ...options, name }).route(graph) });
+}
+
+/** This function makes a router strategy for a router without options. */
+function fixedRouter(router: Router, describe: string): Strategy<"router", object> {
+  return defineStrategy({ step: "router", name: router.name, describe, defaults: {}, run: (graph: Graph): Result => router.route(graph) });
+}
+
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+export const routerStrategies: {
+  readonly straight: Strategy<"router", object>;
+  readonly plugs: Strategy<"router", object>;
+  readonly corners: Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly "corners-smooth": Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly trunks: Strategy<"router", RouterPreset<TrunksOptions>>;
+  readonly shared: Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly "shared-all": Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly sections: Strategy<"router", RouterPreset<SectionsOptions>>;
+  readonly "sections-tree": Strategy<"router", RouterPreset<SectionsOptions>>;
+} = Object.freeze({
+  straight: fixedRouter(straightRouter, "The control. Each edge is one straight line between its plugs."),
+  plugs: fixedRouter(
+    plugsRouter,
+    "Each edge leaves its plug along the normal of the side and follows the curve of the inflection rule. It does not go around the nodes.",
+  ),
+  corners: routerStrategy<RouterPreset<CornersOptions>>(
+    "corners",
+    "Each edge goes around the nodes on a shortest path (A*) through a sparse visibility graph of the box corners.",
+    10_000,
+    {},
+    cornersRouter,
+  ),
+  "corners-smooth": routerStrategy<RouterPreset<CornersOptions>>(
+    "corners-smooth",
+    "The same paths as `corners`. A route in clear view follows the inflection rule, and the other routes get round corners.",
+    10_000,
+    { smooth: true },
+    cornersRouter,
+  ),
+  trunks: routerStrategy<RouterPreset<TrunksOptions>>(
+    "trunks",
+    "A rule puts edges in groups. The edges of a group leave one plug of one node on one trunk. At a split point, each edge goes on to its target.",
+    10_000,
+    { rule: byCollection },
+    trunksRouter,
+  ),
+  shared: routerStrategy<RouterPreset<SharedOptions>>(
+    "shared",
+    "The edges of one collection share their ways through the corner graph. A link that the group uses already costs half.",
+    10_000,
+    { rule: byCollection },
+    sharedRouter,
+  ),
+  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter),
+  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.",
+    100_000,
+    {},
+    sectionsRouter,
+  ),
+  "sections-tree": routerStrategy<RouterPreset<SectionsOptions>>(
+    "sections-tree",
+    "The same as `sections`, but without the limit of the stretch.",
+    100_000,
+    { stretch: Infinity },
+    sectionsRouter,
+  ),
+});
+
+/** The context of a curve input, without the keys that have no value. */
+const contextOf = (input: CurveInput): Omit<CurveInput, "points"> => ({
+  ...(input.startNormal ? { startNormal: input.startNormal } : {}),
+  ...(input.endNormal ? { endNormal: input.endNormal } : {}),
+  ...(input.space ? { space: input.space } : {}),
+});
+
+/** The options of the curve strategies `rounded` and `arc`. */
+export interface RadiusOptions {
+  /** The radius of the corners. The default is 12. */
+  readonly radius: number;
+}
+
+/** The options of the curve strategy `spline`. */
+export interface TensionOptions {
+  /** The tension of the spline, from 0 (the spline) to 1 (the polyline). The default is 0. */
+  readonly tension: number;
+}
+
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+export const curveStrategies: {
+  readonly straight: Strategy<"curve", object>;
+  readonly rounded: Strategy<"curve", RadiusOptions>;
+  readonly spline: Strategy<"curve", TensionOptions>;
+  readonly arc: Strategy<"curve", RadiusOptions>;
+} = Object.freeze({
+  straight: defineStrategy({ step: "curve", name: "straight", describe: "The polyline as it is.", defaults: {}, run: (input: CurveInput) => straightCurve(input.points) }),
+  rounded: defineStrategy({
+    step: "curve",
+    name: "rounded",
+    describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
+    defaults: { radius: 12 },
+    run: (input: CurveInput, o: Readonly<RadiusOptions>) => roundedCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies RoundedOptions),
+  }),
+  spline: defineStrategy({
+    step: "curve",
+    name: "spline",
+    describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
+    defaults: { tension: 0 },
+    run: (input: CurveInput, o: Readonly<TensionOptions>) => splineCurve(input.points, { ...contextOf(input), tension: o.tension } satisfies SplineOptions),
+  }),
+  arc: defineStrategy({
+    step: "curve",
+    name: "arc",
+    describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
+    defaults: { radius: 12 },
+    run: (input: CurveInput, o: Readonly<RadiusOptions>) => arcCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies ArcOptions),
+  }),
+});
+
+/** The options of a room strategy: the options of `roomDemand`, without the method. */
+export type RoomPreset = Omit<RoomOptions, "method">;
+
+const roomStrategy = (method: RoomMethod, describe: string): Strategy<"room", RoomPreset> =>
+  defineStrategy<"room", RoomPreset>({ step: "room", name: method, describe, defaults: {}, run: (input, o) => roomDemand(input.items, input.links, { ...o, method }) });
+
+/** The built-in room strategies: the methods of `roomDemand`. */
+export const roomStrategies: {
+  readonly routes: Strategy<"room", RoomPreset>;
+  readonly lines: Strategy<"room", RoomPreset>;
+} = Object.freeze({
+  routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
+  lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap."),
+});
+
+/** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
+export const groupStrategies: {
+  readonly quadtree: Strategy<"group", Required<SectionOptions>>;
+  readonly keys: Strategy<"group", KeyOptions>;
+} = Object.freeze({
+  quadtree: defineStrategy({
+    step: "group",
+    name: "quadtree",
+    describe: "The cells of a quadtree of the plane. A cell with more than `cap` nodes splits in four. It is the default rule of the router `sections`.",
+    defaults: { ...SECTION_DEFAULTS },
+    run: (graph: Graph, o: Readonly<Required<SectionOptions>>) => quadtreeGroups(graph, o),
+  }),
+  keys: defineStrategy({
+    step: "group",
+    name: "keys",
+    describe: "One group for each key of the nodes. The default key is the string `data.group` of the node. A node without a key is a group alone.",
+    defaults: { key: byDataGroup } as KeyOptions,
+    run: (graph: Graph, o: Readonly<KeyOptions>) => keyGroups(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),
+  ...Object.values(routerStrategies),
+  ...Object.values(curveStrategies),
+  ...Object.values(roomStrategies),
+]);
+
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+export const STRATEGIES: Registry = createRegistry(BUILT_IN_STRATEGIES);

package/src/strategies/index.ts

@@ -0,0 +1,2 @@
+export * from "./model.ts";
+export * from "./builtins.ts";