@mark1russell7/highways 0.3.0 → 0.4.1

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

@@ -1,7 +1,9 @@
 import { arcCurve, type ArcOptions } from "../curves/arc/index.ts";
 import { clothoidCurve, type ClothoidOptions } from "../curves/clothoid/index.ts";
-import { highwayCurve, type JogStyle } from "../curves/highway/index.ts";
+import { highwayCurve, highwayCurves, type JogStyle, type LaneCurve } from "../curves/highway/index.ts";
+import type { CurveSegment } from "../curves/model.ts";
 import { roundedCurve, type RoundedOptions } from "../curves/rounded/index.ts";
+import type { CurveSpace } from "../curves/space.ts";
 import { smoothCurve, type SmoothOptions } from "../curves/smooth/index.ts";
 import { splineCurve, type SplineOptions } from "../curves/spline/index.ts";
 import { straightCurve } from "../curves/straight/index.ts";
@@ -9,6 +11,10 @@ import { CUT_DEFAULTS, cutGroups, type CutOptions } from "../groups/cut/index.ts
 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 { keysPlan, type KeysOptions } from "../highways/keys/index.ts";
+import type { HighwayInput } from "../highways/model.ts";
+import { sharedWaysPlan, type SharedWaysOptions } from "../highways/shared-ways/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";
@@ -19,9 +25,9 @@ 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 { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type Registry, type Strategy } from "./model.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, 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, 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";
 
 /** 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">;
@@ -130,7 +136,10 @@ export interface TensionOptions {
   readonly tension: number;
 }
 
-/** The options of the curve strategy `highway`. */
+/**
+ * The options of the curve strategy `highway`. The options `minRadius`, `jog` and `jogPieces` change only the lanes of a bundle.
+ * So they change the curve only when the input has a `lane` on a board with open segments.
+ */
 export interface HighwayStrategyOptions {
   /** The radius of the center line of a bundle at a bend, and of each lone corner. The default is 12. */
   readonly radius: number;
@@ -142,6 +151,33 @@ export interface HighwayStrategyOptions {
   readonly jogPieces: number;
 }
 
+/** The curves of the lanes of each board, for the last options and the last free space. The strategy `highway` draws one lane in each call. */
+const laneCurves = new WeakMap<LaneBoard, { readonly key: string; readonly space: CurveSpace | undefined; readonly curves: LaneCurve[] }>();
+
+/**
+ * This function gives the curve of one lane of a board with `highwayCurves` and each option of the strategy `highway`.
+ * The lanes of a bundle bend as one. So the function draws all the lanes of the board one time, and keeps them for the next lane.
+ */
+function highwayLane(input: CurveInput & Required<Pick<CurveInput, "lane">>, o: Readonly<HighwayStrategyOptions>): CurveSegment[] {
+  const { board, index } = input.lane;
+  const key = JSON.stringify([o.radius, o.minRadius, o.jog, o.jogPieces]);
+  let hit = laneCurves.get(board);
+  if (!hit || hit.key !== key || hit.space !== input.space) {
+    const curves = highwayCurves(board.graph, board.open, board.width, {
+      radius: o.radius,
+      minRadius: o.minRadius,
+      jog: o.jog,
+      jogPieces: o.jogPieces,
+      ...(board.maxWidth === undefined ? {} : { maxWidth: board.maxWidth }),
+      ...(input.space ? { space: input.space } : {}),
+    });
+    hit = { key, space: input.space, curves };
+    laneCurves.set(board, hit);
+  }
+  const lane = hit.curves[index];
+  return lane ? [...lane.segments] : highwayCurve(input.points, { radius: o.radius, ...(input.space ? { space: input.space } : {}) });
+}
+
 /** The options of the curve strategy `smooth`. */
 export interface SmoothStrategyOptions {
   /** The radius of the arc of each corner. The default is 12. */
@@ -162,7 +198,7 @@ export interface ClothoidStrategyOptions {
 
 /**
  * The built-in curve strategies. The first six are in the order of `CURVE_TYPES`, and each one gives the same segments as `curveOf` with its type.
- * The strategy `highway` gives the curve of `arc` for one polyline. `highwayCurves` bends the lanes of a bundle as one.
+ * The strategy `highway` gives the curve of `arc` for one polyline. For a polyline with a `lane`, it bends the lanes of each bundle as one with `highwayCurves`.
  */
 export const curveStrategies: {
   readonly straight: Strategy<"curve", object>;
@@ -227,7 +263,8 @@ export const curveStrategies: {
     describe: "The lanes of a bundle bend as one, with concentric arcs at the lane spacing. One lane alone gets the curve of `arc`.",
     defaults: { radius: 12, minRadius: 4, jog: "biarc" as JogStyle, jogPieces: 4 },
     schema: HIGHWAY_SCHEMA,
-    run: (input: CurveInput, o: Readonly<HighwayStrategyOptions>) => highwayCurve(input.points, { radius: o.radius, ...(input.space ? { space: input.space } : {}) }),
+    run: (input: CurveInput, o: Readonly<HighwayStrategyOptions>) =>
+      input.lane ? highwayLane({ ...input, lane: input.lane }, o) : highwayCurve(input.points, { radius: o.radius, ...(input.space ? { space: input.space } : {}) }),
   }),
 });
 
@@ -303,10 +340,49 @@ export const groupStrategies: {
   }),
 });
 
