@mark1russell7/highways 0.9.2 → 0.9.4

package/src/routers/tight/index.ts

@@ -0,0 +1,122 @@
+import { byText } from "../../compare.ts";
+import { dist, polylineLength } from "../../geom.ts";
+import type { Graph, GroupRule, Result, Router } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import { sharedRouter, type SharedSearch, type Way } from "../shared.ts";
+import { byCollection } from "../trunks.ts";
+
+/** The edges that go first: the edges with few good ways (`tight`), or the edges with many good ways (`loose`). */
+export type TightFirst = "tight" | "loose";
+
+/** The values of `TightFirst`. */
+export const TIGHT_FIRSTS: readonly TightFirst[] = Object.freeze(["tight", "loose"]);
+
+/** The order of two edges with the same slack: by the edge id, or the longer edge first. */
+export type TightTies = "id" | "length";
+
+/** The values of `TightTies`. */
+export const TIGHT_TIES: readonly TightTies[] = Object.freeze(["id", "length"]);
+
+/** The options of the router `tight` (WILD-023: tight edges first, after list scheduling by slack). */
+export interface TightOptions {
+  /** The cost factor of the links of the first way in the search of the second way, from 2 to 10. The default is 3. */
+  readonly penalty: number;
+  /**
+   * The edges that go first. With `tight`, the default, an edge whose second way costs much more than its first way goes first.
+   * With `loose`, the order turns around: the formula of the record, with the rising slack.
+   */
+  readonly first: TightFirst;
+  /** The order of two edges with the same slack. The default is `length`: the longer edge first, as in `shared`. */
+  readonly ties: TightTies;
+}
+
+/** The default options of the router `tight`. */
+export const TIGHT_DEFAULTS: Readonly<TightOptions> = Object.freeze({ penalty: 3, first: "tight", ties: "length" });
+
+/** The declarations of the options of the router `tight` (WILD-023). */
+export const TIGHT_SCHEMA: OptionSchema<TightOptions> = {
+  penalty: { type: "number", min: 2, max: 10, step: 0.5, marks: [2, 3, 5], default: 3, describe: "The cost factor of the links of the first way in the search of the second way." },
+  first: { type: "enum", values: ["tight", "loose"], default: "tight", describe: "The edges that go first: the edges with few good ways, or the edges with many good ways." },
+  ties: { type: "enum", values: ["id", "length"], default: "length", describe: "The order of two edges with the same slack: by the edge id, or the longer edge first." },
+};
+
+/**
+ * This function gives the slack of each way (WILD-023): `L2 / L1 - 1`. `L1` is the length of the shortest way.
+ * `L2` is the cost of the shortest way when each link of the first way costs `penalty` times its length.
+ * A way with no second way has the slack `penalty - 1`. A way with a second way of near-equal length has a slack near 0.
+ */
+export function waySlacks(ways: readonly Way[], search: SharedSearch, penalty: number): Map<Way, number> {
+  const out = new Map<Way, number>();
+  const n = search.corners;
+  for (const w of ways) {
+    const first = search.find(w);
+    if (!first) {
+      out.set(w, 0);
+      continue;
+    }
+    const l1 = polylineLength(first.seq);
+    const own = new Set<number>();
+    for (let i = 1; i < first.ids.length; i++) {
+      const a = first.ids[i - 1]!;
+      const b = first.ids[i]!;
+      if (a < n && b < n) own.add(search.link(a, b));
+    }
+    const cost = (i: number, j: number, d: number): number => (own.has(search.link(i, j)) ? d * penalty : d);
+    const second = search.find(w, cost, 1);
+    let l2 = l1;
+    if (second) {
+      l2 = 0;
+      for (let i = 1; i < second.ids.length; i++) {
+        const a = second.ids[i - 1]!;
+        const b = second.ids[i]!;
+        const d = dist(second.seq[i - 1]!, second.seq[i]!);
+        l2 += a < n && b < n ? cost(a, b, d) : d;
+      }
+    }
+    out.set(w, l1 > 1e-9 ? l2 / l1 - 1 : 0);
+  }
+  return out;
+}
+
+/**
+ * This function makes the router `tight` (WILD-023). It is the router `shared` with another order of the edges of each key.
+ * With `first: tight`, the edges with the largest slack value go first: their second way costs much more, so they have few good ways.
+ * The edges with many ways of near-equal cost go last. The keys keep the order of `shared`.
+ */
+export function tightRouter(options: Partial<TightOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...TIGHT_DEFAULTS, ...options };
+  const penalty = Math.min(10, Math.max(1, o.penalty));
+  const sign = o.first === "loose" ? 1 : -1;
+  return sharedRouter(
+    { name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) },
+    undefined,
+    {
+      order: (ways, search) => {
+        const slack = waySlacks(ways, search, penalty);
+        const span = (w: Way): number => dist(w.ps.point, w.pt.point);
+        return [...ways].sort(
+          (p, q) =>
+            byText(p.key, q.key) ||
+            sign * (slack.get(p)! - slack.get(q)!) ||
+            (o.ties === "length" ? span(q) - span(p) : 0) ||
+            byText(p.edge.id, q.edge.id),
+        );
+      },
+    },
+  );
+}
+
+/**
+ * The router strategy `tight` (WILD-023), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export const tightStrategy: Strategy<"router", TightOptions> = defineStrategy({
+  step: "router",
+  name: "tight",
+  describe: "Tight edges first (WILD-023). The router `shared` routes first the edges whose second way costs much more than their first way.",
+  defaults: { ...TIGHT_DEFAULTS },
+  schema: TIGHT_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<TightOptions>): Result => tightRouter({ ...o, name: "tight", rule: byCollection }).route(graph),
+});

package/src/strategies/builtins.ts

@@ -46,6 +46,8 @@ import { P_HUB_DEFAULTS, pHubPlan, type PHubOptions } from "../highways/p-hub/in
 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 { KNEE_DEFAULTS, kneePlan, type KneeOptions } from "../highways/knee/index.ts";
+import { BRONCHIAL_DEFAULTS, bronchialPlan, type BronchialOptions } from "../highways/bronchial/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";
@@ -72,8 +74,12 @@ import { WEISZFELD_DEFAULTS, weiszfeldPlan, type WeiszfeldOptions } from "../hig
 import { WSPD_DEFAULTS, wspdPlan, type WspdOptions } from "../highways/wspd/index.ts";
 import { ZIPPER_DEFAULTS, zipperPlan, type ZipperOptions } from "../highways/zipper/index.ts";
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
+import { VENATION_DEFAULTS, venationLevels, type VenationOptions } from "../levels/venation/index.ts";
 import type { Graph, Result, Router } from "../model.ts";
 import { facingEnds } from "../plugs/facing/index.ts";
+import { justifyEnds, type JustifyOptions } from "../plugs/justify.ts";
+import { sideEnds, type SidePlugOptions } from "../plugs/side.ts";
+import { SPREAD_DEFAULTS, spreadEnds, type SpreadOptions } from "../plugs/spread/index.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";
@@ -84,11 +90,11 @@ import { straightRouter } from "../routers/straight.ts";
 import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunks.ts";
 import { buildSections, SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
 import { runPipeline, type PipelineOptions } from "../whole/pipeline/index.ts";
+import { BOARD_PORTFOLIO_DEFAULTS, boardPortfolio, type BoardPortfolioOptions, type PortfolioSetting } from "../whole/portfolio/index.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 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, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_SCHEMA } from "./schemas.ts";
+import { DEPTHS_SCHEMA, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_SCHEMA, 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, KNEE_SCHEMA, BRONCHIAL_SCHEMA, BOARD_PORTFOLIO_SCHEMA, VENATION_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">;
@@ -472,6 +478,8 @@ export const highwayStrategies: {
   readonly streets: Strategy<"highway", StreetOptions>;
   readonly search: Strategy<"highway", SearchOptions>;
   readonly interchanges: Strategy<"highway", InterchangeOptions>;
+  readonly knee: Strategy<"highway", KneeOptions>;
+  readonly bronchial: Strategy<"highway", BronchialOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -947,6 +955,24 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<InterchangeOptions>) => interchangePlan(input, o),
   }),
+  knee: defineStrategy({
+    step: "highway",
+    name: "knee",
+    describe: "The knee of the plant front (NAT-018). A sweep of the balancing factor of NAT-017 gives trees, and the tree at the knee of ink against path length wins.",
+    defaults: { ...KNEE_DEFAULTS } as KneeOptions,
+    schema: KNEE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<KneeOptions>) => kneePlan(input, o),
+  }),
+  bronchial: defineStrategy({
+    step: "highway",
+    name: "bronchial",
+    describe: "Bronchial splits that fill the space (NAT-019). The tree grows toward the center of its targets, then splits the targets in two halves, again and again.",
+    defaults: { ...BRONCHIAL_DEFAULTS } as BronchialOptions,
+    schema: BRONCHIAL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<BronchialOptions>) => bronchialPlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -957,6 +983,9 @@ export const highwayStrategies: {
 /** The built-in plug rules: the strategies of the step `plugs`. The router `corners` routes between their plugs with its option `plug`. */
 export const plugStrategies: {
   readonly facing: Strategy<"plugs", object>;
+  readonly side: Strategy<"plugs", SidePlugOptions>;
+  readonly justify: Strategy<"plugs", JustifyOptions>;
+  readonly spread: Strategy<"plugs", SpreadOptions>;
 } = Object.freeze({
   facing: defineStrategy({
     step: "plugs",
@@ -966,11 +995,36 @@ export const plugStrategies: {
     schema: {},
     run: (input) => facingEnds(input),
   }),
+  side: defineStrategy<"plugs", SidePlugOptions>({
+    step: "plugs",
+    name: "side",
+    describe: "WILD-001. The search of a route starts from the whole free side, and the plug goes where the way leaves the side. It is `corners` with `plugs: side`.",
+    defaults: { bend: 1, inset: 6, most: 16 },
+    schema: SIDE_PLUG_SCHEMA,
+    run: (input, o) => sideEnds(input, o),
+  }),
+  justify: defineStrategy<"plugs", JustifyOptions>({
+    step: "plugs",
+    name: "justify",
+    describe: "WILD-002. The plugs of `facing`, then the free plugs of each side keep their order and a minimum gap. They move the least distance.",
+    defaults: { plugGap: 8 },
+    schema: JUSTIFY_SCHEMA,
+    run: (input, o) => justifyEnds(input, o),
+  }),
+  spread: defineStrategy<"plugs", SpreadOptions>({
+    step: "plugs",
+    name: "spread",
+    describe: "PLUG-SPREAD. The free plugs of each wall share its room with a minimum gap, in the order of their far ends. On a short wall the gap shrinks, and no plug drops.",
+    defaults: { ...SPREAD_DEFAULTS },
+    schema: SPREAD_SCHEMA,
+    run: (input, o) => spreadEnds(input, o),
+  }),
 });
 
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
 export const levelStrategies: {
   readonly depths: Strategy<"levels", DepthLevelOptions>;
+  readonly venation: Strategy<"levels", VenationOptions>;
 } = Object.freeze({
   depths: defineStrategy<"levels", DepthLevelOptions>({
     step: "levels",
@@ -980,14 +1034,37 @@ export const levelStrategies: {
     schema: DEPTHS_SCHEMA,
     run: (input, o) => depthLevels(input, o),
   }),
+  venation: defineStrategy<"levels", VenationOptions>({
+    step: "levels",
+    name: "venation",
+    describe: "A closed venation backbone (NAT-016). The links of each level with groups take their ways along the relative neighbourhood graph of the items.",
+    defaults: { ...VENATION_DEFAULTS },
+    schema: VENATION_SCHEMA,
+    run: (input, o) => venationLevels(input, o),
+  }),
 });
 
+/**
+ * The fixed list of settings of the whole strategy `board-portfolio` (WILD-045), in order. The option `settings` takes the first ones.
+ * The list holds routers and highway strategies with their defaults. It comes from the catalog of the strategies, not from a fit to the screen.
+ */
+export const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[] = Object.freeze(
+  [
+    ...(["shared", "corners", "trunks", "sections", "sections-tree", "corners-smooth"] as const).map((name) => ({ name, pipeline: { router: routerStrategies[name] as Strategy<"router"> } })),
+    ...(["corridors", "shared-ways", "road-classes", "steiner", "knee", "bronchial"] as const).map((name) => ({
+      name: `highway:${name}`,
+      pipeline: { router: routerStrategies.corners as Strategy<"router">, highway: highwayStrategies[name] as Strategy<"highway"> },
+    })),
+  ].map((s) => Object.freeze(s)),
+);
+
 /**
  * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
  * Without options, it routes the graph with the router `corners`.
  */
 export const wholeStrategies: {
   readonly pipeline: Strategy<"whole", PipelineOptions>;
+  readonly "board-portfolio": Strategy<"whole", BoardPortfolioOptions>;
 } = Object.freeze({
   pipeline: defineStrategy<"whole", PipelineOptions>({
     step: "whole",
@@ -997,6 +1074,14 @@ export const wholeStrategies: {
     schema: PIPELINE_SCHEMA,
     run: (graph, o) => runPipeline(graph, o),
   }),
+  "board-portfolio": defineStrategy<"whole", BoardPortfolioOptions>({
+    step: "whole",
+    name: "board-portfolio",
+    describe: "A portfolio for each board (WILD-045). The pipeline tries a fixed list of settings, and the least weighted rank of crossings, detour and ink wins.",
+    defaults: { ...BOARD_PORTFOLIO_DEFAULTS },
+    schema: BOARD_PORTFOLIO_SCHEMA,
+    run: (graph, o) => boardPortfolio(graph, BOARD_PORTFOLIO_SETTINGS, o).output,
+  }),
 });
 
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */

package/src/strategies/schemas.ts

@@ -6,6 +6,9 @@ import type { MlsebOptions } from "../highways/mlseb/index.ts";
 import type { PowerOptions } from "../highways/power/index.ts";
 import type { SbebOptions } from "../highways/sbeb/index.ts";
 import type { CutOptions } from "../groups/cut/index.ts";
+import type { JustifyOptions } from "../plugs/justify.ts";
+import type { SidePlugOptions } from "../plugs/side.ts";
+import type { SpreadOptions } from "../plugs/spread/index.ts";
 import type { KdOptions } from "../groups/kd/index.ts";
 import type { KeyOptions } from "../groups/keys/index.ts";
 import type { HighwayBase } from "../highways/base.ts";
@@ -41,6 +44,8 @@ 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 { KneeOptions } from "../highways/knee/index.ts";
+import type { BronchialOptions } from "../highways/bronchial/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";
@@ -56,6 +61,8 @@ import type { WspdOptions } from "../highways/wspd/index.ts";
 import type { ZipperOptions } from "../highways/zipper/index.ts";
 import type { LaneStretchOptions } from "../lane-orders/stretch/index.ts";
 import type { DepthLevelOptions } from "../levels/depths/index.ts";
+import type { VenationOptions } from "../levels/venation/index.ts";
+import type { BoardPortfolioOptions } from "../whole/portfolio/index.ts";
 import type { CornersOptions } from "../routers/corners.ts";
 import type { SectionsOptions } from "../routers/sections.ts";
 import type { SharedOptions } from "../routers/shared.ts";
@@ -138,6 +145,20 @@ export const CORNERS_SCHEMA: OptionSchema<RouterPreset<CornersOptions>> = {
     step: 1,
     describe: "The distance from the walls of a frame to the bounds of its inner routes. Without a value, the inset is the margin.",
   },
+  inner: {
+    type: "enum",
+    values: ["corners", "gutter"],
+    default: "corners",
+    describe: "The mode of the inner routes. With `gutter`, each inner route is orthogonal in the gaps between the nodes of the frame, with a lane in each shared gap.",
+  },
+  bendCost: {
+    type: "number",
+    min: 0,
+    max: 100,
+    step: 1,
+    default: 16,
+    describe: "The cost of one bend of an inner route of the mode `gutter`, in units of length. A larger cost gives fewer bends.",
+  },
 };
 
 /** The declarations of the options of the router `trunks`. */
@@ -928,6 +949,25 @@ export const DEPTHS_SCHEMA: OptionSchema<DepthLevelOptions> = {
   levels: SECTIONS_SCHEMA.levels,
 };
 
+/** The declarations of the options of the plug strategy `side` (WILD-001). The defaults are the plugs of `corners` with `plugs: "side"`. */
+export const SIDE_PLUG_SCHEMA: OptionSchema<SidePlugOptions> = {
+  bend: { type: "number", min: 0, max: 4, step: 0.25, default: 1, describe: "The cost of a slant first leg: its length grows by this value times its angle to the normal." },
+  inset: { type: "number", min: 0, max: 12, step: 1, default: 6, describe: "A plug stays this far from the corners of its side." },
+  most: { type: "integer", min: 1, max: 64, step: 1, default: 16, describe: "The largest number of places that the search tries on each side." },
+};
+
+/** The declarations of the options of the plug strategy `justify` (WILD-002). */
+export const JUSTIFY_SCHEMA: OptionSchema<JustifyOptions> = {
+  plugGap: { type: "number", min: 0, max: 24, step: 1, default: 8, describe: "The free plugs of a side keep their order and at least this gap. 0 keeps each plug where it faces." },
+};
+
+/** The declarations of the options of the plug strategy `spread` (PLUG-SPREAD). */
+export const SPREAD_SCHEMA: OptionSchema<SpreadOptions> = {
+  plugGap: { type: "number", min: 0, max: 24, step: 1, default: 8, describe: "The least gap between two plugs of one wall. On a short wall, the gap shrinks evenly." },
+  inset: { type: "number", min: 0, max: 12, step: 1, default: 6, describe: "A plug stays this far from the corners of its wall." },
+  rounds: { type: "integer", min: 0, max: 8, step: 1, default: 2, describe: "The passes that sort each wall again by the new places of the far ends." },
+};
+
 /** The declarations of the options of the whole strategy `pipeline`. */
 export const PIPELINE_SCHEMA: OptionSchema<PipelineOptions> = {
   router: { type: "strategy", step: "router", describe: "The router. A highway plan takes its place." },
@@ -994,3 +1034,39 @@ export const INTERCHANGE_SCHEMA: OptionSchema<InterchangeOptions> = {
   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." },
 };
+
+/** The declarations of the options of the highway strategy `knee` (NAT-018). */
+export const KNEE_SCHEMA: OptionSchema<KneeOptions> = {
+  sweep: { type: "integer", min: 5, max: 21, step: 1, marks: [5, 11, 21], default: 11, describe: "The number of points of the sweep of the balancing factor." },
+  rule: { type: "enum", values: ["chord", "weights"], default: "chord", describe: "The rule that picks one tree: the knee of the chord, or the least weighted sum." },
+  ink: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.25, 0.5, 0.75], default: 0.5, describe: "The weight of the ink in the rule `weights`. The rest of the weight goes to the path length." },
+  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 `bronchial` (NAT-019). */
+export const BRONCHIAL_SCHEMA: OptionSchema<BronchialOptions> = {
+  split: { type: "enum", values: ["count", "weight", "gap"], default: "count", describe: "The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap." },
+  share: { type: "number", min: 0.3, max: 0.7, step: 0.05, marks: [0.3, 0.5, 0.7], default: 0.5, describe: "The share of the distance to the center of the targets that a branch grows." },
+  smallest: { type: "integer", min: 1, max: 3, step: 1, default: 1, describe: "A set with this number of targets or fewer stops the splits." },
+  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 level strategy `venation` (NAT-016): the options of `depths`, and the options of the backbone. */
+export const VENATION_SCHEMA: OptionSchema<VenationOptions> = {
+  ...DEPTHS_SCHEMA,
+  backbone: { type: "enum", values: ["rng", "gabriel"], default: "rng", describe: "The graph of the backbone: the relative neighbourhood graph, or the Gabriel graph." },
+  discount: { type: "number", min: 0, max: 0.8, step: 0.05, marks: [0, 0.4, 0.8], default: 0.4, describe: "The share of the cost of a backbone link that a later level link saves when an earlier link uses it." },
+  detour: { type: "number", min: 1, max: 3, step: 0.05, marks: [1.25, 1.5, 2], default: 1.5, describe: "A level link takes its way on the backbone only when that way is this many times its direct link or less." },
+  maxItems: { type: "integer", min: 10, max: 2000, step: 10, marks: [100, 400, 1000], default: 400, describe: "A level with more items than this number keeps the links of `depths`." },
+};
+
+/** The declarations of the options of the whole strategy `board-portfolio` (WILD-045). */
+export const BOARD_PORTFOLIO_SCHEMA: OptionSchema<BoardPortfolioOptions> = {
+  settings: { type: "integer", min: 3, max: 12, step: 1, marks: [3, 4, 8, 12], default: 4, describe: "The number of settings that the portfolio tries, from the start of its list." },
+  crossings: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1, 2], default: 1, describe: "The weight of the crossings (R1) in the score." },
+  detour: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1, 2], default: 1, describe: "The weight of the median detour (R5) in the score." },
+  ink: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1, 2], default: 1, describe: "The weight of the ink saved (B1) in the score." },
+  budget: { type: "number", min: 0, max: 10, step: 0.1, marks: [0, 1, 10], default: 0, describe: "The time budget in seconds. The value 0 sets no budget." },
+};

