@mark1russell7/highways 0.4.1 → 0.4.2

package/src/highways/weiszfeld/index.ts

@@ -0,0 +1,105 @@
+import { dist, type Point } from "../../geom.ts";
+import { basePlan, nearestPlace, planRoutes, routeIndex, tidyPlan, tripsOf, type HighwayBase } from "../base.ts";
+import { memberAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `weiszfeld` (HWY-043 of the note on highways). */
+export interface WeiszfeldOptions {
+  /** The plan whose highways get new meeting points. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The weight of the trunk is `k^alpha` for `k` members. With 0, the trunk costs its ink one time. With 1, it costs each lane. The default is 0.5. */
+  readonly alpha: number;
+  /** The number of steps of Weiszfeld. The default is 20. */
+  readonly steps: number;
+}
+
+/** The default options of the strategy `weiszfeld`. */
+export const WEISZFELD_DEFAULTS: Readonly<WeiszfeldOptions> = Object.freeze({ from: "shared-ways", alpha: 0.5, steps: 20 });
+
+const TINY = 1e-9;
+
+/** This function gives one step of Weiszfeld for the point `m`. The point `m` is near the points `ends`, and tied to `other` with the weight `w`. */
+function weiszfeldStep(m: Point, ends: readonly Point[], other: Point, w: number): Point {
+  let x = 0;
+  let y = 0;
+  let sum = 0;
+  for (const p of ends) {
+    const d = Math.max(TINY, dist(p, m));
+    x += p.x / d;
+    y += p.y / d;
+    sum += 1 / d;
+  }
+  const d = Math.max(TINY, dist(other, m));
+  x += (w * other.x) / d;
+  y += (w * other.y) / d;
+  sum += w / d;
+  return sum > 0 ? { x: x / sum, y: y / sum } : m;
+}
+
+/** This function gives the mean of a list of points that is not empty. */
+const mean = (ps: readonly Point[]): Point => ({ x: ps.reduce((s, p) => s + p.x, 0) / ps.length, y: ps.reduce((s, p) => s + p.y, 0) / ps.length });
+
+/**
+ * This function gives the meeting points `M1` and `M2` of a bundle with the least weighted ink (HWY-043):
+ * `Σ |a_i - M1| + w |M1 - M2| + Σ |M2 - b_i|`. The lists `a` and `b` are the ends of the edges on each side, and `w` is the weight of the trunk.
+ * The function starts at the means of `a` and `b`. Each step moves `M1` and then `M2` by one step of Weiszfeld.
+ */
+export function meetingPoints(a: readonly Point[], b: readonly Point[], w: number, steps: number): [Point, Point] {
+  if (a.length === 0 || b.length === 0) throw new Error("A side of the bundle has no end.");
+  let m1 = mean(a);
+  let m2 = mean(b);
+  for (let s = 0; s < steps; s++) {
+    m1 = weiszfeldStep(m1, a, m2, w);
+    m2 = weiszfeldStep(m2, b, m1, w);
+  }
+  return [m1, m2];
+}
+
+/**
+ * This function gives the highways of the plan `from`, with the meeting points of Weiszfeld (HWY-043).
+ * The ends of a member are the points where its edge comes to the highway and goes away from it after `follow` of the plan.
+ * They are the plugs, or the split point of the highway before and the merge point of the highway after.
+ * The weight of the trunk is `k^alpha` for `k` members. The trunk stays on the spine: the function projects `M1` and `M2` on the spine.
+ * Each member then joins the spine at `M1` and leaves it at `M2`, but not outside its own stretch. So a member only gets shorter on the spine.
+ */
+export function weiszfeldPlan(input: HighwayInput, o: Readonly<WeiszfeldOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  if (plan.highways.length === 0) return plan;
+  const routes = routeIndex(planRoutes(input.graph, plan).routes);
+  const trips = tripsOf(plan);
+  const highways = plan.highways.map((h, hi) => {
+    const a: Point[] = [];
+    const b: Point[] = [];
+    for (const m of h.members) {
+      const trip = trips.get(m.edge) ?? [];
+      const route = routes.get(m.edge);
+      const k = trip.findIndex((s) => s.h === hi);
+      const before = k > 0 ? trip[k - 1]!.m.split : route?.[0];
+      const after = k >= 0 && k < trip.length - 1 ? trip[k + 1]!.m.merge : route?.[route.length - 1];
+      if (!before || !after) continue;
+      if (m.on <= m.off) {
+        a.push(before);
+        b.push(after);
+      } else {
+        a.push(after);
+        b.push(before);
+      }
+    }
+    if (a.length < 2) return h;
+    const [m1, m2] = meetingPoints(a, b, h.members.length ** Math.max(0, o.alpha), Math.max(0, Math.round(o.steps)));
+    const pa = nearestPlace(h.spine, m1);
+    const pb = nearestPlace(h.spine, m2);
+    if (pb - pa <= 1e-6) return h;
+    const members: HighwayMember[] = h.members.map((m) => {
+      if (m.on <= m.off) {
+        const on = Math.max(m.on, pa);
+        const off = Math.min(m.off, pb);
+        return off - on > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+      }
+      const on = Math.min(m.on, pb);
+      const off = Math.max(m.off, pa);
+      return on - off > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+    });
+    return { ...h, members };
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/wspd/index.ts

@@ -0,0 +1,130 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `wspd` (HWY-018 of the note on highways). */
+export interface WspdOptions {
+  /** The separation `s` of the pairs: the gap between two sets is at least `s` times the radius of the larger set. The default is 2. */
+  readonly separation: number;
+  /** A pair with this number of edges or more gets a highway. The default is 3. */
+  readonly minSize: number;
+  /** The spine of each pair. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `wspd`. */
+export const WSPD_DEFAULTS: Readonly<WspdOptions> = Object.freeze({ separation: 2, minSize: 3, spine: "trunk" });
+
+/** A cell of the split tree: the points at the places `lo` to `hi - 1` of the order, with their bounding circle. */
+export interface SplitCell {
+  readonly id: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly c: Point;
+  readonly r: number;
+  readonly kids?: readonly [SplitCell, SplitCell];
+}
+
+/**
+ * The split tree of a set of points and its well-separated pairs (Callahan and Kosaraju 1995).
+ * Each cell splits at the middle of the longer side of its bounding box. A cell of equal points is a leaf.
+ */
+export class SplitTree {
+  readonly root: SplitCell;
+  /** The place of each point in the order of the tree. */
+  readonly #at: Int32Array;
+  #count = 0;
+
+  /** This constructor builds the tree of the points. */
+  constructor(points: readonly Point[]) {
+    const order = points.map((_, i) => i);
+    this.#at = new Int32Array(points.length);
+    this.root = this.#build(points, order, 0, points.length);
+    order.forEach((p, i) => (this.#at[p] = i));
+  }
+
+  #build(points: readonly Point[], order: number[], lo: number, hi: number): SplitCell {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (let i = lo; i < hi; i++) {
+      const p = points[order[i]!]!;
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+    const id = this.#count++;
+    const c = center({ x: x0, y: y0, w: x1 - x0, h: y1 - y0 });
+    const r = Math.hypot(x1 - x0, y1 - y0) / 2;
+    if (hi - lo <= 1 || r <= 1e-9) return { id, lo, hi, c, r };
+    const byX = x1 - x0 >= y1 - y0;
+    const cut = byX ? (x0 + x1) / 2 : (y0 + y1) / 2;
+    const part = order.slice(lo, hi);
+    const left = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) <= cut);
+    const right = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) > cut);
+    [...left, ...right].forEach((p, k) => (order[lo + k] = p));
+    const mid = lo + left.length;
+    return { id, lo, hi, c, r, kids: [this.#build(points, order, lo, mid), this.#build(points, order, mid, hi)] };
+  }
+
+  /** This method tells if the cell holds the point `i`. */
+  holds(cell: SplitCell, i: number): boolean {
+    const at = this.#at[i]!;
+    return at >= cell.lo && at < cell.hi;
+  }
+
+  /**
+   * This method gives the well-separated pair that holds the pair of points `u` and `v`, with the cell of `u` first.
+   * Each pair of two different points is in one pair of the decomposition. Two equal points give `undefined`.
+   */
+  pairOf(u: number, v: number, s: number): [SplitCell, SplitCell] | undefined {
+    let cell = this.root;
+    while (cell.kids) {
+      const next = cell.kids.find((k) => this.holds(k, u) && this.holds(k, v));
+      if (!next) break;
+      cell = next;
+    }
+    if (!cell.kids) return undefined;
+    let a = cell.kids.find((k) => this.holds(k, u))!;
+    let b = cell.kids.find((k) => this.holds(k, v))!;
+    for (;;) {
+      const r = Math.max(a.r, b.r);
+      if (dist(a.c, b.c) - 2 * r >= s * r) return [a, b];
+      if (a.r >= b.r && a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else if (b.kids) b = b.kids.find((k) => this.holds(k, v))!;
+      else if (a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else return [a, b];
+    }
+  }
+}
+
+/**
+ * This function gives the groups of the edges by the well-separated pair of their two nodes (HWY-018).
+ * The points are the centers of the boxes. The edges of one pair, in either direction, are one group.
+ */
+export function wspdGroups(input: HighwayInput, o: Readonly<WspdOptions>): Map<string, EdgeGroup> {
+  const nodes = input.graph.nodes;
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const tree = new SplitTree(nodes.map((n) => center(n.box)));
+  const groups = new Map<string, EdgeGroup>();
+  for (const e of input.graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined || u === v) continue;
+    const pair = tree.pairOf(u, v, o.separation);
+    if (!pair) continue;
+    const [a, b] = pair;
+    groups.set(e.id, a.id < b.id ? { key: `w${a.id}:${b.id}`, flip: false } : { key: `w${b.id}:${a.id}`, flip: true });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of clustered edge routing with the WSPD (HWY-018, after Bouts and Speckmann 2015).
+ * The well-separated pairs split all the pairs of nodes. The edges of one pair with `minSize` edges or more get one highway from one set to the other.
+ */
+export function wspdPlan(input: HighwayInput, o: Readonly<WspdOptions>): HighwayPlan {
+  return groupedPlan(input, wspdGroups(input, o), { spine: o.spine, minSize: o.minSize });
+}

package/src/highways/zipper/index.ts

@@ -0,0 +1,168 @@
+import { boardUnit, segmentKey } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import { Grid, segmentBounds } from "../../grid.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, orderAlongRoutes, planRoutes, routeIndex, tidyPlan, type HighwayBase } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `zipper` (NAT-022 with WILD-037 of the notes). */
+export interface ZipperOptions {
+  /** The plan whose routes the zipper joins. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two legs zip when they are this distance apart or nearer, in units of the board (the median short side of the boxes). The default is 1. */
+  readonly near: number;
+  /** Two legs zip when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly maxAngle: number;
+  /** The adhesion over the tension: two legs zip when `adhesion * overlap` is more than the length that the zip adds. The default is 0.3. */
+  readonly adhesion: number;
+  /** Two legs zip when they overlap along this length or more, in units of the board. The default is 1. */
+  readonly minOverlap: number;
+  /** The number of passes. Each pass routes the plan and zips the legs again. The default is 1. */
+  readonly passes: number;
+}
+
+/** The default options of the strategy `zipper`. */
+export const ZIPPER_DEFAULTS: Readonly<ZipperOptions> = Object.freeze({ from: "shared-ways", near: 1, maxAngle: 15, adhesion: 0.3, minOverlap: 1, passes: 1 });
+
+/** One leg of a route that no other route shares. */
+interface Leg {
+  readonly edge: string;
+  readonly a: Point;
+  readonly b: Point;
+  readonly len: number;
+}
+
+/** A pair of legs that can zip, with the line of the zip. */
+export interface Zip {
+  readonly gain: number;
+  /** The first point of the zipped line. */
+  readonly from: Point;
+  /** The last point of the zipped line. */
+  readonly to: Point;
+  /** This value is `true` when the leg goes from `from` to `to`, for each of the two legs. */
+  readonly forward: readonly [boolean, boolean];
+}
+
+/** The limits of `zipLegs`, in the units of the board. */
+export interface ZipLimits {
+  readonly near: number;
+  readonly maxAngle: number;
+  readonly adhesion: number;
+  readonly minOverlap: number;
+}
+
+/**
+ * This function tells if two legs zip (NAT-022), and gives the zipped line.
+ * The zipped line is the mean of the two legs, with the weight of their lengths, along the stretch where they overlap.
+ * The legs zip when the angle between them is `maxAngle` or less, and they are `near` or nearer along the overlap.
+ * The overlap must be `minOverlap` or more.
+ * The zip adds two jogs to each leg, so it adds the length `2 (d_a + d_b)`, with the distances of the legs to the zipped line.
+ * The legs zip only when `adhesion * overlap` is more than that length.
+ */
+export function zipLegs(a0: Point, a1: Point, b0: Point, b1: Point, o: ZipLimits): Zip | undefined {
+  const la = dist(a0, a1);
+  const lb = dist(b0, b1);
+  if (la <= 1e-9 || lb <= 1e-9) return undefined;
+  const ua = { x: (a1.x - a0.x) / la, y: (a1.y - a0.y) / la };
+  const ub = { x: (b1.x - b0.x) / lb, y: (b1.y - b0.y) / lb };
+  const dot = ua.x * ub.x + ua.y * ub.y;
+  if (Math.abs(dot) < Math.cos((o.maxAngle * Math.PI) / 180) - 1e-12) return undefined;
+  const sign = dot >= 0 ? 1 : -1;
+  const dx = ua.x * la + sign * ub.x * lb;
+  const dy = ua.y * la + sign * ub.y * lb;
+  const dl = Math.hypot(dx, dy);
+  if (dl <= 1e-9) return undefined;
+  const u = { x: dx / dl, y: dy / dl };
+  const o0 = { x: ((a0.x + a1.x) * la + (b0.x + b1.x) * lb) / (2 * (la + lb)), y: ((a0.y + a1.y) * la + (b0.y + b1.y) * lb) / (2 * (la + lb)) };
+  const along = (p: Point): number => (p.x - o0.x) * u.x + (p.y - o0.y) * u.y;
+  const across = (p: Point): number => (p.x - o0.x) * u.y - (p.y - o0.y) * u.x;
+  const ta = [along(a0), along(a1)] as const;
+  const tb = [along(b0), along(b1)] as const;
+  const lo = Math.max(Math.min(...ta), Math.min(...tb));
+  const hi = Math.min(Math.max(...ta), Math.max(...tb));
+  const overlap = hi - lo;
+  if (overlap < o.minOverlap || overlap <= 1e-9) return undefined;
+  // The offset of a leg from the zipped line at the place t along it.
+  const offset = (p0: Point, p1: Point, t0: number, t1: number, t: number): number => {
+    const s = Math.abs(t1 - t0) <= 1e-12 ? 0 : (t - t0) / (t1 - t0);
+    return across({ x: p0.x + (p1.x - p0.x) * s, y: p0.y + (p1.y - p0.y) * s });
+  };
+  let jog = 0;
+  for (const t of [lo, hi]) {
+    const da = offset(a0, a1, ta[0], ta[1], t);
+    const db = offset(b0, b1, tb[0], tb[1], t);
+    if (Math.abs(da - db) > o.near) return undefined;
+    jog += Math.abs(da) + Math.abs(db);
+  }
+  const gain = o.adhesion * overlap - jog;
+  if (!(gain > 0)) return undefined;
+  const from = { x: o0.x + u.x * lo, y: o0.y + u.y * lo };
+  const to = { x: o0.x + u.x * hi, y: o0.y + u.y * hi };
+  return { gain, from, to, forward: [ua.x * u.x + ua.y * u.y > 0, ub.x * u.x + ub.y * u.y > 0] };
+}
+
+/**
+ * This function gives the highways of the plan `from`, with the legs that run near and nearly parallel zipped together (NAT-022, WILD-037).
+ * A pass routes the plan with `follow` and takes each leg that no other route shares. A grid of the legs finds the near pairs.
+ * The pairs that zip (`zipLegs`) go from the largest gain to the smallest, and each leg zips one time in a pass at most.
+ * A zipped line that goes into a box, made larger by 1, does not zip.
+ * Each zip is a new highway of two members. The `seq` of each member follows the place of its merge point along the route of the edge.
+ */
+export function zipperPlan(input: HighwayInput, o: Readonly<ZipperOptions>): HighwayPlan {
+  const graph = input.graph;
+  const unit = boardUnit(graph);
+  const limits: ZipLimits = { near: o.near * unit, maxAngle: o.maxAngle, adhesion: o.adhesion, minOverlap: Math.max(1e-6, o.minOverlap * unit) };
+  const obstacles = new WayFinder(graph.nodes).obstacles;
+  let plan = basePlan(input, o.from);
+  for (let pass = 0; pass < Math.max(1, Math.round(o.passes)); pass++) {
+    const routes = planRoutes(graph, plan).routes;
+    const users = new Map<string, number>();
+    for (const r of routes) {
+      const own = new Set<string>();
+      for (let i = 1; i < r.points.length; i++) {
+        const k = segmentKey(r.points[i - 1]!, r.points[i]!);
+        if (k !== undefined) own.add(k);
+      }
+      for (const k of own) users.set(k, (users.get(k) ?? 0) + 1);
+    }
+    const legs: Leg[] = [];
+    for (const r of routes)
+      for (let i = 1; i < r.points.length; i++) {
+        const a = r.points[i - 1]!;
+        const b = r.points[i]!;
+        const k = segmentKey(a, b);
+        const len = dist(a, b);
+        if (k === undefined || (users.get(k) ?? 0) > 1 || len < limits.minOverlap) continue;
+        legs.push({ edge: r.edge, a, b, len });
+      }
+    const grid = new Grid<number>(Math.max(32, 4 * limits.near));
+    legs.forEach((l, i) => {
+      const bx = segmentBounds(l.a, l.b);
+      grid.add(i, { x: bx.x - limits.near, y: bx.y - limits.near, w: bx.w + 2 * limits.near, h: bx.h + 2 * limits.near });
+    });
+    const found: { i: number; j: number; zip: Zip }[] = [];
+    legs.forEach((l, i) => {
+      grid.query(segmentBounds(l.a, l.b), (j) => {
+        if (j <= i || legs[j]!.edge === l.edge) return;
+        const m = legs[j]!;
+        const zip = zipLegs(l.a, l.b, m.a, m.b, limits);
+        if (zip) found.push({ i, j, zip });
+      });
+    });
+    found.sort((p, q) => q.zip.gain - p.zip.gain || p.i - q.i || p.j - q.j);
+    const used = new Set<number>();
+    const added: Highway[] = [];
+    for (const { i, j, zip } of found) {
+      if (used.has(i) || used.has(j)) continue;
+      if (!obstacles.clear(zip.from, zip.to, 1)) continue;
+      used.add(i);
+      used.add(j);
+      const spine = [zip.from, zip.to];
+      const members = [legs[i]!, legs[j]!].map((l, k) => (zip.forward[k] ? memberAt(spine, l.edge, 0, 1) : memberAt(spine, l.edge, 1, 0)));
+      added.push({ id: "", key: `zip${pass}`, spine, lanes: members.map((m) => m.edge), members });
+    }
+    if (added.length === 0) break;
+    plan = tidyPlan(orderAlongRoutes({ highways: [...plan.highways, ...added] }, routeIndex(routes)));
+  }
+  return tidyPlan(plan);
+}

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])`. */