@mark1russell7/highways 0.9.0 → 0.9.1

package/src/routers/index.ts

@@ -9,7 +9,8 @@ import { byCollection, trunksRouter } from "./trunks.ts";
 export { boxExit, straightRouter } from "./straight.ts";
 export { plugsRouter } from "./plugs.ts";
 export { cornersRouter, type CornersOptions } from "./corners.ts";
-export { sharedRouter, type ShareCost, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
+export { sharedRouter, type ShareCost, type SharedNegotiation, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
+export { ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, attractionRouter, attractionStrategy, type AttractionOptions } from "./attraction/index.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";
 export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunkFan, type TrunkSplit, type TrunksOptions } from "./trunks.ts";
 

package/src/routers/plugs.ts

@@ -1,6 +1,6 @@
 import { inflectionCurve } from "../curves.ts";
 import { center } from "../geom.ts";
-import { nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, resolvePorts, type Graph, type Result, type Route, type Router } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 
 /**
@@ -9,7 +9,8 @@ import { placePlug } from "../plugs.ts";
  */
 export const plugsRouter: Router = {
   name: "plugs",
-  route(graph: Graph): Result {
+  route(input: Graph): Result {
+    const graph = resolvePorts(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/sections.ts

@@ -2,7 +2,7 @@ import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
 import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
 import { LEVEL_LINK_DEFAULTS, type LevelLinkOptions } from "../levels.ts";
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
-import { nodeIndex, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, resolvePorts, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 import { allSections, buildSections, checkSections, SECTION_DEFAULTS, type Section, type SectionOptions } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -91,7 +91,8 @@ const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || d
 export function sectionsRouter(options: SectionsOptions): Router {
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
       const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
       const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;

package/src/routers/shared.ts

@@ -1,5 +1,5 @@
 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 { nodeIndex, resolvePorts, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { channelWidth } from "../channels.ts";
 import { orderRun } from "../lane-order.ts";
 import { stretchLaneOrders, type LaneStretchOrder } from "../lane-orders/stretch/index.ts";
@@ -77,6 +77,21 @@ export interface SharedOptions extends WayOptions {
   readonly maxNodes?: number;
 }
 
+/**
+ * The negotiation of the router `attraction` (HWY-044, PathFinder turned around). Each pass routes each edge again from no ways.
+ * A link costs `len (1 - attraction h) (1 + weight max(0, use - cap))` more than in `shared`, with `h` the history of the link.
+ */
+export interface SharedNegotiation {
+  /** The number of passes, 1 or more. */
+  readonly passes: number;
+  /** The pull of the history of a link, from 0 to 1. */
+  readonly attraction: number;
+  /** The cost weight of each edge over the capacity of a link, 0 or more. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width, and 1 or more. */
+  readonly laneWidth: number;
+}
+
 /** A way of one edge through the corner graph. */
 export interface Way {
   readonly edge: Edge;
@@ -114,7 +129,7 @@ function turn(from: Point, base: Point, to: Point): number {
  * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
  * The result gives each stretch as a run, with the order of its lanes.
  */
-export function sharedRouter(options: SharedOptions): Router {
+export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation): Router {
   const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
   const flow = options.cost === "flow";
   const alpha = Math.min(1, Math.max(0.1, options.alpha ?? 0.6));
@@ -133,7 +148,8 @@ export function sharedRouter(options: SharedOptions): Router {
   };
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const corners = ways.corners;
@@ -172,8 +188,11 @@ export function sharedRouter(options: SharedOptions): Router {
         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 => {
+      /**
+       * This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`.
+       * `history` holds the history of each link of the key, for the negotiation of `attraction`.
+       */
+      const route = (w: Way, before?: ReadonlyMap<number, number>, history?: ReadonlyMap<number, number>): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
@@ -192,6 +211,20 @@ export function sharedRouter(options: SharedOptions): Router {
           cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
           floor /= (1 + reuse * most) ** reuseExponent;
         }
+        if (negotiation !== undefined && history !== undefined) {
+          const plain = cost;
+          const a = negotiation.attraction;
+          const b = negotiation.capacityWeight;
+          let most = 0;
+          for (const h of history.values()) most = Math.max(most, h);
+          cost = (i, j, d) => {
+            const k = link(i, j);
+            const use = (mine.get(k)?.length ?? 0) + 1;
+            const cap = Math.max(1, Math.floor(widthOf(i, j) / negotiation.laneWidth));
+            return plain(i, j, d) * (1 - a * (history.get(k) ?? 0)) * (1 + b * Math.max(0, use - cap));
+          };
+          floor *= 1 - a * most;
+        }
         const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
         if (!way) return;
         w.found = true;
@@ -207,9 +240,39 @@ export function sharedRouter(options: SharedOptions): Router {
           if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b))!.length));
         }
       };
-      for (const w of order) route(w);
+      /**
+       * This function gives the passes of the negotiation (HWY-044). After each pass, the history of each link grows by `use / m`,
+       * with `m` the edges of the key, up to `0.9 / attraction`. Each later pass routes each edge again from no ways.
+       */
+      const negotiate = (list: readonly Way[]): void => {
+        const nego = negotiation!;
+        const histories = new Map<string, Map<number, number>>();
+        const size = new Map<string, number>();
+        for (const w of list) size.set(w.key, (size.get(w.key) ?? 0) + 1);
+        const most = nego.attraction > 0 ? 0.9 / nego.attraction : Infinity;
+        for (let pass = 0; pass < Math.max(1, Math.floor(nego.passes)); pass++) {
+          if (pass > 0) {
+            for (const [key, links] of discounted) {
+              let h = histories.get(key);
+              if (!h) histories.set(key, (h = new Map()));
+              const m = size.get(key) ?? 1;
+              for (const [k, users] of links) h.set(k, Math.min(most, (h.get(k) ?? 0) + users.length / m));
+            }
+            discounted.clear();
+            top.clear();
+            for (const w of list) {
+              w.found = false;
+              w.seq = [];
+              w.ids = [];
+            }
+          }
+          for (const w of list) route(w, undefined, histories.get(w.key) ?? new Map());
+        }
+      };
+      if (negotiation !== undefined) negotiate(order);
+      else for (const w of order) route(w);
       // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
-      for (let pass = 1; pass < passes; pass++) {
+      for (let pass = 1; negotiation === undefined && 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>>();

package/src/routers/straight.ts

@@ -1,5 +1,5 @@
 import { center, type Box, type Point } from "../geom.ts";
-import { fixedPortPoint, nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { fixedPortPoint, nodeIndex, resolvePorts, type Graph, type Result, type Route, type Router } from "../model.ts";
 
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export function boxExit(box: Box, toward: Point): Point {
@@ -19,7 +19,8 @@ export function boxExit(box: Box, toward: Point): Point {
  */
 export const straightRouter: Router = {
   name: "straight",
-  route(graph: Graph): Result {
+  route(input: Graph): Result {
+    const graph = resolvePorts(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/trunks.ts

@@ -1,5 +1,5 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, resolvePorts, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
@@ -209,7 +209,8 @@ export function trunksRouter(options: TrunksOptions): Router {
   const rule = groupRuleOf(options.rule);
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const points = new Map<string, readonly Point[]>();

package/src/strategies/builtins.ts

@@ -44,6 +44,11 @@ import { TERRITORY_DEFAULTS, territoryPlan, type TerritoryOptions } from "../hig
 import { CONSENSUS_DEFAULTS, consensusPlan, type ConsensusOptions } from "../highways/consensus/index.ts";
 import { P_HUB_DEFAULTS, pHubPlan, type PHubOptions } from "../highways/p-hub/index.ts";
 import { SCALE_SPACE_DEFAULTS, scaleSpacePlan, type ScaleSpaceOptions } from "../highways/scale-space/index.ts";
+import { GAP_DEFAULTS, gapPlan, type GapOptions } from "../highways/gaps/index.ts";
+import { INTERCHANGE_DEFAULTS, interchangePlan, type InterchangeOptions } from "../highways/interchanges/index.ts";
+import { SEARCH_DEFAULTS, searchPlan, type SearchOptions } from "../highways/search/index.ts";
+import { STEINER_DEFAULTS, steinerPlan, type SteinerOptions } from "../highways/steiner/index.ts";
+import { STREET_DEFAULTS, streetPlan, type StreetOptions } from "../highways/streets/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";
@@ -83,7 +88,7 @@ import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type
 import type { OptionSchema } from "./options.ts";
 import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
 import { DEPTHS_SCHEMA, PIPELINE_SCHEMA } from "./schemas.ts";
-import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_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">;
@@ -462,6 +467,11 @@ export const highwayStrategies: {
   readonly consensus: Strategy<"highway", ConsensusOptions>;
   readonly "p-hub": Strategy<"highway", PHubOptions>;
   readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
+  readonly steiner: Strategy<"highway", SteinerOptions>;
+  readonly gaps: Strategy<"highway", GapOptions>;
+  readonly streets: Strategy<"highway", StreetOptions>;
+  readonly search: Strategy<"highway", SearchOptions>;
+  readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -892,6 +902,51 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<ScaleSpaceOptions>) => scaleSpacePlan(input, o),
   }),
+  steiner: defineStrategy({
+    step: "highway",
+    name: "steiner",
+    describe: "Obstacle-avoiding rectilinear Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree, and the stretches that edges share become highways.",
+    defaults: { ...STEINER_DEFAULTS } as SteinerOptions,
+    schema: STEINER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SteinerOptions>) => steinerPlan(input, o),
+  }),
+  gaps: defineStrategy({
+    step: "highway",
+    name: "gaps",
+    describe: "Gap highways (HWY-057). The free middle lines of the gaps are streets, and a street that enough edges choose becomes a highway.",
+    defaults: { ...GAP_DEFAULTS } as GapOptions,
+    schema: GAP_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<GapOptions>) => gapPlan(input, o),
+  }),
+  streets: defineStrategy({
+    step: "highway",
+    name: "streets",
+    describe: "Orthogonal streets by a greedy set cover (HWY-058). Each step takes the street that its new edges ride the most per unit of its length.",
+    defaults: { ...STREET_DEFAULTS } as StreetOptions,
+    schema: STREET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<StreetOptions>) => streetPlan(input, o),
+  }),
+  search: defineStrategy({
+    step: "highway",
+    name: "search",
+    describe: "A local search over the set of highways (HWY-059). The annealing adds, drops and moves highways, edges and points on a score of the bundle measures.",
+    defaults: { ...SEARCH_DEFAULTS } as SearchOptions,
+    schema: SEARCH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SearchOptions>) => searchPlan(input, o),
+  }),
+  interchanges: defineStrategy({
+    step: "highway",
+    name: "interchanges",
+    describe: "A network of highways with interchanges (HWY-060). Each edge rides up to a number of highways, with a cost for each change.",
+    defaults: { ...INTERCHANGE_DEFAULTS } as InterchangeOptions,
+    schema: INTERCHANGE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<InterchangeOptions>) => interchangePlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),

package/src/strategies/schemas.ts

@@ -39,6 +39,11 @@ import type { ResistanceOptions } from "../highways/resistance/index.ts";
 import type { RidgeOptions } from "../highways/ridges/index.ts";
 import type { RoadClassOptions } from "../highways/road-classes/index.ts";
 import type { ScaleSpaceOptions } from "../highways/scale-space/index.ts";
+import type { GapOptions } from "../highways/gaps/index.ts";
+import type { InterchangeOptions } from "../highways/interchanges/index.ts";
+import type { SearchOptions } from "../highways/search/index.ts";
+import type { SteinerOptions } from "../highways/steiner/index.ts";
+import type { StreetOptions } from "../highways/streets/index.ts";
 import type { SelectOptions } from "../highways/select/index.ts";
 import type { SoftKeyOptions } from "../highways/soft-keys/index.ts";
 import type { SpectralOptions } from "../highways/spectral/index.ts";
@@ -925,3 +930,54 @@ export const PIPELINE_SCHEMA: OptionSchema<PipelineOptions> = {
   room: { type: "strategy", step: "room", describe: "The room strategy. With it, the gaps of the board open before the routes. Without it, the board stays." },
   roomOptions: { type: "object", describe: "The options of the room strategy." },
 };
+
+/** The declarations of the options of the highway strategy `steiner` (HWY-036 with EDA-015). */
+export const STEINER_SCHEMA: OptionSchema<SteinerOptions> = {
+  group: { type: "enum", values: ["source", "key"], default: "source", describe: "The groups of the trees: the edges from one source node, or the edges of one collection." },
+  method: { type: "enum", values: ["one-steiner", "spanning"], default: "one-steiner", describe: "The method of the tree: the iterated 1-Steiner method, or the spanning tree of the terminals." },
+  maxGroup: { type: "integer", min: 3, max: 32, step: 1, marks: [8, 12, 16], default: 12, describe: "A group with more terminals than this number gets the spanning tree alone." },
+  metric: { type: "enum", values: ["rectilinear", "octilinear"], default: "rectilinear", describe: "The metric of the tree: two directions or four directions." },
+  detour: { type: "number", min: 1, max: 3, step: 0.05, marks: [1.25, 1.5, 2], default: 1.5, describe: "An edge rides the tree only when its path in the tree is this many times its first route or less." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A stretch of a tree with fewer edges than this number is not a highway." },
+};
+
+/** The declarations of the options of the highway strategy `gaps` (HWY-057). */
+export const GAP_SCHEMA: OptionSchema<GapOptions> = {
+  minSize: { type: "integer", min: 2, max: 16, step: 1, marks: [2, 3, 6], default: 3, describe: "A street with fewer edges than this number (the demand) is not a highway." },
+  discount: { type: "number", min: 0.1, max: 0.8, step: 0.05, marks: [0.3, 0.5, 0.7], default: 0.5, describe: "The cost of a length on a street against a length off the streets." },
+  detour: { type: "number", min: 1, max: 2, step: 0.05, marks: [1.2, 1.3, 1.5], default: 1.3, describe: "An edge rides a street only when its way along the street is this many times its first route or less." },
+  source: { type: "enum", values: ["room", "corners"], default: "room", describe: "The source of the streets: the gaps of the room step, or the lines through the corners." },
+};
+
+/** The declarations of the options of the highway strategy `streets` (HWY-058). */
+export const STREET_SCHEMA: OptionSchema<StreetOptions> = {
+  detour: { type: "number", min: 1, max: 1.5, step: 0.05, marks: [1.1, 1.2, 1.3], default: 1.2, describe: "A street covers an edge when the way of the edge along it is this many times its first route or less." },
+  minGain: { type: "number", min: 1, max: 8, step: 0.25, marks: [1.5, 2, 4], default: 2, describe: "The cover stops when the best street gives less gain: the length that its edges ride over its length." },
+  maxStreets: { type: "integer", min: 4, max: 64, step: 4, marks: [16, 32], default: 32, describe: "The largest number of streets." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A street with fewer new edges than this number is not a highway." },
+  source: { type: "enum", values: ["room", "corners"], default: "corners", describe: "The source of the streets: the gaps of the room step, or the lines through the corners." },
+};
+
+/** The declarations of the options of the highway strategy `search` (HWY-059). */
+export const SEARCH_SCHEMA: OptionSchema<SearchOptions> = {
+  from: { type: "enum", values: ["corridors", "quickbundles", "wspd", "road-classes", "flow-field", "od-cells", "shared-ways"], default: "corridors", describe: "The plan where the search starts." },
+  pool: { type: "list", default: ["quickbundles", "road-classes"], describe: "The generators of the highways that the move `add` takes." },
+  evaluations: { type: "integer", min: 0, max: 400, step: 4, marks: [0, 16, 64], default: 16, describe: "The number of plans that the search measures. The value 0 gives the start plan." },
+  temperature: { type: "number", min: 0, max: 0.2, step: 0.005, marks: [0, 0.02, 0.05], default: 0.02, describe: "The first temperature of the annealing, on the scale of the score." },
+  inkWeight: { type: "number", min: 0, max: 4, step: 0.25, marks: [1], default: 1, describe: "The weight of the ink that the routes save (B1)." },
+  stretchWeight: { type: "number", min: 0, max: 4, step: 0.25, marks: [0.5], default: 0.5, describe: "The weight of the 0.95 quantile of the stretch (B3)." },
+  ambiguityWeight: { type: "number", min: 0, max: 4, step: 0.25, marks: [0.5], default: 0.5, describe: "The weight of the ambiguity (B4)." },
+  angleWeight: { type: "number", min: 0, max: 4, step: 0.25, marks: [0.25], default: 0.25, describe: "The weight of the largest merge angle (B6), divided by 180 degrees." },
+  seed: { type: "integer", min: 0, max: 1000, step: 1, default: 1, describe: "The seed of the moves." },
+};
+
+/** The declarations of the options of the highway strategy `interchanges` (HWY-060). */
+export const INTERCHANGE_SCHEMA: OptionSchema<InterchangeOptions> = {
+  from: { type: "enum", values: ["corridors", "shared-ways"], default: "corridors", describe: "The plan that gives the highways of the network." },
+  changeCost: { type: "number", min: 0, max: 8, step: 0.5, marks: [0, 2, 4], default: 2, describe: "The cost of a change between two highways, in units of the board." },
+  interchanges: { type: "integer", min: 1, max: 32, step: 1, marks: [4, 16], default: 16, describe: "The largest number of interchanges." },
+  perEdge: { type: "integer", min: 1, max: 3, step: 1, default: 2, describe: "The largest number of highways on the way of one edge." },
+  radius: { type: "number", min: 0.5, max: 8, step: 0.5, marks: [1, 2, 4], default: 2, describe: "Two highways get an interchange where they come this near, in units of the board." },
+  discount: { type: "number", min: 0.1, max: 1, step: 0.05, marks: [0.3, 0.5, 0.7], default: 0.5, describe: "The cost of a length on a highway against a length off the highways." },
+  detour: { type: "number", min: 1, max: 3, step: 0.05, marks: [1.25, 1.5, 2], default: 1.5, describe: "An edge rides the network only when its way is this many times its first route or less." },
+};