+/**
+ * The built-in highway strategies: the decisions of the routers `trunks` and `shared` as plans, and corridor signatures (HWY-031).
+ * `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>;
+} = Object.freeze({
+  keys: defineStrategy({
+    step: "highway",
+    name: "keys",
+    describe: "The highways of the router `trunks`. The edges from one plug with one key share a trunk, and the edges that go on together share a run past it.",
+    defaults: { rule: byCollection } as KeysOptions,
+    schema: TRUNKS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<KeysOptions>) => keysPlan(input, o),
+  }),
+  "shared-ways": defineStrategy({
+    step: "highway",
+    name: "shared-ways",
+    describe: "The highways of the router `shared`. The edges of one key share their ways through the corner graph, and each shared stretch is a highway.",
+    defaults: { rule: byCollection } as SharedWaysOptions,
+    schema: SHARED_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SharedWaysOptions>) => sharedWaysPlan(input, o),
+  }),
+  corridors: 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 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(highwayStrategies),
   ...Object.values(curveStrategies),
   ...Object.values(roomStrategies),
 ]);

package/src/strategies/model.ts

@@ -1,9 +1,11 @@
 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 { Boxed, Gap, RoomLink } from "../room/index.ts";
 import type { Section } from "../sections.ts";
+import type { SegmentGraph } from "../segments.ts";
 import type { OptionSchema } from "./options.ts";
 
 /** The input of a curve strategy: one polyline and the context of its route. */
@@ -16,6 +18,23 @@ export interface CurveInput {
   readonly endNormal?: Point;
   /** The boxes that the curve must not go through, from `curveSpace`. */
   readonly space?: CurveSpace;
+  /**
+   * The lane of the polyline on its board, for a strategy that bends the lanes of a bundle as one. Then `points` is the route of `laneRoutes` with the index `index`.
+   * The other strategies do not read it.
+   */
+  readonly lane?: { readonly board: LaneBoard; readonly index: number };
+}
+
+/** The lanes of the bundles of one board: the input of `laneRoutes` and `highwayCurves`. */
+export interface LaneBoard {
+  /** The shared segments and the paths of the routes, from `segmentsOf`. */
+  readonly graph: SegmentGraph;
+  /** The keys of the open segments, from `runKey`. Each edge of an open segment gets its own lane. */
+  readonly open: ReadonlySet<string>;
+  /** The distance between two lanes of an open segment. */
+  readonly width: number;
+  /** The largest width of an open segment, from its outer lane to its outer lane. The default is `Infinity`. */
+  readonly maxWidth?: number;
 }
 
 /** The input of a room strategy: the boxes of a board and the links between them. */
