@mark1russell7/highways 0.4.0 → 0.4.2

package/src/routers/snell.ts

@@ -0,0 +1,140 @@
+import { dist, type Point } from "../geom.ts";
+import type { Way } from "./shared.ts";
+
+/**
+ * This function gives the Snell merge point of a route (NAT-035).
+ * The route comes from `from`, reaches a run at `at` and goes on along the run to `next`.
+ * A unit of length on the run costs `d` against 1 off it. The cheapest route meets the run at the angle `acos(d)`.
+ * The function gives the distance from `at` toward `next` of that merge point. A value of 0 or less tells that the turn at `at` is already at most `acos(d)`.
+ */
+export function snellOffset(from: Point, at: Point, next: Point, d: number): number {
+  const len = dist(at, next);
+  if (len <= 0) return 0;
+  const ux = (next.x - at.x) / len;
+  const uy = (next.y - at.y) / len;
+  const vx = from.x - at.x;
+  const vy = from.y - at.y;
+  // The foot of `from` on the line of the run is at `along` from `at`, and `from` is `h` from the line.
+  const along = vx * ux + vy * uy;
+  const h = Math.abs(vx * uy - vy * ux);
+  const c = Math.min(0.999, Math.max(0, d));
+  return along + (h * c) / Math.sqrt(1 - c * c);
+}
+
+/** The turn, in radians from 0 to π, at `b` on the way from `a` through `b` to `c`. */
+function turnAt(a: Point, b: Point, c: Point): number {
+  const ux = b.x - a.x;
+  const uy = b.y - a.y;
+  const vx = c.x - b.x;
+  const vy = c.y - b.y;
+  return Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+}
+
+/**
+ * This function moves the merge points of the ways of the router `shared` to the Snell angle (NAT-035). It changes the ways in place.
+ *
+ * A way joins a run at a corner `J` when it comes alone from the corner before.
+ * The link from `J` to the next corner has other edges of its key.
+ * When the way turns at `J` by more than `acos(d)`, it goes directly to a new point `J*` on that link.
+ * At `J*`, the way meets the link at the angle `acos(d)`.
+ * Each way on the link gets `J*` as a new corner, so the run keeps the same points in each route. Then the same rule moves the exits, on the reversed ways.
+ *
+ * `firstId` is the first free id of a corner. `clear` tells if a line keeps out of the boxes. `delta` gives the cost share `d` of a link with `f` other edges.
+ */
+export function snellMerges(ways: readonly Way[], firstId: number, clear: (a: Point, b: Point) => boolean, delta: (f: number) => number): void {
+  let next = firstId;
+  const keys = new Map<string, Way[]>();
+  for (const w of ways) {
+    if (!w.found) continue;
+    const list = keys.get(w.key);
+    if (list) list.push(w);
+    else keys.set(w.key, [w]);
+  }
+  for (const group of keys.values()) {
+    if (group.length < 2) continue;
+    const linkOf = (a: number, b: number): string => (a < b ? `${a}:${b}` : `${b}:${a}`);
+    const on = new Map<string, Set<Way>>();
+    const add = (k: string, w: Way): void => {
+      const set = on.get(k);
+      if (set) set.add(w);
+      else on.set(k, new Set([w]));
+    };
+    const drop = (k: string, w: Way): void => {
+      const set = on.get(k);
+      if (!set) return;
+      set.delete(w);
+      if (set.size === 0) on.delete(k);
+    };
+    for (const w of group) for (let i = 1; i < w.ids.length; i++) add(linkOf(w.ids[i - 1]!, w.ids[i]!), w);
+    // First the merges, then the exits: an exit is a merge of the reversed way.
+    for (const back of [false, true]) {
+      for (const w of group) {
+        if (back) {
+          w.seq.reverse();
+          w.ids.reverse();
+        }
+        for (let i = 1; i < w.ids.length - 1; i++) {
+          const before = on.get(linkOf(w.ids[i - 1]!, w.ids[i]!));
+          const after = on.get(linkOf(w.ids[i]!, w.ids[i + 1]!));
+          if (!before || !after || before.size !== 1 || after.size < 2) continue;
+          const P = w.seq[i - 1]!;
+          const J = w.seq[i]!;
+          const N = w.seq[i + 1]!;
+          const d = delta(after.size - 1);
+          const turn = turnAt(P, J, N);
+          if (turn <= Math.acos(d) + 1e-3) continue;
+          const len = dist(J, N);
+          let t = Math.min(len, snellOffset(P, J, N, d));
+          // A line from P to the merge point that goes through a box moves the point back toward J, at most three times.
+          const pointAt = (s: number): Point => ({ x: J.x + ((N.x - J.x) * s) / len, y: J.y + ((N.y - J.y) * s) / len });
+          let tries = 0;
+          while (t >= 1 && !clear(P, pointAt(t)) && tries < 3) {
+            t /= 2;
+            tries++;
+          }
+          if (t < 1 || !clear(P, pointAt(t))) continue;
+          const a = w.ids[i - 1]!;
+          const j = w.ids[i]!;
+          const n = w.ids[i + 1]!;
+          if (t >= len - 1e-6) {
+            // The merge point is the next corner: the way skips J.
+            drop(linkOf(a, j), w);
+            drop(linkOf(j, n), w);
+            w.seq.splice(i, 1);
+            w.ids.splice(i, 1);
+            add(linkOf(a, n), w);
+            continue;
+          }
+          const star = pointAt(t);
+          const id = next++;
+          const users = [...after];
+          on.delete(linkOf(j, n));
+          // Each way on the link from J to N gets the new corner between them.
+          for (const o of users) {
+            for (let k = 0; k < o.ids.length - 1; k++) {
+              const x = o.ids[k]!;
+              const y = o.ids[k + 1]!;
+              if ((x === j && y === n) || (x === n && y === j)) {
+                o.seq.splice(k + 1, 0, star);
+                o.ids.splice(k + 1, 0, id);
+                break;
+              }
+            }
+            add(linkOf(j, id), o);
+            add(linkOf(id, n), o);
+          }
+          // The way itself goes from P directly to the new corner.
+          drop(linkOf(a, j), w);
+          drop(linkOf(j, id), w);
+          w.seq.splice(i, 1);
+          w.ids.splice(i, 1);
+          add(linkOf(a, id), w);
+        }
+        if (back) {
+          w.seq.reverse();
+          w.ids.reverse();
+        }
+      }
+    }
+  }
+}

