@mark1russell7/highways 0.4.2 → 0.5.1

package/src/strategies/builtins.ts

@@ -18,17 +18,51 @@ import { hysteresisGate, type HysteresisOptions } from "../highways/gates/hyster
 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 { DIVIDED_DEFAULTS, dividedPlan, type DividedOptions } from "../highways/divided/index.ts";
+import { HIERARCHY_DEFAULTS, hierarchyPlan, type HierarchyOptions } from "../highways/hierarchy/index.ts";
+import { FDEB_DEFAULTS, fdebPlan, type FdebOptions } from "../highways/fdeb/index.ts";
+import { MESH_DEFAULTS, meshPlan, type MeshOptions } from "../highways/mesh/index.ts";
+import { KDEEB_DEFAULTS, kdeebPlan, type KdeebOptions } from "../highways/kdeeb/index.ts";
+import { CUBU_DEFAULTS, cubuPlan, type CubuOptions } from "../highways/cubu/index.ts";
+import { MLSEB_DEFAULTS, mlsebPlan, type MlsebOptions } from "../highways/mlseb/index.ts";
+import { SBEB_DEFAULTS, sbebPlan, type SbebOptions } from "../highways/sbeb/index.ts";
+import { AREA_DEFAULTS, areaPlan, type AreaOptions } from "../highways/areas/index.ts";
+import { CONFLUENT_DEFAULTS, confluentPlan, type ConfluentOptions } from "../highways/confluent/index.ts";
+import { POWER_DEFAULTS, powerPlan, type PowerOptions } from "../highways/power/index.ts";
+import { CROSSBAR_DEFAULTS, crossbarPlan, type CrossbarOptions } from "../highways/crossbars/index.ts";
+import { FRECHET_DEFAULTS, frechetPlan, type FrechetOptions } from "../highways/frechet/index.ts";
+import { SPECTRAL_DEFAULTS, spectralPlan, type SpectralOptions } from "../highways/spectral/index.ts";
+import { RESISTANCE_DEFAULTS, resistancePlan, type ResistanceOptions } from "../highways/resistance/index.ts";
+import { LINK_COMMUNITY_DEFAULTS, linkCommunityPlan, type LinkCommunityOptions } from "../highways/link-communities/index.ts";
+import { TERRITORY_DEFAULTS, territoryPlan, type TerritoryOptions } from "../highways/territories/index.ts";
+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 { 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";
@@ -44,7 +78,8 @@ 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, FLOW_FIELD_SCHEMA, HIGHWAY_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_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_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";
 
 /** 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">;
@@ -389,6 +424,40 @@ export const highwayStrategies: {
   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 divided: Strategy<"highway", DividedOptions>;
+  readonly hierarchy: Strategy<"highway", HierarchyOptions>;
+  readonly fdeb: Strategy<"highway", FdebOptions>;
+  readonly mesh: Strategy<"highway", MeshOptions>;
+  readonly kdeeb: Strategy<"highway", KdeebOptions>;
+  readonly cubu: Strategy<"highway", CubuOptions>;
+  readonly mlseb: Strategy<"highway", MlsebOptions>;
+  readonly sbeb: Strategy<"highway", SbebOptions>;
+  readonly areas: Strategy<"highway", AreaOptions>;
+  readonly confluent: Strategy<"highway", ConfluentOptions>;
+  readonly power: Strategy<"highway", PowerOptions>;
+  readonly crossbars: Strategy<"highway", CrossbarOptions>;
+  readonly frechet: Strategy<"highway", FrechetOptions>;
+  readonly spectral: Strategy<"highway", SpectralOptions>;
+  readonly resistance: Strategy<"highway", ResistanceOptions>;
+  readonly "link-communities": Strategy<"highway", LinkCommunityOptions>;
+  readonly territories: Strategy<"highway", TerritoryOptions>;
+  readonly consensus: Strategy<"highway", ConsensusOptions>;
+  readonly "p-hub": Strategy<"highway", PHubOptions>;
+  readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -513,6 +582,312 @@ export const highwayStrategies: {
     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: "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<HubArcOptions>) => hubArcPlan(input, o),
+  }),
+  divided: defineStrategy({
+    step: "highway",
+    name: "divided",
+    describe: "Divided edge bundling (HWY-011). Each highway of two-way traffic splits into two carriageways at an offset, one for each direction.",
+    defaults: { ...DIVIDED_DEFAULTS } as DividedOptions,
+    schema: DIVIDED_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<DividedOptions>) => dividedPlan(input, o),
+  }),
+  hierarchy: defineStrategy({
+    step: "highway",
+    name: "hierarchy",
+    describe: "Hierarchical edge bundling (HWY-001). Each edge goes near the hubs of the sections between its two leaves, and the shared stretches become highways.",
+    defaults: { ...HIERARCHY_DEFAULTS } as HierarchyOptions,
+    schema: HIERARCHY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HierarchyOptions>) => hierarchyPlan(input, o),
+  }),
+  fdeb: defineStrategy({
+    step: "highway",
+    name: "fdeb",
+    describe: "Force-directed edge bundling with a field of the boxes (HWY-002 with RULE-002). The bundled points snap back to legal ways.",
+    defaults: { ...FDEB_DEFAULTS } as FdebOptions,
+    schema: FDEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FdebOptions>) => fdebPlan(input, o),
+  }),
+  mesh: defineStrategy({
+    step: "highway",
+    name: "mesh",
+    describe: "A control mesh (HWY-004). The crossings of the edges with the mesh form clusters, and the edges of a cluster share its point.",
+    defaults: { ...MESH_DEFAULTS } as MeshOptions,
+    schema: MESH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MeshOptions>) => meshPlan(input, o),
+  }),
+  kdeeb: defineStrategy({
+    step: "highway",
+    name: "kdeeb",
+    describe: "Density bundling with a mask of the free space (RULE-028 with HWY-006). The edges move up the density, and the ridges become highways.",
+    defaults: { ...KDEEB_DEFAULTS } as KdeebOptions,
+    schema: KDEEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<KdeebOptions>) => kdeebPlan(input, o),
+  }),
+  cubu: defineStrategy({
+    step: "highway",
+    name: "cubu",
+    describe: "Fast density bundling (HWY-007). The steps of `kdeeb` with a separable blur or a Fourier transform of the counts of the cells.",
+    defaults: { ...CUBU_DEFAULTS } as CubuOptions,
+    schema: CUBU_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<CubuOptions>) => cubuPlan(input, o),
+  }),
+  mlseb: defineStrategy({
+    step: "highway",
+    name: "mlseb",
+    describe: "Moving least squares bundling (HWY-008). Each point of an edge moves to a local fit of the near edges, and the bundled points snap back to legal ways.",
+    defaults: { ...MLSEB_DEFAULTS } as MlsebOptions,
+    schema: MLSEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MlsebOptions>) => mlsebPlan(input, o),
+  }),
+  sbeb: defineStrategy({
+    step: "highway",
+    name: "sbeb",
+    describe: "Skeleton-based edge bundling (HWY-009). The edges of a group move toward the skeleton of their shape, and the bundled points snap back to legal ways.",
+    defaults: { ...SBEB_DEFAULTS } as SbebOptions,
+    schema: SBEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SbebOptions>) => sbebPlan(input, o),
+  }),
+  areas: defineStrategy({
+    step: "highway",
+    name: "areas",
+    describe: "Image-based edge bundles (HWY-010). Each group of edges is one shaded area around the longest path of the skeleton of its shape.",
+    defaults: { ...AREA_DEFAULTS } as AreaOptions,
+    schema: AREA_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<AreaOptions>) => areaPlan(input, o),
+  }),
+  confluent: defineStrategy({
+    step: "highway",
+    name: "confluent",
+    describe: "Confluent drawings (HWY-013). Each biclique of a greedy search is one track, with a merge junction and a split junction.",
+    defaults: { ...CONFLUENT_DEFAULTS } as ConfluentOptions,
+    schema: CONFLUENT_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ConfluentOptions>) => confluentPlan(input, o),
+  }),
+  power: defineStrategy({
+    step: "highway",
+    name: "power",
+    describe: "Edge compression with modules and power graphs (HWY-014). The edges between two modules are one power edge, and a large power edge is a highway.",
+    defaults: { ...POWER_DEFAULTS } as PowerOptions,
+    schema: POWER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<PowerOptions>) => powerPlan(input, o),
+  }),
+  crossbars: defineStrategy({
+    step: "highway",
+    name: "crossbars",
+    describe: "Bundled crossings (HWY-022). Two sets of edges that cross near one place cross as two bundles, at one place.",
+    defaults: { ...CROSSBAR_DEFAULTS } as CrossbarOptions,
+    schema: CROSSBAR_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<CrossbarOptions>) => crossbarPlan(input, o),
+  }),
+  frechet: defineStrategy({
+    step: "highway",
+    name: "frechet",
+    describe: "Subtrajectory clusters by the discrete Fréchet distance (HWY-027). The parts of the first routes that stay near one reference part become highways.",
+    defaults: { ...FRECHET_DEFAULTS } as FrechetOptions,
+    schema: FRECHET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FrechetOptions>) => frechetPlan(input, o),
+  }),
+  spectral: defineStrategy({
+    step: "highway",
+    name: "spectral",
+    describe: "Spectral clustering of the compatibility graph of the edges (HWY-029). The largest eigengap gives the number of clusters, and each cluster gets highways.",
+    defaults: { ...SPECTRAL_DEFAULTS } as SpectralOptions,
+    schema: SPECTRAL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SpectralOptions>) => spectralPlan(input, o),
+  }),
+  resistance: defineStrategy({
+    step: "highway",
+    name: "resistance",
+    describe: "Spectral bundling with the effective resistance (HWY-021). A pair of two bridges of the graph gets a lower weight, then the clusters of `spectral` apply.",
+    defaults: { ...RESISTANCE_DEFAULTS } as ResistanceOptions,
+    schema: RESISTANCE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ResistanceOptions>) => resistancePlan(input, o),
+  }),
+  "link-communities": defineStrategy({
+    step: "highway",
+    name: "link-communities",
+    describe: "Link communities on the line graph (HWY-030). The edges with a common node and similar neighbours form communities, and each community gets highways.",
+    defaults: { ...LINK_COMMUNITY_DEFAULTS } as LinkCommunityOptions,
+    schema: LINK_COMMUNITY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<LinkCommunityOptions>) => linkCommunityPlan(input, o),
+  }),
+  territories: defineStrategy({
+    step: "highway",
+    name: "territories",
+    describe: "Territory aggregation of flows (HWY-033). The plugs and bends form cells, and the strong flows between two neighbour cells become highways.",
+    defaults: { ...TERRITORY_DEFAULTS } as TerritoryOptions,
+    schema: TERRITORY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<TerritoryOptions>) => territoryPlan(input, o),
+  }),
+  consensus: defineStrategy({
+    step: "highway",
+    name: "consensus",
+    describe: "A consensus of clusterings (HWY-035). The finders vote on the pairs of edges, and the pairs that most finders agree on form the highways.",
+    defaults: { ...CONSENSUS_DEFAULTS } as ConsensusOptions,
+    schema: CONSENSUS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ConsensusOptions>) => consensusPlan(input, o),
+  }),
+  "p-hub": defineStrategy({
+    step: "highway",
+    name: "p-hub",
+    describe: "Hub location with the p-hub median (HWY-041). The p-median of the plugs gives the hubs, and the links between two hubs become highways.",
+    defaults: { ...P_HUB_DEFAULTS } as PHubOptions,
+    schema: P_HUB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<PHubOptions>) => pHubPlan(input, o),
+  }),
+  "scale-space": defineStrategy({
+    step: "highway",
+    name: "scale-space",
+    describe: "A scale space with persistence (HWY-053). The clusters of edges that live over a long range of scales get highways at the scale of the plan.",
+    defaults: { ...SCALE_SPACE_DEFAULTS } as ScaleSpaceOptions,
+    schema: SCALE_SPACE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ScaleSpaceOptions>) => scaleSpacePlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),