@mark1russell7/highways 0.4.0 → 0.4.1

package/src/routers/shared.ts

@@ -1,8 +1,19 @@
 import { center, dist, type Point } from "../geom.ts";
 import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
+import { buildSections, type Section } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
+import { snellMerges } from "./snell.ts";
+
+/** The cost of a link that edges of one key share: a fixed discount, or the flow cost `len * f^alpha` (EDA-029). */
+export type ShareCost = "fixed" | "flow";
+
+/** The order of the edges of one key: the longest first, the shortest first, the most load first, or the order of the input (NAT-024). */
+export type ShareOrder = "span" | "shortest" | "load" | "input";
+
+/** The place where a route joins or leaves a run: at a corner of the graph, or at the Snell angle (NAT-035). */
+export type ShareMerge = "corner" | "snell";
 
 /** The options of the router with shared ways. */
 export interface SharedOptions extends WayOptions {
@@ -14,11 +25,31 @@ export interface SharedOptions extends WayOptions {
   readonly discount?: number;
   /** The lane order of the runs. With `bundle`, the default, two edges keep one order on each run of their common stretch. With `run`, each run gets its order alone. */
   readonly laneOrder?: RunOrder;
+  /**
+   * The cost of a shared link. With `fixed`, the default, a link that the key uses already costs `discount` times its length.
+   * With `flow`, one more edge on a link with `f` edges costs `len * ((f + 1)^alpha - f^alpha)` (EDA-029).
+   */
+  readonly cost?: ShareCost;
+  /** The exponent of the flow cost, from 0.1 to 1. A smaller value gives more sharing. The default is 0.6. Only the cost `flow` uses it. */
+  readonly alpha?: number;
+  /** The number of passes. In each pass after the first, each edge leaves its links and finds its way again with the others fixed (HWY-039). The default is 1. */
+  readonly passes?: number;
+  /**
+   * The order of the edges of one key. With `span`, the default, the longest edge goes first. With `shortest`, the shortest edge goes first.
+   * With `load`, the edge with the most edges between its two sections goes first. With `input`, the edges keep the order of the graph (NAT-024).
+   */
+  readonly order?: ShareOrder;
+  /**
+   * The place where a route joins or leaves a run. With `corner`, the default, it is a corner of the graph.
+   * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
+   */
+  readonly merge?: ShareMerge;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
-interface Way {
+/** A way of one edge through the corner graph. */
+export interface Way {
   readonly edge: Edge;
   readonly key: string;
   readonly ps: Plug;
@@ -58,6 +89,11 @@ function turn(from: Point, base: Point, to: Point): number {
  */
 export function sharedRouter(options: SharedOptions): Router {
   const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
+  const flow = options.cost === "flow";
+  const alpha = Math.min(1, Math.max(0.1, options.alpha ?? 0.6));
+  // The cost share of a link for one more edge, when `f` edges of the key use it already. The share falls when `f` grows.
+  const share = (f: number): number => (f <= 0 ? 1 : flow ? (f + 1) ** alpha - f ** alpha : discount);
+  const passes = Math.max(1, Math.floor(options.passes ?? 1));
   const keyOf = (e: Edge): string => {
     if (!options.rule) return "*";
     return options.rule(e) ?? `\u0000${e.id}`;
@@ -90,17 +126,21 @@ export function sharedRouter(options: SharedOptions): Router {
         all.push({ edge: e, key: keyOf(e), ps, pt, seq: [], ids: [], found: false });
       }
 
-      // The edges of one key go one after the other, the longest first, so that the short edges join the long ways.
+      // The edges of one key go one after the other, by default the longest first, so that the short edges join the long ways.
       const discounted = new Map<string, Map<number, string[]>>();
-      const order = [...all].sort(
-        (p, q) => byText(p.key, q.key) || dist(q.ps.point, q.pt.point) - dist(p.ps.point, p.pt.point) || byText(p.edge.id, q.edge.id),
-      );
-      for (const w of order) {
+      const order = orderWays(all, options.order ?? "span", graph);
+      // The largest number of edges on one link of each key. The cost share of that number is the floor of the search.
+      const top = new Map<string, number>();
+      const route = (w: Way): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
-        const way = corners.path(ways.out(w.ps), ways.out(w.pt), (i, j, d) => (mine.has(link(i, j)) ? d * discount : d), discount);
-        if (!way) continue;
+        const floor = flow ? share(top.get(w.key) ?? 0) : discount;
+        const cost = flow
+          ? (i: number, j: number, d: number): number => d * share(mine.get(link(i, j))?.length ?? 0)
+          : (i: number, j: number, d: number): number => (mine.has(link(i, j)) ? d * discount : d);
+        const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
+        if (!way) return;
         w.found = true;
         w.seq = way;
         w.ids = way.map((p, i) => (i === 0 || i === way.length - 1 ? endId(p) : index.get(p)!));
@@ -111,7 +151,37 @@ export function sharedRouter(options: SharedOptions): Router {
           const list = mine.get(link(a, b));
           if (list) list.push(w.edge.id);
           else mine.set(link(a, b), [w.edge.id]);
+          if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b))!.length));
         }
+      };
+      for (const w of order) route(w);
+      // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
+      for (let pass = 1; pass < passes; pass++) {
+        for (const w of order) {
+          if (!w.found) continue;
+          const mine = discounted.get(w.key)!;
+          for (let i = 1; i < w.ids.length; i++) {
+            const a = w.ids[i - 1]!;
+            const b = w.ids[i]!;
+            if (a >= corners.points.length || b >= corners.points.length) continue;
+            const k = link(a, b);
+            const list = mine.get(k);
+            if (!list) continue;
+            const at = list.indexOf(w.edge.id);
+            if (at >= 0) list.splice(at, 1);
+            if (list.length === 0) mine.delete(k);
+          }
+          w.found = false;
+          w.seq = [];
+          w.ids = [];
+          route(w);
+        }
+      }
+
+      // With `merge: snell`, each route that joins or leaves a run moves its merge point along the run to the Snell angle.
+      if (options.merge === "snell") {
+        const pad = ways.margin / 2;
+        snellMerges(order, corners.points.length + ends.size, (a, b) => ways.obstacles.clear(a, b, pad), (f) => Math.min(0.95, share(f)));
       }
 
       // The users of each link, with the links to the ends. Two edges from one plug share the link from it.
@@ -185,6 +255,35 @@ export function sharedRouter(options: SharedOptions): Router {
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
 
+/**
+ * This function gives the order of the ways for the router `shared`. The ways of one key stay together, in the order of the keys.
+ * In a key, the order is `order`, and the edge id breaks each tie. The order `load` counts the edges of the key between the same two sections.
+ */
+function orderWays(all: readonly Way[], order: ShareOrder, graph: Graph): Way[] {
+  const span = (w: Way): number => dist(w.ps.point, w.pt.point);
+  if (order === "input") {
+    const at = new Map(all.map((w, i) => [w, i]));
+    return [...all].sort((p, q) => byText(p.key, q.key) || at.get(p)! - at.get(q)!);
+  }
+  if (order === "shortest") return [...all].sort((p, q) => byText(p.key, q.key) || span(p) - span(q) || byText(p.edge.id, q.edge.id));
+  if (order === "span") return [...all].sort((p, q) => byText(p.key, q.key) || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+  // The leaf section of each node, then the number of edges of each key between each pair of leaves.
+  const leafOf = new Map<string, string>();
+  const walk = (s: Section): void => {
+    if (s.children.length === 0) for (const i of s.nodes) leafOf.set(graph.nodes[i]!.id, s.id);
+    for (const c of s.children) walk(c);
+  };
+  walk(buildSections(graph.nodes));
+  const pair = (w: Way): string => {
+    const a = leafOf.get(w.edge.source.node) ?? "";
+    const b = leafOf.get(w.edge.target.node) ?? "";
+    return `${w.key}\u0000${a < b ? a : b}\u0000${a < b ? b : a}`;
+  };
+  const load = new Map<string, number>();
+  for (const w of all) load.set(pair(w), (load.get(pair(w)) ?? 0) + 1);
+  return [...all].sort((p, q) => byText(p.key, q.key) || load.get(pair(q))! - load.get(pair(p))! || span(q) - span(p) || byText(p.edge.id, q.edge.id));
+}
+
 /**
  * This function gives the lane order of a run with the option `laneOrder: "run"` (metro-line order). Two edges of the run go together past its last corner
  * until they part. The edge that turns more to the left there gets the lane more to the left.

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/schemas.ts

@@ -7,6 +7,7 @@ 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 +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." },
@@ -33,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>> = {
@@ -48,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`. */
@@ -63,6 +94,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). */