package/src/routers/trunks.ts

@@ -3,6 +3,7 @@ import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Nod
 import { placePlug, type Plug } from "../plugs.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
+import { balancedFan, fanPath, gilbertPoint } from "./fan.ts";
 
 /** The options of the trunk router. */
 export interface TrunksOptions extends WayOptions {
@@ -21,6 +22,20 @@ export interface TrunksOptions extends WayOptions {
    * A lane that turns back over the trunk leaves at an earlier point of the trunk. With `split`, each lane leaves at the split point, as in version 0.2.0.
    */
   readonly leave?: TrunkLeave;
+  /**
+   * The place of the split point. With `share`, the default, it is at `split` of the way to the center of the targets.
+   * With `gilbert`, it is where the flow cost of the trunk and its branches is least, with the exponent `alpha` (EDA-030).
+   */
+  readonly splitAt?: TrunkSplit;
+  /** The exponent of the flow cost of the split `gilbert`, from 0 to 1. The default is 0.5. */
+  readonly alpha?: number;
+  /**
+   * The shape of each group. With `split`, the default, the edges share a trunk to a split point.
+   * With `tree`, the edges grow a balancing-factor tree from the plug, with the factor `bf` (NAT-017).
+   */
+  readonly fan?: TrunkFan;
+  /** The balancing factor of the fan `tree`, from 0 to 1. 0 gives the least ink, and a larger factor gives more direct routes. The default is 0.4. */
+  readonly bf?: number;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -28,6 +43,12 @@ export interface TrunksOptions extends WayOptions {
 /** The place where the lanes of a trunk leave it: where their ways part, or at the split point. */
 export type TrunkLeave = "part" | "split";
 
+/** The place of the split point of a trunk: at a share of the way, or at the Gilbert point of the flow cost (EDA-030). */
+export type TrunkSplit = "share" | "gilbert";
+
+/** The shape of a group of the router `trunks`: a trunk and a split point, or a balancing-factor tree (NAT-017). */
+export type TrunkFan = "split" | "tree";
+
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 export const byCollection: GroupRule = (e) => {
   const c = e.data?.["collection"];
@@ -188,7 +209,28 @@ export function trunksRouter(options: TrunksOptions): Router {
         const c = { x: centers.reduce((a, p) => a + p.x, 0) / centers.length, y: centers.reduce((a, p) => a + p.y, 0) / centers.length };
         const plug: Plug = placePlug(s, first.source, c);
         const start = ways.out(plug);
-        const split = splitPoint(start, centers, options.split ?? 0.5, (p) => !ways.obstacles.inside(p, ways.margin), ways.margin);
+        const key = id.split("\u0000")[2]!;
+        if (options.fan === "tree") {
+          // Each edge follows the tree from the plug to its target. The routes share the points of the tree.
+          const pts = group.map((e, i) => placePlug(targets[i]!, e.target, start));
+          const bf = Math.min(1, Math.max(0, options.bf ?? 0.4));
+          const fan = balancedFan(start, pts.map((pt) => ways.out(pt)), bf, (from, t) => ways.toPlug(from, pts[t]!) ?? [from, pts[t]!.point]);
+          const own: Route[] = group.map((e, i) => ({ edge: e.id, points: dedupe([plug.point, ...fanPath(fan, fan.leaf[i]!)]) }));
+          for (const r of own) points.set(r.edge, r.points);
+          const order = options.laneOrder ?? "bundle";
+          const common = own[0]!.points.slice(0, commonStart(own, 0));
+          bundles.push({ id: `b${bundles.length}`, key, node: s.id, edges: orderLanes(common, own, order), trunk: common });
+          for (const way of sharedWays(own, common.length)) {
+            const users = own.filter((r) => way.edges.includes(r.edge));
+            runs.push({ id: `r${runs.length}`, key, points: way.points, edges: orderLanes(way.points, users, order) });
+          }
+          continue;
+        }
+        const free = (p: Point): boolean => !ways.obstacles.inside(p, ways.margin);
+        const split =
+          options.splitAt === "gilbert"
+            ? gilbertPoint(start, centers, options.alpha ?? 0.5, free, ways.margin)
+            : splitPoint(start, centers, options.split ?? 0.5, free, ways.margin);
         const way = ways.fromPlug(plug, split);
         if (!way) continue;
         const trunk = dedupe(way);
@@ -211,7 +253,6 @@ export function trunksRouter(options: TrunksOptions): Router {
           const exit = leaveTrunk(trunk, branch, clear, 2 * ways.margin);
           if (exit) exits.push({ edge: e.id, exit });
         });
-        const key = id.split("\u0000")[2]!;
         if (!part) {
           for (const r of own) points.set(r.edge, r.points);
           const edges = options.laneOrder === "run" || trunk.length < 2 ? laneOrder(dir, end, branches) : orderLanes(trunk, own, "bundle");

package/src/strategies/builtins.ts

@@ -12,9 +12,26 @@ import { KD_DEFAULTS, kdGroups, type KdOptions } from "../groups/kd/index.ts";
 import { byDataGroup, keyGroups, type KeyOptions } from "../groups/keys/index.ts";
 import { quadtreeGroups } from "../groups/quadtree/index.ts";
 import { CORRIDOR_DEFAULTS, corridorPlan, type CorridorOptions } from "../highways/corridors/index.ts";
+import { ambiguityGate, type AmbiguityGuardOptions } from "../highways/gates/ambiguity/index.ts";
+import { breakEvenGate, type BreakEvenOptions } from "../highways/gates/breakeven/index.ts";
+import { hysteresisGate, type HysteresisOptions } from "../highways/gates/hysteresis/index.ts";
+import { stableIdGate, type StableIdOptions } from "../highways/gates/ids/index.ts";
+import { gateStrategy } from "../highways/gates/model.ts";
+import { stretchGate, type StretchOptions } from "../highways/gates/stretch/index.ts";
+import { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FlowFieldOptions } from "../highways/flow-field/index.ts";
 import { keysPlan, type KeysOptions } from "../highways/keys/index.ts";
+import { LEVEL_HIGHWAY_DEFAULTS, levelHighwayPlan, type LevelHighwayOptions } from "../highways/level-links/index.ts";
+import { MEET_DEFAULTS, meetPlan, type MeetOptions } from "../highways/meet/index.ts";
 import type { HighwayInput } from "../highways/model.ts";
+import { OD_CELL_DEFAULTS, odCellPlan, type OdCellOptions } from "../highways/od-cells/index.ts";
+import { QUICKBUNDLES_DEFAULTS, quickBundlesPlan, type QuickBundlesOptions } from "../highways/quickbundles/index.ts";
+import { ROAD_CLASS_DEFAULTS, roadClassPlan, type RoadClassOptions } from "../highways/road-classes/index.ts";
+import { SELECT_DEFAULTS, selectPlan, type SelectOptions } from "../highways/select/index.ts";
 import { sharedWaysPlan, type SharedWaysOptions } from "../highways/shared-ways/index.ts";
+import { STUB_DEFAULTS, stubPlan, type StubOptions } from "../highways/stubs/index.ts";
+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 type { Graph, Result, Router } from "../model.ts";
 import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
 import { levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
@@ -27,7 +44,7 @@ import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunk
 import { buildSections, SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 import type { OptionSchema } from "./options.ts";
-import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CUT_SCHEMA, HIGHWAY_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LEVEL_ROOM_SCHEMA, RADIUS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, TENSION_SCHEMA, TRUNKS_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CUT_SCHEMA, FLOW_FIELD_SCHEMA, HIGHWAY_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, STUB_SCHEMA, TENSION_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">;
@@ -340,14 +357,43 @@ export const groupStrategies: {
   }),
 });
 
+/** The highway strategy `corridors` (HWY-031): the base of the built-in gates. */
+const corridors: Strategy<"highway", CorridorOptions> = defineStrategy({
+  step: "highway",
+  name: "corridors",
+  describe: "Corridor signatures. Edges whose first ways share long links make a cluster, found with MinHash. The longest common run of each cluster is its highway.",
+  defaults: { ...CORRIDOR_DEFAULTS } as CorridorOptions,
+  schema: CORRIDOR_SCHEMA,
+  maxNodes: 10_000,
+  run: (input: HighwayInput, o: Readonly<CorridorOptions>) => corridorPlan(input, o),
+});
+
 /**
  * The built-in highway strategies: the decisions of the routers `trunks` and `shared` as plans, and corridor signatures (HWY-031).
+ * The strategies `corridors+<gate>` put a gate of BUILD-W2A after `corridors`: `breakeven` (HWY-047), `stretch` (HWY-048), `ambiguity` (HWY-049),
+ * `hysteresis` (HWY-046) and `ids` (HWY-054). `gateStrategy` puts a gate after any other plan.
  * `follow` routes the edges along a plan, and `highwayRouter` gives a router that does both.
  */
 export const highwayStrategies: {
   readonly keys: Strategy<"highway", KeysOptions>;
   readonly "shared-ways": Strategy<"highway", SharedWaysOptions>;
   readonly corridors: Strategy<"highway", CorridorOptions>;
+  readonly meet: Strategy<"highway", MeetOptions>;
+  readonly weiszfeld: Strategy<"highway", WeiszfeldOptions>;
+  readonly stubs: Strategy<"highway", StubOptions>;
+  readonly zipper: Strategy<"highway", ZipperOptions>;
+  readonly "level-links": Strategy<"highway", LevelHighwayOptions>;
+  readonly quickbundles: Strategy<"highway", QuickBundlesOptions>;
+  readonly "road-classes": Strategy<"highway", RoadClassOptions>;
+  readonly "flow-field": Strategy<"highway", FlowFieldOptions>;
+  readonly wspd: Strategy<"highway", WspdOptions>;
+  readonly "od-cells": Strategy<"highway", OdCellOptions>;
+  readonly select: Strategy<"highway", SelectOptions>;
+  readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
+  readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
+  readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
+  readonly "corridors+hysteresis": Strategy<"highway", CorridorOptions & HysteresisOptions>;
+  readonly "corridors+ids": Strategy<"highway", CorridorOptions & StableIdOptions>;
 } = Object.freeze({
   keys: defineStrategy({
     step: "highway",
@@ -367,15 +413,111 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<SharedWaysOptions>) => sharedWaysPlan(input, o),
   }),
-  corridors: defineStrategy({
+  corridors,
+  meet: defineStrategy({
+    step: "highway",
+    name: "meet",
+    describe: "Meet points (HWY-050). Each member of the plan `from` joins its spine where its first route meets the spine, and leaves where they part.",
+    defaults: { ...MEET_DEFAULTS } as MeetOptions,
+    schema: MEET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MeetOptions>) => meetPlan(input, o),
+  }),
+  weiszfeld: defineStrategy({
+    step: "highway",
+    name: "weiszfeld",
+    describe: "Weiszfeld meeting points (HWY-043). Each highway of the plan `from` gets the merge and split points with the least ink, with a weighted trunk.",
+    defaults: { ...WEISZFELD_DEFAULTS } as WeiszfeldOptions,
+    schema: WEISZFELD_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<WeiszfeldOptions>) => weiszfeldPlan(input, o),
+  }),
+  stubs: defineStrategy({
+    step: "highway",
+    name: "stubs",
+    describe: "Stubs (HWY-015, WILD-005). The ends on one side of a box that go in near directions share one plug and one short stub.",
+    defaults: { ...STUB_DEFAULTS } as StubOptions,
+    schema: STUB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<StubOptions>) => stubPlan(input, o),
+  }),
+  zipper: defineStrategy({
+    step: "highway",
+    name: "zipper",
+    describe: "The axon zipper (NAT-022, WILD-037). Two near, nearly parallel legs zip into one line when the shared length is more than the jogs.",
+    defaults: { ...ZIPPER_DEFAULTS } as ZipperOptions,
+    schema: ZIPPER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ZipperOptions>) => zipperPlan(input, o),
+  }),
+  "level-links": defineStrategy({
+    step: "highway",
+    name: "level-links",
+    describe: "Level links as highways (HWY-056, WILD-034). The edges between two items of a zoom level ride the link of the level.",
+    defaults: { ...LEVEL_HIGHWAY_DEFAULTS } as LevelHighwayOptions,
+    schema: LEVEL_HIGHWAY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<LevelHighwayOptions>) => levelHighwayPlan(input, o),
+  }),
+  quickbundles: defineStrategy({
+    step: "highway",
+    name: "quickbundles",
+    describe: "QuickBundles (HWY-026). One pass puts each edge in the nearest cluster of resampled lines. Each cluster gets highways.",
+    defaults: { ...QUICKBUNDLES_DEFAULTS } as QuickBundlesOptions,
+    schema: QUICKBUNDLES_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<QuickBundlesOptions>) => quickBundlesPlan(input, o),
+  }),
+  "road-classes": defineStrategy({
+    step: "highway",
+    name: "road-classes",
+    describe: "Road classes (HWY-034, EDA-050). The links that most ways use become main roads, and a second pass routes the edges onto them.",
+    defaults: { ...ROAD_CLASS_DEFAULTS } as RoadClassOptions,
+    schema: ROAD_CLASS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<RoadClassOptions>) => roadClassPlan(input, o),
+  }),
+  "flow-field": defineStrategy({
+    step: "highway",
+    name: "flow-field",
+    describe: "A flow field for each target (EDA-046, HWY-037). The edges into one side of a box merge like streams on shortest ways to one root.",
+    defaults: { ...FLOW_FIELD_DEFAULTS } as FlowFieldOptions,
+    schema: FLOW_FIELD_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FlowFieldOptions>) => flowFieldPlan(input, o),
+  }),
+  wspd: defineStrategy({
+    step: "highway",
+    name: "wspd",
+    describe: "Well-separated pairs (HWY-018). The edges between the two sets of one pair share one highway.",
+    defaults: { ...WSPD_DEFAULTS } as WspdOptions,
+    schema: WSPD_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<WspdOptions>) => wspdPlan(input, o),
+  }),
+  "od-cells": defineStrategy({
+    step: "highway",
+    name: "od-cells",
+    describe: "Origin and destination cells (EDA-033, WILD-032). The edges between two cells of a zoom level share one trunk.",
+    defaults: { ...OD_CELL_DEFAULTS } as OdCellOptions,
+    schema: OD_CELL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<OdCellOptions>) => odCellPlan(input, o),
+  }),
+  select: defineStrategy({
     step: "highway",
-    name: "corridors",
-    describe: "Corridor signatures. Edges whose first ways share long links make a cluster, found with MinHash. The longest common run of each cluster is its highway.",
-    defaults: { ...CORRIDOR_DEFAULTS } as CorridorOptions,
-    schema: CORRIDOR_SCHEMA,
+    name: "select",
+    describe: "Candidate generation and selection (HWY-045). Some strategies propose highways, and a greedy pass with swaps keeps the best set.",
+    defaults: { ...SELECT_DEFAULTS } as SelectOptions,
+    schema: SELECT_SCHEMA,
     maxNodes: 10_000,
-    run: (input: HighwayInput, o: Readonly<CorridorOptions>) => corridorPlan(input, o),
+    run: (input: HighwayInput, o: Readonly<SelectOptions>) => selectPlan(input, o),
   }),
