@mark1russell7/highways 0.2.0 → 0.4.0

package/src/strategies/builtins.ts

@@ -1,19 +1,33 @@
 import { arcCurve, type ArcOptions } from "../curves/arc/index.ts";
+import { clothoidCurve, type ClothoidOptions } from "../curves/clothoid/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";
+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";
 import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
 import { plugsRouter } from "../routers/plugs.ts";
 import { sectionsRouter, type SectionsOptions } from "../routers/sections.ts";
 import { sharedRouter, type SharedOptions } from "../routers/shared.ts";
 import { straightRouter } from "../routers/straight.ts";
 import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunks.ts";
-import { SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
-import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type Registry, type Strategy } from "./model.ts";
+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";
 
 /** 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">;
@@ -25,13 +39,14 @@ function routerStrategy<O extends object>(
   maxNodes: number,
   defaults: O,
   make: (options: O & { readonly name: string }) => Router,
+  schema: OptionSchema<O>,
 ): Strategy<"router", O> {
-  return defineStrategy({ step: "router", name, describe, defaults, maxNodes, run: (graph: Graph, options: Readonly<O>): Result => make({ ...options, name }).route(graph) });
+  return defineStrategy({ step: "router", name, describe, defaults, schema, maxNodes, run: (graph: Graph, options: Readonly<O>): Result => make({ ...options, name }).route(graph) });
 }
 
 /** This function makes a router strategy for a router without options. */
 function fixedRouter(router: Router, describe: string): Strategy<"router", object> {
-  return defineStrategy({ step: "router", name: router.name, describe, defaults: {}, run: (graph: Graph): Result => router.route(graph) });
+  return defineStrategy({ step: "router", name: router.name, describe, defaults: {}, schema: {}, run: (graph: Graph): Result => router.route(graph) });
 }
 
 /** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
@@ -57,6 +72,7 @@ export const routerStrategies: {
     10_000,
     {},
     cornersRouter,
+    CORNERS_SCHEMA,
   ),
   "corners-smooth": routerStrategy<RouterPreset<CornersOptions>>(
     "corners-smooth",
@@ -64,6 +80,7 @@ export const routerStrategies: {
     10_000,
     { smooth: true },
     cornersRouter,
+    CORNERS_SCHEMA,
   ),
   trunks: routerStrategy<RouterPreset<TrunksOptions>>(
     "trunks",
@@ -71,6 +88,7 @@ export const routerStrategies: {
     10_000,
     { rule: byCollection },
     trunksRouter,
+    TRUNKS_SCHEMA,
   ),
   shared: routerStrategy<RouterPreset<SharedOptions>>(
     "shared",
@@ -78,14 +96,16 @@ export const routerStrategies: {
     10_000,
     { rule: byCollection },
     sharedRouter,
+    SHARED_SCHEMA,
   ),
-  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter),
+  "shared-all": routerStrategy<RouterPreset<SharedOptions>>("shared-all", "The same as `shared`, but all edges share their ways.", 10_000, {}, sharedRouter, SHARED_SCHEMA),
   sections: routerStrategy<RouterPreset<SectionsOptions>>(
     "sections",
     "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.",
     100_000,
     {},
     sectionsRouter,
+    SECTIONS_SCHEMA,
   ),
   "sections-tree": routerStrategy<RouterPreset<SectionsOptions>>(
     "sections-tree",
@@ -93,6 +113,7 @@ export const routerStrategies: {
     100_000,
     { stretch: Infinity },
     sectionsRouter,
+    SECTIONS_SCHEMA,
   ),
 });
 
@@ -115,19 +136,86 @@ export interface TensionOptions {
   readonly tension: number;
 }
 
-/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+/**
+ * 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;
+  /** The smallest radius of a lane at a bend of a bundle. The default is 4. */
+  readonly minRadius: number;
+  /** The shape of the S curve where a lane changes its offset. The default is `biarc`. */
+  readonly jog: JogStyle;
+  /** The number of cubic pieces of a `quintic` S curve. The default is 4. */
+  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. */
+  readonly radius: number;
+  /** The share of the turn of a corner in its two spirals, from 0 to 1. The default is 0.6. */
+  readonly smoothing: number;
+}
+
+/** The options of the curve strategy `clothoid`. */
+export interface ClothoidStrategyOptions {
+  /** The radius of the arc of each corner. The default is 12. */
+  readonly radius: number;
+  /** The share of the turn of a corner in its two clothoids, from 0 to 1. The default is 0.5. */
+  readonly spiral: number;
+  /** The largest distance from the cubic pieces to the true clothoid. The default is 0.25. */
+  readonly tolerance: number;
+}
+
+/**
+ * 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. 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>;
   readonly rounded: Strategy<"curve", RadiusOptions>;
   readonly spline: Strategy<"curve", TensionOptions>;
   readonly arc: Strategy<"curve", RadiusOptions>;
+  readonly smooth: Strategy<"curve", SmoothStrategyOptions>;
+  readonly clothoid: Strategy<"curve", ClothoidStrategyOptions>;
+  readonly highway: Strategy<"curve", HighwayStrategyOptions>;
 } = Object.freeze({
-  straight: defineStrategy({ step: "curve", name: "straight", describe: "The polyline as it is.", defaults: {}, run: (input: CurveInput) => straightCurve(input.points) }),
+  straight: defineStrategy({ step: "curve", name: "straight", describe: "The polyline as it is.", defaults: {}, schema: {}, run: (input: CurveInput) => straightCurve(input.points) }),
   rounded: defineStrategy({
     step: "curve",
     name: "rounded",
     describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
     defaults: { radius: 12 },
+    schema: RADIUS_SCHEMA,
     run: (input: CurveInput, o: Readonly<RadiusOptions>) => roundedCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies RoundedOptions),
   }),
   spline: defineStrategy({
@@ -135,6 +223,7 @@ export const curveStrategies: {
     name: "spline",
     describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
     defaults: { tension: 0 },
+    schema: TENSION_SCHEMA,
     run: (input: CurveInput, o: Readonly<TensionOptions>) => splineCurve(input.points, { ...contextOf(input), tension: o.tension } satisfies SplineOptions),
   }),
   arc: defineStrategy({
@@ -142,35 +231,87 @@ export const curveStrategies: {
     name: "arc",
     describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
     defaults: { radius: 12 },
+    schema: RADIUS_SCHEMA,
     run: (input: CurveInput, o: Readonly<RadiusOptions>) => arcCurve(input.points, { ...contextOf(input), radius: o.radius } satisfies ArcOptions),
   }),
+  smooth: defineStrategy({
+    step: "curve",
+    name: "smooth",
+    describe: "A cubic spiral, an arc and a second cubic spiral at each corner, as the corner smoothing of Figma. The curvature has no jump.",
+    defaults: { radius: 12, smoothing: 0.6 },
+    schema: SMOOTH_SCHEMA,
+    run: (input: CurveInput, o: Readonly<SmoothStrategyOptions>) =>
+      smoothCurve(input.points, { ...(input.space ? { space: input.space } : {}), radius: o.radius, smoothing: o.smoothing } satisfies SmoothOptions),
+  }),
+  clothoid: defineStrategy({
+    step: "curve",
+    name: "clothoid",
+    describe: "A clothoid, an arc and a second clothoid at each corner, as a transition curve of a road. Cubic pieces draw each clothoid.",
+    defaults: { radius: 12, spiral: 0.5, tolerance: 0.25 },
+    schema: CLOTHOID_SCHEMA,
+    run: (input: CurveInput, o: Readonly<ClothoidStrategyOptions>) =>
+      clothoidCurve(input.points, {
+        ...(input.space ? { space: input.space } : {}),
+        radius: o.radius,
+        spiral: o.spiral,
+        tolerance: o.tolerance,
+      } satisfies ClothoidOptions),
+  }),
+  highway: defineStrategy({
+    step: "curve",
+    name: "highway",
+    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>) =>
+      input.lane ? highwayLane({ ...input, lane: input.lane }, o) : highwayCurve(input.points, { radius: o.radius, ...(input.space ? { space: input.space } : {}) }),
+  }),
 });
 
 /** The options of a room strategy: the options of `roomDemand`, without the method. */
 export type RoomPreset = Omit<RoomOptions, "method">;
 
 const roomStrategy = (method: RoomMethod, describe: string): Strategy<"room", RoomPreset> =>
