@mark1russell7/highways 0.3.0 → 0.4.0

package/src/highways/model.ts

@@ -0,0 +1,111 @@
+import { dist, type Point } from "../geom.ts";
+import type { Graph, Result } from "../model.ts";
+
+/** The input of a highway strategy: the boxes and the edges, and optionally the first routes of a router. */
+export interface HighwayInput {
+  readonly graph: Graph;
+  /**
+   * These routes are the first routes, from a router. A strategy that reads first routes makes them itself when this value is absent.
+   * The strategy `corridors` makes the ways of the corner graph, as the router `corners` finds them.
+   */
+  readonly routes?: Result;
+}
+
+/**
+ * One edge of a highway. The edge joins the spine at the merge point and leaves it at the split point.
+ * A place on the spine is the index of a point of the spine plus the share of the next leg. Point `i` of the spine is at `i`.
+ * When `on` is larger than `off`, the edge goes along the spine from its last point to its first point.
+ */
+export interface HighwayMember {
+  readonly edge: string;
+  /** The place of the merge point on the spine. */
+  readonly on: number;
+  /** The place of the split point on the spine. */
+  readonly off: number;
+  /** The point where the edge joins the spine. */
+  readonly merge: Point;
+  /** The point where the edge leaves the spine. */
+  readonly split: Point;
+  /**
+   * The place of this highway in the trip of the edge, from 0. An edge can go along several highways, one after the other.
+   * `follow` takes the highways of an edge in the order of this value.
+   */
+  readonly seq: number;
+}
+
+/** A highway: a shared way that a bundle of edges follows, from their merge points to their split points. */
+export interface Highway {
+  readonly id: string;
+  /** The key of the highway, for example the key of the grouping rule or the index of a cluster. */
+  readonly key: string;
+  /** The spine: the polyline that the edges follow, in free space. */
+  readonly spine: readonly Point[];
+  /** The edges in lane order. Lane 0 is on the left of the spine, from its first point to its last point. The y axis points down. */
+  readonly lanes: readonly string[];
+  /** The edges with their merge points and their split points, in the order of `lanes`. */
+  readonly members: readonly HighwayMember[];
+}
+
+/** The output of a highway strategy: the highways, as data. `follow` routes the edges along them. */
+export interface HighwayPlan {
+  readonly highways: readonly Highway[];
+}
+
+/** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
+export function pointAt(line: readonly Point[], at: number): Point {
+  if (line.length === 0) throw new Error("The polyline has no point.");
+  if (at <= 0) return line[0]!;
+  if (at >= line.length - 1) return line[line.length - 1]!;
+  const i = Math.floor(at);
+  const u = at - i;
+  const a = line[i]!;
+  if (u === 0) return a;
+  const b = line[i + 1]!;
+  return { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u };
+}
+
+/** This function gives the length of a polyline from the place `from` to the place `to`, with `from` not larger than `to`. */
+export function lengthBetween(line: readonly Point[], from: number, to: number): number {
+  if (to <= from) return 0;
+  let sum = 0;
+  let prev = pointAt(line, from);
+  for (let i = Math.floor(from) + 1; i < to; i++) {
+    const p = line[i]!;
+    sum += dist(prev, p);
+    prev = p;
+  }
+  return sum + dist(prev, pointAt(line, to));
+}
+
+/** This function gives a member of a highway with its merge point and its split point at the places `on` and `off` of the spine. */
+export function memberAt(spine: readonly Point[], edge: string, on: number, off: number, seq = 0): HighwayMember {
+  return { edge, on, off, merge: pointAt(spine, on), split: pointAt(spine, off), seq };
+}
+
+/**
+ * This function lists the problems of a plan against its graph. A good plan gives an empty list.
+ * Each highway has a spine of two points or more, and two members or more. Each member is an edge of the graph, with `on` and `off` on the spine and apart.
+ * An edge is a member of a highway one time at most.
+ */
+export function checkPlan(graph: Graph, plan: HighwayPlan): string[] {
+  const edges = new Set(graph.edges.map((e) => e.id));
+  const out: string[] = [];
+  const ids = new Set<string>();
+  for (const h of plan.highways) {
+    if (ids.has(h.id)) out.push(`Two highways have the id "${h.id}".`);
+    ids.add(h.id);
+    const last = h.spine.length - 1;
+    if (h.spine.length < 2) out.push(`The highway "${h.id}" has a spine with fewer than two points.`);
+    if (h.members.length < 2) out.push(`The highway "${h.id}" has fewer than two members.`);
+    const seen = new Set<string>();
+    for (const m of h.members) {
+      if (!edges.has(m.edge)) out.push(`The highway "${h.id}" has the member "${m.edge}", which is not an edge of the graph.`);
+      if (seen.has(m.edge)) out.push(`The highway "${h.id}" has the member "${m.edge}" two times.`);
+      seen.add(m.edge);
+      if (!(m.on >= 0 && m.on <= last && m.off >= 0 && m.off <= last)) out.push(`The member "${m.edge}" of the highway "${h.id}" has a place off the spine.`);
+      if (m.on === m.off) out.push(`The member "${m.edge}" of the highway "${h.id}" joins and leaves the spine at one place.`);
+    }
+    if (h.lanes.length !== h.members.length || h.lanes.some((e) => !seen.has(e))) out.push(`The lanes of the highway "${h.id}" are not its members.`);
+  }
+  return out;
+}

package/src/highways/result.ts

