@mark1russell7/highways 0.5.0 → 0.6.0

package/src/portfolio/router.ts

@@ -0,0 +1,133 @@
+// The portfolio router (PORTFOLIO-API, PORTFOLIO-FIT): it runs the base `shared` and a small greedy set of members on an input, and gives the output with the most
+// ink saved inside the rule and the stretch cap of the caller. The combinator is `portfolio` of `@mark1russell7/layout-contract`.
+// The router is opt-in: it is not in the registry `STRATEGIES`, so no default output changes.
+import { pickMoves, portfolio, type Member, type PortfolioTrace } from "../bench/screen/portfolio-pick.ts";
+import type { Graph, Result, Router } from "../model.ts";
+import { asRouter, defineStrategy, type Strategy } from "../strategies/model.ts";
+import { PORTFOLIO_CAPS, PORTFOLIO_KS_API, PORTFOLIO_RULES, portfolioBand, type PortfolioCap, type PortfolioRule } from "./bands.ts";
+import { PORTFOLIO_FIT } from "./fit.ts";
+import { portfolioKey } from "./key.ts";
+import { portfolioMember } from "./members.ts";
+import { PORTFOLIO_SETS } from "./sets.ts";
+
+/** The options of the portfolio router. */
+export interface PortfolioRouterOptions {
+  /** The rule of the caller. Under `collection` (the default), a shared segment must hold edges of one collection only. Under `all`, collections can mix. */
+  readonly rule?: PortfolioRule;
+  /** The stretch cap of the caller: 1.1, 1.25 or 1.5 (the default). An output with an edge above the cap does not win. The base is the fallback output. */
+  readonly cap?: PortfolioCap;
+  /**
+   * The count of members after the base: 3, 5 or 8. Without `k` (the default), the router runs the fit of `fit.ts`.
+   * The fit gives a member count for each rule, cap and band, and a node limit for each member. Thus the default is deterministic.
+   */
+  readonly k?: 3 | 5 | 8;
+  /**
+   * A time limit of the pick in milliseconds, as a ceiling that the caller sets. The base always runs. The combinator cuts the members that start after the limit.
+   * A cut by the budget makes the output depend on the speed of the machine. Then the trace has `deterministic: false`.
+   */
+  readonly budgetMs?: number;
+  /** The largest count of members that run, with the base. */
+  readonly maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`. */
+  readonly now?: () => number;
+}
+
+/** The base member of each portfolio: the router `shared` with the rule `byCollection`. It is the fallback output above the cap. */
+export const PORTFOLIO_BASE_MEMBER = "shared";
+
+/** The result of the portfolio router: the output of the winner, the winner, the trace of the pick, the move counts and the band. */
+export interface PortfolioRoute {
+  readonly result: Result;
+  readonly winner: string;
+  readonly trace: PortfolioTrace;
+  /** The move count of the pick (ACTIVATION): `{ "move.pick": 1 }` when the winner is not the base and has another output. */
+  readonly moves: Readonly<Record<string, number>>;
+  /** The size band of the input, from its node count. */
+  readonly band: string;
+  /** The names of the members, in their order. */
+  readonly members: readonly string[];
+}
+
+/** This function checks the options of the portfolio router, and gives them with their defaults. It throws a `RangeError` for a bad value. */
+function checked(o: PortfolioRouterOptions): { rule: PortfolioRule; cap: PortfolioCap; k: 3 | 5 | 8 | undefined } {
+  const rule = o.rule ?? "collection";
+  const cap = o.cap ?? 1.5;
+  const k = o.k;
+  if (!PORTFOLIO_RULES.includes(rule)) throw new RangeError(`The portfolio router has the rule "${String(rule)}". It must be ${PORTFOLIO_RULES.join(" or ")}.`);
+  if (!PORTFOLIO_CAPS.includes(cap)) throw new RangeError(`The portfolio router has the cap ${String(cap)}. It must be ${PORTFOLIO_CAPS.join(", ")}.`);
+  if (k !== undefined && !PORTFOLIO_KS_API.includes(k)) throw new RangeError(`The portfolio router has the k ${String(k)}. It must be ${PORTFOLIO_KS_API.join(", ")}.`);
+  return { rule, cap, k };
+}
+
+/** This function gives the name of the portfolio router with the options `options`: `portfolio-<rule>-<cap>-k<k>`, or `portfolio-<rule>-<cap>-fit` without `k`. */
+export function portfolioName(options: PortfolioRouterOptions = {}): string {
+  const { rule, cap, k } = checked(options);
+  return `portfolio-${rule}-${cap}-${k === undefined ? "fit" : `k${k}`}`;
+}
+
+/**
+ * This function gives the names of the members for an input with `nodes` nodes. The base comes first.
+ * - With `k`, the first `k` names of the set of the band follow.
+ * - Without `k`, the members of the fit of the band follow, each only when `nodes` is at or below its node limit.
+ */
+export function portfolioMembers(nodes: number, options: PortfolioRouterOptions = {}): string[] {
+  const { rule, cap, k } = checked(options);
+  const key: `${PortfolioRule}|${PortfolioCap}|${string}` = `${rule}|${cap}|${portfolioBand(nodes).id}`;
+  if (k === undefined) return [PORTFOLIO_BASE_MEMBER, ...(PORTFOLIO_FIT[key] ?? []).filter(([s, limit]) => s !== PORTFOLIO_BASE_MEMBER && nodes <= limit).map(([s]) => s)];
+  const set = PORTFOLIO_SETS[key] ?? [];
+  return [PORTFOLIO_BASE_MEMBER, ...set.filter((s) => s !== PORTFOLIO_BASE_MEMBER).slice(0, k)];
+}
+
+/**
+ * This function routes the graph `graph` with the portfolio of its size band, rule and cap. The base runs first, then the members in their order.
+ * The key is `portfolioKey`: a member wins only when it passes the guard against the base. Of those members, the winner has the most ink saved.
+ * A tie within the `minEffect` of B1 goes to the first member (`selectBest`). A member that throws does not win.
+ * The result carries the trace of the pick and the move count `move.pick`.
+ */
+export function routePortfolio(graph: Graph, options: PortfolioRouterOptions = {}): PortfolioRoute {
+  // A member with a node limit below the size of the graph does not run. The base `shared` has no such limit below the limit of the router.
+  const names = portfolioMembers(graph.nodes.length, options).filter((name) => name === PORTFOLIO_BASE_MEMBER || (portfolioMember(name)?.maxNodes ?? Infinity) >= graph.nodes.length);
+  const { rule, cap } = checked(options);
+  // The key compares each member with the output of the base, so the run of the base keeps its output.
+  let base: Result | undefined;
+  const members: Member<Graph, Result>[] = names.map((name) => {
+    const s = portfolioMember(name);
+    if (s === undefined) throw new Error(`The portfolio router has no member "${name}".`);
+    const router = asRouter(s);
+    if (name !== PORTFOLIO_BASE_MEMBER) return { id: name, run: (g: Graph) => router.route(g) };
+    return {
+      id: name,
+      run: (g: Graph) => {
+        base = router.route(g);
+        return base;
+      },
+    };
+  });
+  const p = portfolio(portfolioName(options), members, portfolioKey(graph, rule, cap, () => base), {
+    ...(options.budgetMs === undefined ? {} : { budgetMs: options.budgetMs }),
+    ...(options.maxMembers === undefined ? {} : { maxMembers: options.maxMembers }),
+    ...(options.now === undefined ? {} : { now: options.now }),
+  });
+  const pick = p.pick(graph);
+  const moves = Object.fromEntries(Object.entries(pickMoves(pick.trace)).map(([k, v]) => [`move.${k}`, v]));
+  return { result: pick.output, winner: pick.winner, trace: pick.trace, moves, band: portfolioBand(graph.nodes.length).id, members: names };
+}
+
+/** This function gives a router that routes each graph with `routePortfolio` and the options `options`. Its name is `portfolioName(options)`. */
+export function portfolioRouter(options: PortfolioRouterOptions = {}): Router {
+  checked(options);
+  return { name: portfolioName(options), maxNodes: 10_000, route: (graph) => routePortfolio(graph, options).result };
+}
+
+/**
+ * The portfolio router as a router strategy. It is not in the registry `STRATEGIES`, so the benchmark and the site do not race it by default.
+ * A caller adds it to a registry of its own, or calls `routePortfolio` for the trace.
+ */
+export const portfolioStrategy: Strategy<"router", PortfolioRouterOptions> = defineStrategy<"router", PortfolioRouterOptions>({
+  step: "router",
+  name: "portfolio",
+  describe: "The portfolio router (PORTFOLIO-API). It runs `shared` and the fit of the size band, and gives the output with the most ink saved inside the rule and the cap.",
+  defaults: { rule: "collection", cap: 1.5 },
+  maxNodes: 10_000,
+  run: (graph, options) => routePortfolio(graph, options).result,
+});

package/src/portfolio/sets.ts

@@ -0,0 +1,40 @@
+// This file is generated by `scripts/portfolio-sets.ts` (`pnpm portfolio:sets`). Do not edit it. The test `sets.test.ts` checks that it is current.
+// The records come from the CI runs 40631516113, 40644555345, 40644557536, 40644560237, 40644562652, 40644565132, 40644567956, 40644570455, 40644572910, 40644575649, 40644578541, 40644580965, 40644583603, 40665016754.
+import type { PortfolioCap, PortfolioRule } from "./bands.ts";
+
+/**
+ * The greedy set of each rule, cap and size band, by the key `<rule>|<cap>|<band>`. The set of k strategies is the first k names.
+ * Each set comes from the train seeds (0 to 4) of its band. The base `shared` is not in a set: the portfolio always runs it first.
+ */
+export const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly string[]>> = {
+  "collection|1.1|n1-12": ["corners-side", "w2c:select+stretch", "trunks-gilbert-a05", "w3a:spiral-a15", "trunks-tree-bf08", "hw:zipper", "w2c:level-links+stretch-b1.1", "hw:stubs"],
+  "collection|1.1|n13-24": ["w3e:crossbars+stretch", "trunks-tree-bf08", "corners-side", "shared-p2", "w2c:zipper+stretch-b1.1", "hw:weiszfeld", "trunks-gilbert-a07", "hw:stubs"],
+  "collection|1.1|n25-40": ["w2a:shared-ways+breakeven", "w2b:weiszfeld-a1", "w2c:level-links+stretch-b1.1"],
+  "collection|1.1|n41-64": [],
+  "collection|1.1|n65-128": [],
+  "collection|1.25|n1-12": ["corners-side", "trunks-tree-bf06", "w3f:p-hub-a0.2", "hw:stubs", "hw:p-hub", "hw:spiral", "w2c:level-links+stretch", "w3f:spectral-c0.3"],
+  "collection|1.25|n13-24": ["w2a:shared-ways+stretch", "shared-p3", "trunks-gilbert-a07", "w3e:crossbars+stretch", "trunks-tree-bf06", "w3c:hdbscan+stretch", "shared-wind-p2-r1-e2", "hw:stubs"],
+  "collection|1.25|n25-40": ["w2a:shared-ways+stretch", "shared-p3", "shared-order-shortest", "w2b:weiszfeld-a1", "w3e:crossbars+stretch", "trunks-tree-bf08", "w2a:shared-ways+ambiguity", "w2b:weiszfeld-a0"],
+  "collection|1.25|n41-64": ["hw:lanes", "w3e:crossbars+stretch", "w2a:shared-ways+stretch", "shared-flow-a06-p3"],
+  "collection|1.25|n65-128": ["hw:lanes"],
+  "collection|1.5|n1-12": ["trunks-gilbert-a03", "w3e:areas-keys", "trunks-tree-bf02", "w3f:p-hub-a0.2", "w2b:zipper-a1", "w3a:spiral-a35", "w3f:spectral-c0.3", "w2c:level-links+stretch"],
+  "collection|1.5|n13-24": ["shared-wind-p2-r0.5", "trunks-gilbert-a03", "w3e:crossbars+stretch", "shared-wind-p2-r1-e2", "trunks-tree-bf06", "shared-flow-a06-p3", "shared-wind-p3-r1", "trunks-gilbert-a07"],
+  "collection|1.5|n25-40": ["shared-p3", "hw:lanes", "shared-wind-p2-r1-e2", "hw:crossbars", "shared-flow-a06-p3", "trunks-tree-bf06", "shared-wind-p2-r1", "shared-wind-p2-r2"],
+  "collection|1.5|n41-64": ["shared-flow-a06-p3", "hw:lanes", "shared-p2", "trunks-tree-bf06"],
+  "collection|1.5|n65-128": ["shared-p2", "shared-p3", "shared-flow-a06-p3", "hw:lanes"],
+  "all|1.1|n1-12": ["w2b:zipper-p2", "hw:cubu", "w3d:kdeeb+stretch", "w3c:hough-wide", "w3d:kdeeb-routes", "hw:stubs", "hw:spiral", "w3b:growth-s0.7"],
+  "all|1.1|n13-24": ["w3e:frechet-e0.5", "w3a:diffusion-wide", "w2c:zipper+stretch-b1.1", "w3d:cubu+stretch", "w3a:spiral-a15", "w3d:kdeeb-routes", "hw:diffusion", "hw:mesh"],
+  "all|1.1|n25-40": ["w2c:zipper+stretch-b1.1", "w3a:spiral-a15", "w3d:mesh+stretch", "w3a:diffusion+stretch", "w3a:diffusion-wide", "w2c:road-classes-d0.3", "w3d:kdeeb-routes"],
+  "all|1.1|n41-64": ["hw:diffusion", "w3a:spiral-a15", "w2c:zipper+stretch-b1.1", "w3e:frechet-e0.5"],
+  "all|1.1|n65-128": ["hw:diffusion"],
+  "all|1.25|n1-12": ["w3d:kdeeb-routes", "w3e:mlseb+stretch", "hw:growth", "hw:level-links", "w3b:growth-input", "w3e:confluent+stretch", "w3d:kdeeb-nomask", "w3a:diffusion-g2"],
+  "all|1.25|n13-24": ["w3d:kdeeb-routes", "w3f:p-hub-a0.2", "w3d:kdeeb-nomask", "w3a:spiral-n3", "w3b:growth-input", "w3d:cubu+stretch", "w3a:spiral-a35", "trunks-tree-bf06"],
+  "all|1.25|n25-40": ["w3d:kdeeb-routes", "hw:spiral", "hw:shared-ways-all", "w3a:diffusion-g2", "w3e:frechet+stretch", "hw:cubu"],
+  "all|1.25|n41-64": ["w3e:frechet+stretch", "hw:cubu", "w3a:diffusion-wide", "w2a:shared-ways+stretch", "w3a:spiral-a35"],
+  "all|1.25|n65-128": ["hw:diffusion", "w3a:diffusion-wide", "w3a:diffusion-l3"],
+  "all|1.5|n1-12": ["w3b:growth-s0.3", "w3e:mlseb-a0", "w3e:mlseb-routes", "w3c:edge-paths-k1.5", "w3f:territories-r2", "hw:mlseb", "hw:growth", "w3e:mlseb-parabola"],
+  "all|1.5|n13-24": ["hw:growth", "w3b:growth-input", "hw:mlseb", "w3b:growth-s0.3"],
+  "all|1.5|n25-40": ["hw:growth", "w3b:growth-s0.7", "w3b:growth-s0.3", "w3b:growth-t1.2", "w3b:growth-input"],
+  "all|1.5|n41-64": ["hw:growth", "w3b:growth-s0.3", "w3a:diffusion-g2", "w3b:growth-s0.7", "w3a:diffusion-l3", "w3b:growth-input"],
+  "all|1.5|n65-128": ["hw:growth", "w3b:growth-s0.3", "hw:shared-ways-all", "w3a:diffusion-g2"],
+};

package/src/strategies/builtins.ts

@@ -24,6 +24,26 @@ import { EDGE_PATH_DEFAULTS, edgePathPlan, type EdgePathOptions } from "../highw
 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";
@@ -58,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, DIFFUSION_SCHEMA, EDGE_PATH_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+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">;
@@ -417,6 +438,26 @@ export const highwayStrategies: {
   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>;
@@ -667,6 +708,186 @@ export const highwayStrategies: {
     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),