@mark1russell7/highways 0.4.1 → 0.5.0

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

@@ -7,6 +7,7 @@ export * from "./plugs.ts";
 export * from "./curves.ts";
 export * from "./curves/index.ts";
 export * from "./visibility.ts";
+export * from "./channels.ts";
 export * from "./ways.ts";
 export * from "./segments.ts";
 export * from "./sections.ts";

package/src/routers/shared.ts

@@ -1,5 +1,6 @@
 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 { channelWidth } from "../channels.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { buildSections, type Section } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -44,6 +45,20 @@ export interface SharedOptions extends WayOptions {
    * 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 pull of the busy links of the pass before (HWY-005, Winding Roads). With a value above 0 and two passes or more, each later pass routes each edge again from no ways.
+   * A link then costs `len / (1 + reuse * u)^reuseExponent`, with `u` the edges of the key on it in the pass before. The default is 0: the later passes are rip-up passes.
+   */
+  readonly reuse?: number;
+  /** The exponent of the pull of `reuse`. The default is 1. */
+  readonly reuseExponent?: number;
+  /**
+   * The cost of a lane that does not fit in its channel (HWY-016). One more edge on a link with `f` edges of the key costs `capacity * max(0, (f + 1) * laneWidth - width)` more.
+   * `width` is the free space across the link (`channelWidth`). The default is 0: the router does not read the channels.
+   */
+  readonly capacity?: number;
+  /** The width of one lane, for `capacity`. The default is 4. */
+  readonly laneWidth?: number;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -94,6 +109,10 @@ export function sharedRouter(options: SharedOptions): Router {
   // 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 reuse = Math.max(0, options.reuse ?? 0);
+  const reuseExponent = Math.max(0, options.reuseExponent ?? 1);
+  const capacity = Math.max(0, options.capacity ?? 0);
+  const laneWidth = Math.max(0, options.laneWidth ?? 4);
   const keyOf = (e: Edge): string => {
     if (!options.rule) return "*";
     return options.rule(e) ?? `\u0000${e.id}`;
@@ -131,14 +150,34 @@ export function sharedRouter(options: SharedOptions): Router {
       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 => {
+      // The width of the channel of each link, for the option `capacity`. Each link gets its width at its first use.
+      const widths = new Map<number, number>();
+      const widthOf = (i: number, j: number): number => {
+        const k = link(i, j);
+        let wd = widths.get(k);
+        if (wd === undefined) widths.set(k, (wd = channelWidth(ways.obstacles, corners.points[i]!, corners.points[j]!)));
+        return wd;
+      };
+      /** This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`. */
+      const route = (w: Way, before?: ReadonlyMap<number, number>): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
-        const floor = flow ? share(top.get(w.key) ?? 0) : discount;
-        const cost = flow
+        let floor = flow ? share(top.get(w.key) ?? 0) : discount;
+        let 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);
+        if (capacity > 0) {
+          const plain = cost;
+          cost = (i, j, d) => plain(i, j, d) + capacity * Math.max(0, ((mine.get(link(i, j))?.length ?? 0) + 1) * laneWidth - widthOf(i, j));
+        }
+        if (before !== undefined) {
+          const plain = cost;
+          let most = 0;
+          for (const u of before.values()) most = Math.max(most, u);
+          cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
+          floor /= (1 + reuse * most) ** reuseExponent;
+        }
         const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
         if (!way) return;
         w.found = true;
@@ -157,6 +196,20 @@ export function sharedRouter(options: SharedOptions): Router {
       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++) {
+        if (reuse > 0) {
+          // Winding Roads (HWY-005): each edge finds its way again from no ways, and the busy links of the pass before pull it.
+          const before = new Map<string, Map<number, number>>();
+          for (const [key, links] of discounted) before.set(key, new Map([...links].map(([k, list]) => [k, list.length])));
+          discounted.clear();
+          top.clear();
+          for (const w of order) {
+            w.found = false;
+            w.seq = [];
+            w.ids = [];
+          }
+          for (const w of order) route(w, before.get(w.key) ?? new Map());
+          continue;
+        }
         for (const w of order) {
           if (!w.found) continue;
           const mine = discounted.get(w.key)!;

package/src/strategies/builtins.ts

@@ -12,9 +12,40 @@ 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 { DIFFUSION_DEFAULTS, diffusionPlan, type DiffusionOptions } from "../highways/diffusion/index.ts";
+import { FLOW_CLUSTER_DEFAULTS, flowClusterPlan, type FlowClusterOptions } from "../highways/flow-clusters/index.ts";
+import { EDGE_PATH_DEFAULTS, edgePathPlan, type EdgePathOptions } from "../highways/edge-paths/index.ts";
+import { HDBSCAN_DEFAULTS, hdbscanPlan, type HdbscanOptions } from "../highways/hdbscan/index.ts";
+import { HOUGH_DEFAULTS, houghPlan, type HoughOptions } from "../highways/hough/index.ts";
+import { HUB_ARC_DEFAULTS, hubArcPlan, type HubArcOptions } from "../highways/hub-arcs/index.ts";
+import { RIDGE_DEFAULTS, ridgePlan, type RidgeOptions } from "../highways/ridges/index.ts";
+import { SOFT_KEY_DEFAULTS, softKeyPlan, type SoftKeyOptions } from "../highways/soft-keys/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 { MINGLE_DEFAULTS, minglePlan, type MingleOptions } from "../highways/mingle/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 { NESTED_DEFAULTS, nestedPlan, type NestedOptions } from "../highways/nested/index.ts";
+import { LANES_DEFAULTS, lanesPlan, type LanesOptions } from "../highways/lanes/index.ts";
+import { GROWTH_DEFAULTS, growthPlan, type GrowthOptions } from "../highways/growth/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 { SPIRAL_DEFAULTS, spiralPlan, type SpiralOptions } from "../highways/spiral/index.ts";
+import { STUB_DEFAULTS, stubPlan, type StubOptions } from "../highways/stubs/index.ts";
+import { TRACLUS_DEFAULTS, traclusPlan, type TraclusOptions } from "../highways/traclus/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 +58,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, DIFFUSION_SCHEMA, EDGE_PATH_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TRACLUS_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 +371,57 @@ 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 mingle: Strategy<"highway", MingleOptions>;
+  readonly spiral: Strategy<"highway", SpiralOptions>;
+  readonly "flow-clusters": Strategy<"highway", FlowClusterOptions>;
+  readonly traclus: Strategy<"highway", TraclusOptions>;
+  readonly diffusion: Strategy<"highway", DiffusionOptions>;
+  readonly nested: Strategy<"highway", NestedOptions>;
+  readonly lanes: Strategy<"highway", LanesOptions>;
+  readonly growth: Strategy<"highway", GrowthOptions>;
+  readonly "edge-paths": Strategy<"highway", EdgePathOptions>;
+  readonly "soft-keys": Strategy<"highway", SoftKeyOptions>;
+  readonly hough: Strategy<"highway", HoughOptions>;
+  readonly ridges: Strategy<"highway", RidgeOptions>;
+  readonly hdbscan: Strategy<"highway", HdbscanOptions>;
+  readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
+  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 +441,237 @@ 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: "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<SelectOptions>) => selectPlan(input, o),
+  }),
+  mingle: defineStrategy({
+    step: "highway",
+    name: "mingle",
+    describe: "MINGLE (HWY-003). Edges are points in 4D. Near bundles merge level by level while the merge saves ink, and each bundle gets one trunk.",
+    defaults: { ...MINGLE_DEFAULTS } as MingleOptions,
+    schema: MINGLE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MingleOptions>) => minglePlan(input, o),
+  }),
+  spiral: defineStrategy({
+    step: "highway",
+    name: "spiral",
+    describe: "Spiral trees (HWY-017, EDA-035). The edges of a node with many edges branch on arcs of spirals, and each branch with two edges is a highway.",
+    defaults: { ...SPIRAL_DEFAULTS } as SpiralOptions,
+    schema: SPIRAL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SpiralOptions>) => spiralPlan(input, o),
+  }),
+  "flow-clusters": defineStrategy({
+    step: "highway",
+    name: "flow-clusters",
+    describe: "Flow clusters (HWY-023). A hierarchical clustering puts the edges with near sources and near targets together, and each cluster gets highways.",
+    defaults: { ...FLOW_CLUSTER_DEFAULTS } as FlowClusterOptions,
+    schema: FLOW_CLUSTER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FlowClusterOptions>) => flowClusterPlan(input, o),
+  }),
+  traclus: defineStrategy({
+    step: "highway",
+    name: "traclus",
+    describe: "TRACLUS (HWY-025). The first routes break into segments, and the dense clusters of near segments become highways.",
+    defaults: { ...TRACLUS_DEFAULTS } as TraclusOptions,
+    schema: TRACLUS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<TraclusOptions>) => traclusPlan(input, o),
+  }),
+  diffusion: defineStrategy({
+    step: "highway",
+    name: "diffusion",
+    describe: "Route-aware bundling (HWY-020). The density of the first ways diffuses on the corner graph, and dense links cost less in a second pass.",
+    defaults: { ...DIFFUSION_DEFAULTS } as DiffusionOptions,
+    schema: DIFFUSION_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<DiffusionOptions>) => diffusionPlan(input, o),
+  }),
+  nested: defineStrategy({
+    step: "highway",
+    name: "nested",
+    describe: "Highways for each zoom level that nest (HWY-052). Each level puts the edges of each cluster of the level above in finer clusters.",
+    defaults: { ...NESTED_DEFAULTS } as NestedOptions,
+    schema: NESTED_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<NestedOptions>) => nestedPlan(input, o),
+  }),
+  lanes: defineStrategy({
+    step: "highway",
+    name: "lanes",
+    describe: "Width, lanes and capacity (HWY-051). A highway that does not fit in its channels splits into two highways by lane order.",
+    defaults: { ...LANES_DEFAULTS } as LanesOptions,
+    schema: LANES_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<LanesOptions>) => lanesPlan(input, o),
+  }),
+  growth: defineStrategy({
+    step: "highway",
+    name: "growth",
+    describe: "Local growth (HWY-055). Each edge, the longest first, joins the highway with the largest saving, or starts a highway.",
+    defaults: { ...GROWTH_DEFAULTS } as GrowthOptions,
+    schema: GROWTH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<GrowthOptions>) => growthPlan(input, o),
+  }),
+  "edge-paths": defineStrategy({
+    step: "highway",
+    name: "edge-paths",
+    describe: "Edge-path bundling (HWY-012). An edge with a short path of other edges follows their ways, and the shared stretches become highways.",
+    defaults: { ...EDGE_PATH_DEFAULTS } as EdgePathOptions,
+    schema: EDGE_PATH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<EdgePathOptions>) => edgePathPlan(input, o),
+  }),
+  "soft-keys": defineStrategy({
+    step: "highway",
+    name: "soft-keys",
+    describe: "Soft keys (HWY-019). The key of an edge adds a distance to the flow distance, and a hierarchical clustering makes the highways.",
+    defaults: { ...SOFT_KEY_DEFAULTS } as SoftKeyOptions,
+    schema: SOFT_KEY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SoftKeyOptions>) => softKeyPlan(input, o),
+  }),
+  hough: defineStrategy({
+    step: "highway",
+    name: "hough",
+    describe: "Hough votes (HWY-024). The straight lines of the edges vote for corridors, and each peak of the votes becomes a highway.",
+    defaults: { ...HOUGH_DEFAULTS } as HoughOptions,
+    schema: HOUGH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HoughOptions>) => houghPlan(input, o),
+  }),
+  ridges: defineStrategy({
+    step: "highway",
+    name: "ridges",
+    describe: "Ridges of the line density (HWY-032). The ridges of the blurred density of the edges become highways, and near edges snap to them.",
+    defaults: { ...RIDGE_DEFAULTS } as RidgeOptions,
+    schema: RIDGE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<RidgeOptions>) => ridgePlan(input, o),
+  }),
+  hdbscan: defineStrategy({
+    step: "highway",
+    name: "hdbscan",
+    describe: "HDBSCAN on edges (HWY-028). The density clusters of the edges that live over a long range become highways.",
+    defaults: { ...HDBSCAN_DEFAULTS } as HdbscanOptions,
+    schema: HDBSCAN_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HdbscanOptions>) => hdbscanPlan(input, o),
+  }),
+  "hub-arcs": 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: "hub-arcs",
+    describe: "Hub arc location (HWY-042). A greedy pass with swaps chooses at most q arcs from the candidates, and each edge rides its best arc.",
+    defaults: { ...HUB_ARC_DEFAULTS } as HubArcOptions,
+    schema: HUB_ARC_SCHEMA,
     maxNodes: 10_000,
-    run: (input: HighwayInput, o: Readonly<CorridorOptions>) => corridorPlan(input, o),
+    run: (input: HighwayInput, o: Readonly<HubArcOptions>) => hubArcPlan(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])`. */