+  "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
+  "corridors+stretch": gateStrategy(corridors, stretchGate),
+  "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
+  "corridors+hysteresis": gateStrategy(corridors, hysteresisGate),
+  "corridors+ids": gateStrategy(corridors, stableIdGate),
 });
 
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */

package/src/strategies/schemas.ts

@@ -1,12 +1,26 @@
 import type { CutOptions } from "../groups/cut/index.ts";
 import type { KdOptions } from "../groups/kd/index.ts";
 import type { KeyOptions } from "../groups/keys/index.ts";
+import type { HighwayBase } from "../highways/base.ts";
 import type { CorridorOptions } from "../highways/corridors/index.ts";
+import type { FlowFieldOptions } from "../highways/flow-field/index.ts";
+import type { GroupSpine } from "../highways/grouped.ts";
+import type { LevelHighwayOptions } from "../highways/level-links/index.ts";
+import type { MeetOptions } from "../highways/meet/index.ts";
+import type { OdCellOptions } from "../highways/od-cells/index.ts";
+import type { QuickBundlesOptions } from "../highways/quickbundles/index.ts";
+import type { RoadClassOptions } from "../highways/road-classes/index.ts";
+import type { SelectOptions } from "../highways/select/index.ts";
+import type { StubOptions } from "../highways/stubs/index.ts";
+import type { WeiszfeldOptions } from "../highways/weiszfeld/index.ts";
+import type { WspdOptions } from "../highways/wspd/index.ts";
+import type { ZipperOptions } from "../highways/zipper/index.ts";
 import type { CornersOptions } from "../routers/corners.ts";
 import type { SectionsOptions } from "../routers/sections.ts";
 import type { SharedOptions } from "../routers/shared.ts";
 import type { TrunksOptions } from "../routers/trunks.ts";
 import type { SectionOptions } from "../sections.ts";