@@ -34,12 +53,14 @@ export interface RoomInput {
  *
  * - `group`: a graph in, the tree of sections out. The router `sections` makes its hubs and its zoom levels from this tree.
  * - `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.
  * - `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.
  */
 export interface StepTypes {
   readonly group: { readonly input: Graph; readonly output: Section };
   readonly router: { readonly input: Graph; readonly output: Result };
+  readonly highway: { readonly input: HighwayInput; readonly output: HighwayPlan };
   readonly curve: { readonly input: CurveInput; readonly output: CurveSegment[] };
   readonly room: { readonly input: RoomInput; readonly output: Gap[] };
 }
@@ -54,7 +75,7 @@ export type StepInput<S extends Step> = StepTypes[S]["input"];
 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", "curve", "room"];
+export const STEPS: readonly Step[] = ["group", "router", "highway", "curve", "room"];
 
 /**
  * A strategy: one way to do one step, with a name and a description.
@@ -126,25 +147,34 @@ 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 list `group` is optional in the type, so a registry from version 0.1.5 stays a registry. `createRegistry` always gives it.
+ * 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.
  */
-export type Registry = { readonly [S in Exclude<Step, "group">]: readonly Strategy<S>[] } & { readonly group?: readonly Strategy<"group">[] };
+export type Registry = { readonly [S in Exclude<Step, "group" | "highway">]: readonly Strategy<S>[] } & {
+  readonly group?: readonly Strategy<"group">[];
+  readonly highway?: readonly Strategy<"highway">[];
+};
 
 /** 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: [], curve: [], room: [] };
+  const out: { [S in Step]: Strategy<S>[] } = { group: [], router: [], highway: [], curve: [], room: [] };
   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(", ")}.`);
     if (list.some((t) => t.name === s.name)) throw new Error(`The step "${s.step}" has two strategies with the name "${s.name}".`);
     list.push(s);
   }
-  return Object.freeze({ group: Object.freeze(out.group), router: Object.freeze(out.router), curve: Object.freeze(out.curve), room: Object.freeze(out.room) });
+  return Object.freeze({
+    group: Object.freeze(out.group),
+    router: Object.freeze(out.router),
+    highway: Object.freeze(out.highway),
+    curve: Object.freeze(out.curve),
+    room: Object.freeze(out.room),
+  });
 }
 
 /** 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.curve, ...registry.room, ...strategies]);
+  return createRegistry([...(registry.group ?? []), ...registry.router, ...(registry.highway ?? []), ...registry.curve, ...registry.room, ...strategies]);
 }
 
 /** This function gives the strategies of one step of a registry, in order. */

package/src/strategies/schemas.ts

@@ -1,11 +1,13 @@
 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 { CorridorOptions } from "../highways/corridors/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";
@@ -14,7 +16,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." },
@@ -32,7 +34,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>> = {
@@ -47,6 +65,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`. */
@@ -62,6 +94,38 @@ 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). */
+export const CORRIDOR_SCHEMA: OptionSchema<CorridorOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  rho: { type: "number", min: 0.1, max: 0.8, step: 0.05, default: 0.3, describe: "Two edges join when their common links are this share of the shorter way, or longer." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway has this number of edges or more." },
+  hashes: { type: "integer", min: 16, max: 128, step: 16, scale: "log", marks: [16, 32, 64, 128], default: 64, describe: "The number of hash functions of the signature of a way." },
+  bands: { type: "integer", min: 4, max: 32, step: 4, scale: "log", marks: [4, 8, 16, 32], default: 32, describe: "The number of bands of the signature. Two ways with one equal band are a candidate pair." },
+  near: { type: "number", min: 0, max: 8, step: 1, default: 0, describe: "Two link ends nearer than this grid size are one point. With 0, only equal points are one point." },
+  lane: { type: "number", min: 1, max: 16, step: 1, default: 4, describe: "The gap between two lanes. A common stretch shorter than the break-even overlap for this gap does not join two edges." },
 };
 
 /** The declarations of the limits of the tree of sections (`SectionOptions`). */