@@ -0,0 +1,34 @@
+import type { Result } from "../model.ts";
+import { segmentsOf } from "../segments.ts";
+import { memberAt, type Highway, type HighwayMember, type HighwayPlan } from "./model.ts";
+
+/**
+ * This function gives the highways of a result of a router: one highway for each shared run and for each trunk of a bundle.
+ * The spine is the points of the run or of the trunk. Each edge of the run is a member, from one end of the spine to the other end, in the way of its route.
+ * The member `seq` is the place of the shared stretch in the route of the edge. The lanes keep the lane order of the router.
+ *
+ * Thus `follow` routes each edge along the shared stretches of the router. A route that does not hold its run is not a member.
+ */
+export function planOfResult(result: Result): HighwayPlan {
+  const graph = segmentsOf(result);
+  const keys = new Map<string, string>([...(result.runs ?? []).map((r) => [r.id, r.key] as const), ...(result.bundles ?? []).map((b) => [b.id, b.key] as const)]);
+  const shared = graph.segments.filter((s) => s.count > 1);
+  const ids = new Set(shared.map((s) => s.id));
+  const place = new Map<string, { seq: number; reverse: boolean }>();
+  for (const path of graph.paths) {
+    let seq = 0;
+    for (const ref of path.segments) if (ids.has(ref.segment)) place.set(`${ref.segment}\u0000${path.edge}`, { seq: seq++, reverse: ref.reverse });
+  }
+  const highways: Highway[] = [];
+  for (const s of shared) {
+    const last = s.points.length - 1;
+    const members: HighwayMember[] = [];
+    for (const edge of s.edges) {
+      const at = place.get(`${s.id}\u0000${edge}`);
+      if (at) members.push(at.reverse ? memberAt(s.points, edge, last, 0, at.seq) : memberAt(s.points, edge, 0, last, at.seq));
+    }
+    if (members.length < 2) continue;
+    highways.push({ id: `h${highways.length}`, key: keys.get(s.id) ?? s.id, spine: s.points, lanes: members.map((m) => m.edge), members });
+  }
+  return { highways };
+}

package/src/highways/router.ts

@@ -0,0 +1,40 @@
+import type { Graph, Result, Router } from "../model.ts";
+import { defineStrategy, type Strategy } from "../strategies/model.ts";
+import type { WayOptions } from "../ways.ts";
+import { follow, type FollowOptions } from "./follow.ts";
+
+/** This function gives the options of the way finder in the options of a strategy: `margin` and `k`, when they are present. */
+function wayOptionsOf(options: object): WayOptions {
+  const o = options as { margin?: unknown; k?: unknown };
+  return { ...(typeof o.margin === "number" ? { margin: o.margin } : {}), ...(typeof o.k === "number" ? { k: o.k } : {}) };
+}
+
+/**
+ * This function gives a router that runs a highway strategy and then `follow`. The strategy gets the graph without first routes.
+ * The way finder of `follow` takes `margin` and `k` from the options of the strategy, and then from `followOptions`.
+ * The router keeps the name and the `maxNodes` of the strategy.
+ */
+export function highwayRouter<O extends object>(strategy: Strategy<"highway", O>, options?: Partial<O>, followOptions: FollowOptions = {}): Router {
+  return {
+    name: strategy.name,
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    route: (graph: Graph): Result => follow(graph, strategy.run({ graph }, options), { ...followOptions, ...wayOptionsOf({ ...strategy.defaults, ...options }) }),
+  };
+}
+
+/**
+ * This function gives a router strategy that runs a highway strategy and then `follow`.
+ * The router strategy has the name, the options and the schema of the highway strategy.
+ * The benchmark and the screen race such a router with the other routers.
+ */
+export function highwayRouterStrategy<O extends object>(strategy: Strategy<"highway", O>): Strategy<"router", O> {
+  return defineStrategy<"router", O>({
+    step: "router",
+    name: strategy.name,
+    describe: strategy.describe,
+    defaults: strategy.defaults as O,
+    ...(strategy.schema === undefined ? {} : { schema: strategy.schema }),
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    run: (graph: Graph, options: Readonly<O>): Result => follow(graph, strategy.run({ graph }, options), wayOptionsOf(options)),
+  });
+}

package/src/highways/shared-ways/index.ts

@@ -0,0 +1,15 @@
+import { sharedRouter, type SharedOptions } from "../../routers/shared.ts";
+import { planOfResult } from "../result.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `shared-ways`: the options of the router `shared`, without the name and the limit of the benchmark. */
+export type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
+
+/**
+ * This function gives the highways that the router `shared` decides. The edges of one key go one by one through the corner graph.
+ * A link that the key uses already costs less, so the ways of a key come together. Each stretch that two edges or more share becomes one highway.
+ * The function does not change the router: it reads its runs.
+ */
+export function sharedWaysPlan(input: HighwayInput, options: SharedWaysOptions): HighwayPlan {
+  return planOfResult(sharedRouter({ ...options, name: "shared-ways" }).route(input.graph));
+}

package/src/index.ts

@@ -27,3 +27,5 @@ export * from "./bench/measures/index.ts";
 export * from "./bench/suite.ts";
 export * from "./strategies/index.ts";
 export * from "./bench/compare.ts";
+export * from "./bench/screen/index.ts";
+export * from "./highways/index.ts";

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,6 +1,7 @@
 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";
@@ -64,6 +65,18 @@ export const SHARED_SCHEMA: OptionSchema<RouterPreset<SharedOptions>> = {
   laneOrder: LANE_ORDER,
 };
 
+/** 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`). */
 export const SECTION_SCHEMA: OptionSchema<Required<SectionOptions>> = {
   cap: { type: "integer", min: 1, max: 32, step: 1, scale: "log", marks: [4, 6, 8, 12, 16], default: 8, describe: "The section limit. A section with more nodes splits in four." },