+import type { WayOptions } from "../ways.ts";
 import type { RunOrder } from "../segments.ts";
 import type { ClothoidStrategyOptions, HighwayStrategyOptions, LevelRoomPreset, RadiusOptions, RoomPreset, RouterPreset, SmoothStrategyOptions, TensionOptions } from "./builtins.ts";
 import type { EnumOption, OptionSchema } from "./options.ts";
@@ -15,7 +29,7 @@ import type { EnumOption, OptionSchema } from "./options.ts";
 // The test of the defaults runs each strategy with `optionDefaults` and with no option, and compares the output.
 
 /** The options of the way finder (`WayOptions`), for each router that goes around the nodes. */
-const WAY_SCHEMA: OptionSchema<RouterPreset<CornersOptions>> = {
+const WAY_SCHEMA: OptionSchema<WayOptions> = {
   margin: { type: "number", min: 1, max: 20, step: 1, default: 5, describe: "The distance from a box to the corners of the graph." },
   k: { type: "integer", min: 2, max: 16, step: 1, default: 8, describe: "The number of visible neighbours of each corner." },
   smooth: { type: "boolean", default: false, describe: "With `true`, a way in clear view uses the inflection rule, and the other ways get round corners." },
@@ -33,7 +47,23 @@ const LANE_ORDER: EnumOption<RunOrder> = {
 const RUN_LANE_ORDER: EnumOption<RunOrder> = { ...LANE_ORDER, default: "run" };
 
 /** The declarations of the options of the routers `corners` and `corners-smooth`. */
-export const CORNERS_SCHEMA: OptionSchema<RouterPreset<CornersOptions>> = WAY_SCHEMA;
+export const CORNERS_SCHEMA: OptionSchema<RouterPreset<CornersOptions>> = {
+  ...WAY_SCHEMA,
+  plugs: {
+    type: "enum",
+    values: ["facing", "side"],
+    default: "facing",
+    describe: "With `facing`, a free plug faces the other end. With `side`, the search starts from the whole free side, and the plug goes where the way leaves (WILD-001).",
+  },
+  plugGap: {
+    type: "number",
+    min: 0,
+    max: 24,
+    step: 1,
+    default: 0,
+    describe: "With a gap above 0, the free plugs of a side keep their order and at least this gap (WILD-002). 0 keeps each plug where it is.",
+  },
+};
 
 /** The declarations of the options of the router `trunks`. */
 export const TRUNKS_SCHEMA: OptionSchema<RouterPreset<TrunksOptions>> = {
@@ -48,6 +78,20 @@ export const TRUNKS_SCHEMA: OptionSchema<RouterPreset<TrunksOptions>> = {
     default: "part",
     describe: "With `part`, a lane leaves the trunk where its way parts from the other ways. With `split`, each lane leaves at the split point.",
   },
+  splitAt: {
+    type: "enum",
+    values: ["share", "gilbert"],
+    default: "share",
+    describe: "With `share`, the split point is at `split` of the way. With `gilbert`, it is where the flow cost is least (EDA-030).",
+  },
+  alpha: { type: "number", min: 0, max: 1, step: 0.05, default: 0.5, describe: "The exponent of the flow cost of the split `gilbert`. A smaller value moves the split toward the targets." },
+  fan: {
+    type: "enum",
+    values: ["split", "tree"],
+    default: "split",
+    describe: "With `split`, the edges of a group share a trunk to a split point. With `tree`, they grow a balancing-factor tree (NAT-017).",
+  },
+  bf: { type: "number", min: 0, max: 1, step: 0.05, default: 0.4, describe: "The balancing factor of the fan `tree`. 0 gives the least ink, and a larger factor gives more direct routes." },
 };
 
 /** The declarations of the options of the routers `shared` and `shared-all`. */
@@ -63,6 +107,26 @@ export const SHARED_SCHEMA: OptionSchema<RouterPreset<SharedOptions>> = {
     describe: "The cost of a link that an edge with the same key uses already, as a share of its length.",
   },
   laneOrder: LANE_ORDER,
+  cost: {
+    type: "enum",
+    values: ["fixed", "flow"],
+    default: "fixed",
+    describe: "With `fixed`, a shared link costs `discount` of its length. With `flow`, a link with `f` edges costs `len * f^alpha` (EDA-029).",
+  },
+  alpha: { type: "number", min: 0.1, max: 1, step: 0.05, default: 0.6, describe: "The exponent of the cost `flow`. A smaller value gives more sharing." },
+  passes: { type: "integer", min: 1, max: 5, step: 1, default: 1, describe: "In each pass after the first, each edge finds its way again with the ways of the other edges fixed (HWY-039)." },
+  order: {
+    type: "enum",
+    values: ["span", "shortest", "load", "input"],
+    default: "span",
+    describe: "The order of the edges of a key: the longest first, the shortest first, the most edges between two sections first, or the input order (NAT-024).",
+  },
+  merge: {
+    type: "enum",
+    values: ["corner", "snell"],
+    default: "corner",
+    describe: "With `corner`, a route joins a run at a corner of the graph. With `snell`, it joins at the angle `acos(d)` (NAT-035).",
+  },
 };
 
 /** The declarations of the options of the highway strategy `corridors` (HWY-031). */
@@ -232,3 +296,110 @@ export const CUT_SCHEMA: OptionSchema<CutOptions> = {
   pull: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 0.5, 1, 2, 4], default: 0.5, describe: "The cost of a line grows with its distance from the middle of the cell, by this factor." },
   guard: { type: "boolean", default: true, describe: "With `true`, each section also tests the quadtree split, and keeps the split that cuts fewer edges." },
 };