-  defineStrategy<"room", RoomPreset>({ step: "room", name: method, describe, defaults: {}, run: (input, o) => roomDemand(input.items, input.links, { ...o, method }) });
+  defineStrategy<"room", RoomPreset>({ step: "room", name: method, describe, defaults: {}, schema: ROOM_SCHEMA, run: (input, o) => roomDemand(input.items, input.links, { ...o, method }) });
 
-/** The built-in room strategies: the methods of `roomDemand`. */
+/** The options of the room strategy `levels`: the options of `levelRoom` without the method, and the limits of the quadtree. */
+export type LevelRoomPreset = Omit<LevelRoomOptions, "method"> & SectionOptions;
+
+/** The built-in room strategies: the methods of `roomDemand`, and the room of each zoom level (`levelRoom`). */
 export const roomStrategies: {
   readonly routes: Strategy<"room", RoomPreset>;
   readonly lines: Strategy<"room", RoomPreset>;
+  readonly levels: Strategy<"room", LevelRoomPreset>;
 } = Object.freeze({
   routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
   lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap."),
+  levels: defineStrategy<"room", LevelRoomPreset>({
+    step: "room",
+    name: "levels",
+    describe: "Each zoom level gets the gaps that its links need. The far levels open first, and a box moves with its parent.",
+    defaults: {},
+    schema: LEVEL_ROOM_SCHEMA,
+    run: (input, o) => {
+      const { cap, maxDepth, collapse, ...room } = o;
+      const root = input.sections ?? buildSections(input.items, { cap: cap ?? SECTION_DEFAULTS.cap, maxDepth: maxDepth ?? SECTION_DEFAULTS.maxDepth, collapse: collapse ?? SECTION_DEFAULTS.collapse });
+      return levelRoom(input.items, input.links, root, room).gaps;
+    },
+  }),
 });
 
 /** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
 export const groupStrategies: {
   readonly quadtree: Strategy<"group", Required<SectionOptions>>;
   readonly keys: Strategy<"group", KeyOptions>;
+  readonly kd: Strategy<"group", Required<KdOptions>>;
+  readonly cut: Strategy<"group", Required<CutOptions>>;
 } = Object.freeze({
   quadtree: defineStrategy({
     step: "group",
     name: "quadtree",
     describe: "The cells of a quadtree of the plane. A cell with more than `cap` nodes splits in four. It is the default rule of the router `sections`.",
     defaults: { ...SECTION_DEFAULTS },
+    schema: SECTION_SCHEMA,
     run: (graph: Graph, o: Readonly<Required<SectionOptions>>) => quadtreeGroups(graph, o),
   }),
   keys: defineStrategy({
@@ -178,14 +319,70 @@ export const groupStrategies: {
     name: "keys",
     describe: "One group for each key of the nodes. The default key is the string `data.group` of the node. A node without a key is a group alone.",
     defaults: { key: byDataGroup } as KeyOptions,
+    schema: KEY_SCHEMA,
     run: (graph: Graph, o: Readonly<KeyOptions>) => keyGroups(graph, o),
   }),
+  kd: defineStrategy({
+    step: "group",
+    name: "kd",
+    describe: "The cells of a k-d tree of the plane. A cell with more than `cap` nodes splits in two with a line across one axis, and each half splits again.",
+    defaults: { ...KD_DEFAULTS },
+    schema: KD_SCHEMA,
+    run: (graph: Graph, o: Readonly<Required<KdOptions>>) => kdGroups(graph, o),
+  }),
+  cut: defineStrategy({
+    step: "group",
+    name: "cut",
+    describe: "A guillotine cut that reads the edges. Each line goes where it cuts the fewest edges for its balance, so the far view has fewer links.",
+    defaults: { ...CUT_DEFAULTS },
+    schema: CUT_SCHEMA,
+    run: (graph: Graph, o: Readonly<Required<CutOptions>>) => cutGroups(graph, o),
+  }),
+});
+
+/**
+ * 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/index.ts

@@ -1,2 +1,3 @@
 export * from "./model.ts";
 export * from "./builtins.ts";
+export * from "./options.ts";

package/src/strategies/model.ts

@@ -1,9 +1,12 @@
 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. */
 export interface CurveInput {
@@ -15,12 +18,34 @@ 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. */
 export interface RoomInput {
   readonly items: readonly Boxed[];
   readonly links: readonly RoomLink[];
+  /**
+   * The tree of sections of the items, for a strategy that gives room to each zoom level. The indices of its nodes are the indices of `items`.
+   * Without it, such a strategy makes the quadtree of `buildSections`. The other strategies do not read it.
+   */
+  readonly sections?: Section;
 }
 
 /**
@@ -28,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[] };
 }
@@ -48,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.
@@ -63,6 +90,8 @@ export interface Strategy<S extends Step = Step, O extends object = object> {
   readonly describe: string;
   /** The values of the options when the caller gives no value. */
   readonly defaults: Readonly<O>;
+  /** The declarations of the options: the type, the range, the step and the meaning of each one. A strategy without it declares nothing. */
+  readonly schema?: OptionSchema<O>;
   /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
   readonly maxNodes?: number;
   /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
@@ -79,23 +108,33 @@ export interface StrategyDefinition<S extends Step, O extends object> {
   readonly describe: string;
   /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
   readonly defaults: O;
+  /** These declarations tell the type, the range, the step and the meaning of each option. `checkSchema` examines them. */
+  readonly schema?: NoInfer<OptionSchema<O>>;
   readonly maxNodes?: number;
   /** This function does the step. It gets each option, from the caller or from `defaults`. */
   run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
 }
 
+/** This function gives a frozen copy of a schema, with each declaration frozen. */
+function freezeSchema<O>(schema: OptionSchema<O>): OptionSchema<O> {
+  const out: Record<string, unknown> = {};
+  for (const [key, d] of Object.entries(schema)) out[key] = Object.freeze({ ...(d as object) });
+  return Object.freeze(out) as OptionSchema<O>;
+}
+
 /**
  * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
  * When the caller gives no option, the definition gets the `defaults` object itself.
  */
 export function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O> {
-  const { step, name, describe, defaults, maxNodes } = definition;
+  const { step, name, describe, defaults, schema, maxNodes } = definition;
   if (name.length === 0) throw new Error(`A strategy of the step "${step}" has no name.`);
   const strategy: Strategy<S, O> = {
     step,
     name,
     describe,
     defaults: Object.freeze({ ...defaults }),
+    ...(schema === undefined ? {} : { schema: freezeSchema(schema) }),
     ...(maxNodes === undefined ? {} : { maxNodes }),
     run(input: StepInput<S>, options?: Partial<O>): StepOutput<S> {
       const all = options === undefined || Object.keys(options).length === 0 ? strategy.defaults : { ...strategy.defaults, ...options };
@@ -108,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. */