package/src/whole/portfolio/index.ts

@@ -0,0 +1,108 @@
+import { inkSaved } from "../../bench/measures/bundles.ts";
+import { detourSpread } from "../../bench/measures/routes.ts";
+import { checkProperties } from "../../bench/properties.ts";
+import { measureQuality } from "../../bench/quality.ts";
+import type { Graph, Result } from "../../model.ts";
+import type { WholeOutput } from "../../strategies/model.ts";
+import { runPipeline, type PipelineOptions } from "../pipeline/index.ts";
+
+/** The clock in milliseconds. */
+const clock = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** One setting of the portfolio: a name and the options of the pipeline. */
+export interface PortfolioSetting {
+  readonly name: string;
+  readonly pipeline: PipelineOptions;
+}
+
+/** The options of the whole strategy `board-portfolio` (WILD-045). */
+export interface BoardPortfolioOptions {
+  /** The number of settings that the portfolio tries, from the start of its list, from 3 to 12. The default is 4. */
+  readonly settings: number;
+  /** The weight of the crossings (R1) in the score, from 0 to 4. The default is 1. */
+  readonly crossings: number;
+  /** The weight of the median detour (R5) in the score, from 0 to 4. The default is 1. */
+  readonly detour: number;
+  /** The weight of the ink saved (B1) in the score, from 0 to 4. The default is 1. */
+  readonly ink: number;
+  /**
+   * The time budget in seconds, from 0 to 10. After the budget, no new setting starts. The first setting always runs.
+   * The value 0, the default, sets no budget, so the output does not depend on the speed of the machine.
+   */
+  readonly budget: number;
+}
+
+/** The default options of the strategy `board-portfolio`. */
+export const BOARD_PORTFOLIO_DEFAULTS: Readonly<BoardPortfolioOptions> = Object.freeze({ settings: 4, crossings: 1, detour: 1, ink: 1, budget: 0 });
+
+/** The measures of one setting on the board, and its output. */
+export interface PortfolioEntry {
+  readonly name: string;
+  readonly output: WholeOutput;
+  readonly crossings: number;
+  readonly detour: number;
+  readonly ink: number;
+}
+
+/** The result of `boardPortfolio`: the output and the name of the pick. It also holds the measures of each setting with no break of a hard rule. */
+export interface BoardPortfolioRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly PortfolioEntry[];
+}
+
+/** This function gives the rank of each value from 0 (the best) to 1 (the worst). Equal values get the mean of their ranks. One value gets 0. */
+export function rankShares(values: readonly number[], lowerIsBetter: boolean): number[] {
+  const n = values.length;
+  if (n < 2) return values.map(() => 0);
+  const order = values.map((_, i) => i).sort((a, b) => (lowerIsBetter ? values[a]! - values[b]! : values[b]! - values[a]!));
+  const rank = new Array<number>(n).fill(0);
+  for (let i = 0; i < n; ) {
+    let j = i;
+    while (j + 1 < n && Math.abs(values[order[j + 1]!]! - values[order[i]!]!) <= 1e-9) j++;
+    for (let k = i; k <= j; k++) rank[order[k]!] = (i + j) / 2 / (n - 1);
+    i = j + 1;
+  }
+  return rank;
+}
+
+/**
+ * This function runs the portfolio for one board (WILD-045, after Rice, 1976). It reads only the board and the outputs of its own settings.
+ * A setting whose router or highway strategy has a node limit below the size of the board does not run.
+ * A setting with a break of a hard rule does not count. The score of a setting is `Σ w_i × the rank share of measure_i` over the settings.
+ * The measures are the crossings (R1), the median detour (R5) and the ink saved (B1). The least score wins, and a tie goes to the earlier setting.
+ */
+export function boardPortfolio(graph: Graph, list: readonly PortfolioSetting[], o: Readonly<BoardPortfolioOptions>, now: () => number = clock): BoardPortfolioRun {
+  const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+  const t0 = now();
+  const entries: PortfolioEntry[] = [];
+  let fallback: { name: string; output: WholeOutput } | undefined;
+  for (const s of list.slice(0, count)) {
+    if (o.budget > 0 && fallback !== undefined && now() - t0 > o.budget * 1000) break;
+    const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+    if (limit !== undefined && graph.nodes.length > limit) continue;
+    const output = runPipeline(graph, s.pipeline);
+    fallback ??= { name: s.name, output };
+    if (checkProperties(output.graph, output.result, 1).length > 0) continue;
+    entries.push({ name: s.name, output, ...measuresOf(output.graph, output.result) });
+  }
+  if (entries.length === 0) {
+    const first = fallback ?? { name: list[0]!.name, output: runPipeline(graph, list[0]!.pipeline) };
+    return { output: first.output, pick: first.name, entries };
+  }
+  const r1 = rankShares(entries.map((e) => e.crossings), true);
+  const r5 = rankShares(entries.map((e) => e.detour), true);
+  const b1 = rankShares(entries.map((e) => e.ink), false);
+  let best = 0;
+  let score = Infinity;
+  entries.forEach((_, i) => {
+    const s = o.crossings * r1[i]! + o.detour * r5[i]! + o.ink * b1[i]!;
+    if (s < score - 1e-9) [best, score] = [i, s];
+  });
+  return { output: entries[best]!.output, pick: entries[best]!.name, entries };
+}
+
+/** This function gives the three measures of the score of one output: the crossings, the median detour and the ink saved. */
+function measuresOf(graph: Graph, result: Result): { crossings: number; detour: number; ink: number } {
+  return { crossings: measureQuality(graph, result).crossings, detour: detourSpread(result.routes).median, ink: inkSaved(result.routes) };
+}