+
+/** The declaration of the plan that a post step of the step `highway` changes (BUILD-W2B). */
+const HIGHWAY_BASE: EnumOption<HighwayBase> = {
+  type: "enum",
+  values: ["none", "shared-ways", "corridors"],
+  default: "shared-ways",
+  describe: "The plan that the strategy changes: no highway, the highways of `shared-ways`, or the highways of `corridors`.",
+};
+
+/** The declarations of the options of the highway strategy `meet` (HWY-050). */
+export const MEET_SCHEMA: OptionSchema<MeetOptions> = {
+  from: HIGHWAY_BASE,
+  near: { type: "number", min: 2, max: 40, step: 2, default: 8, describe: "A first route meets the spine where it is this distance from the spine, or nearer." },
+  maxTurn: { type: "number", min: 10, max: 90, step: 5, default: 45, describe: "A first route meets the spine only where it runs at this angle to the spine, or less, in degrees." },
+  minRun: { type: "number", min: 0, max: 80, step: 5, default: 10, describe: "A member keeps its places when the stretch where its first route meets the spine is shorter than this length." },
+};
+
+/** The declarations of the options of the highway strategy `weiszfeld` (HWY-043). */
+export const WEISZFELD_SCHEMA: OptionSchema<WeiszfeldOptions> = {
+  from: HIGHWAY_BASE,
+  alpha: { type: "number", min: 0, max: 1, step: 0.1, default: 0.5, describe: "The weight of the trunk is `k^alpha` for `k` members." },
+  steps: { type: "integer", min: 1, max: 50, step: 1, marks: [10, 20, 50], default: 20, describe: "The number of steps of Weiszfeld." },
+};
+
+/** The declarations of the options of the highway strategy `stubs` (HWY-015 with WILD-005). */
+export const STUB_SCHEMA: OptionSchema<StubOptions> = {
+  from: HIGHWAY_BASE,
+  omega: { type: "number", min: 10, max: 60, step: 5, default: 30, describe: "The ends of one side of a box whose directions are in a window of this angle share a stub, in degrees." },
+  sigma: { type: "number", min: 0.1, max: 0.4, step: 0.05, default: 0.25, describe: "The length of a stub is this share of the distance to the nearest other end." },
+  ends: { type: "enum", values: ["source", "target", "both"], default: "both", describe: "The ends that get stubs." },
+  minSize: { type: "integer", min: 2, max: 8, step: 1, default: 2, describe: "A stub has this number of edges or more." },
+};
+
+/** The declarations of the options of the highway strategy `zipper` (NAT-022 with WILD-037). */
+export const ZIPPER_SCHEMA: OptionSchema<ZipperOptions> = {
+  from: HIGHWAY_BASE,
+  near: { type: "number", min: 0.5, max: 3, step: 0.25, default: 1, describe: "Two legs zip when they are this distance apart or nearer, in units of the board." },
+  maxAngle: { type: "number", min: 5, max: 30, step: 5, default: 15, describe: "Two legs zip when the angle between them is this value or less, in degrees." },
+  adhesion: { type: "number", min: 0, max: 1, step: 0.1, default: 0.3, describe: "Two legs zip when this value times their overlap is more than the length that the zip adds." },
+  minOverlap: { type: "number", min: 1, max: 5, step: 0.5, default: 1, describe: "Two legs zip when they overlap along this length or more, in units of the board." },
+  passes: { type: "integer", min: 1, max: 5, step: 1, default: 1, describe: "The number of passes. Each pass routes the plan and zips the legs again." },
+};
+
+/** The declarations of the options of the highway strategy `level-links` (HWY-056 with WILD-034). */
+export const LEVEL_HIGHWAY_SCHEMA: OptionSchema<LevelHighwayOptions> = {
+  from: HIGHWAY_BASE,
+  depth: { type: "integer", min: 1, max: 3, step: 1, default: 1, describe: "The depth of the level in the tree of sections." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A level link becomes a highway when this number of edges or more ride it." },
+  stretch: { type: "number", min: 1.2, max: 2, step: 0.1, default: 1.5, describe: "An edge rides the link only when its way along the link is this many times its first route, or shorter." },
+};
+
+/** The declaration of the spine of a group of edges: the shared ways of the group, or one trunk between two terminals. */
+const GROUP_SPINE: EnumOption<GroupSpine> = {
+  type: "enum",
+  values: ["shared", "trunk"],
+  default: "shared",
+  describe: "With `shared`, the edges of a group share their ways through the corner graph. With `trunk`, a group gets one trunk between two terminals.",
+};
+
+/** The declarations of the options of the highway strategy `quickbundles` (HWY-026). */
+export const QUICKBUNDLES_SCHEMA: OptionSchema<QuickBundlesOptions> = {
+  theta: { type: "number", min: 1, max: 10, step: 0.5, marks: [1.5, 3, 6], default: 3, describe: "An edge joins a cluster when its distance to the centroid is this value or less, in units of the board." },
+  points: { type: "integer", min: 6, max: 24, step: 2, default: 12, describe: "The number of points of each line after the resampling." },
+  line: { type: "enum", values: ["routes", "lines"], default: "routes", describe: "The line of each edge: its first route, or the straight line between its plugs." },
+  order: { type: "enum", values: ["input", "length"], default: "input", describe: "The order of the edges in the pass: the order of the graph, or the longest line first." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A cluster with this number of edges or more gets highways." },
+  spine: GROUP_SPINE,
+};
+
+/** The declarations of the options of the highway strategy `road-classes` (HWY-034 with EDA-050). */
+export const ROAD_CLASS_SCHEMA: OptionSchema<RoadClassOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  quantile: { type: "number", min: 0.5, max: 0.99, step: 0.05, marks: [0.8, 0.9, 0.95], default: 0.9, describe: "A link is a highway link when its use is at this quantile of the use of the links, or higher." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway link and a highway have this number of edges or more." },
+  discount: { type: "number", min: 0.1, max: 0.8, step: 0.1, default: 0.5, describe: "The second pass gives each highway link this discount, as a share of its length." },
+};
+
+/** The declarations of the options of the highway strategy `flow-field` (EDA-046 with HWY-037). */
+export const FLOW_FIELD_SCHEMA: OptionSchema<FlowFieldOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  minFanIn: { type: "integer", min: 2, max: 10, step: 1, default: 2, describe: "An end with this number of edges or more on one side of its box gets a field." },
+  end: { type: "enum", values: ["target", "source"], default: "target", describe: "The end that gets a field: the target of a fan-in, or the source of a fan-out." },
+};
+
+/** The declarations of the options of the highway strategy `wspd` (HWY-018). */
+export const WSPD_SCHEMA: OptionSchema<WspdOptions> = {
+  separation: { type: "number", min: 1, max: 8, step: 0.5, marks: [1, 2, 4], default: 2, describe: "The gap between the two sets of a pair is at least this value times the radius of the larger set." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 3, describe: "A pair with this number of edges or more gets a highway." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `od-cells` (EDA-033 with WILD-032). */
+export const OD_CELL_SCHEMA: OptionSchema<OdCellOptions> = {
+  level: { type: "integer", min: 1, max: 4, step: 1, default: 2, describe: "The depth of the cells in the tree of sections." },
+  minGroup: { type: "integer", min: 2, max: 8, step: 1, default: 3, describe: "A pair of cells with this number of edges or more gets a trunk." },
+  legMax: { type: "number", min: 0.1, max: 1, step: 0.05, marks: [0.2, 0.3, 0.4], default: 0.3, describe: "An edge rides the trunk only when each of its legs is this share of the span or shorter." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `select` (HWY-045). */
+export const SELECT_SCHEMA: OptionSchema<SelectOptions> = {
+  generators: { type: "list", default: ["corridors", "quickbundles", "wspd", "road-classes"], describe: "The highway strategies that propose the candidates." },
+  lambda: { type: "number", min: 0, max: 4, step: 0.25, marks: [0.5, 1, 2], default: 1, describe: "The weight of the added length of the edges against the ink that a highway saves." },
+  swaps: { type: "integer", min: 0, max: 5, step: 1, default: 2, describe: "The number of passes of the local search with one swap." },
+};