@mark1russell7/highways 0.9.3 → 0.9.5

package/src/routers/reroute/index.ts

@@ -0,0 +1,164 @@
+import { dist, type Point } 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 sine of 1 degree, as a literal. A literal gives the same bits on each platform, so a decision does not depend on `Math.sin`. */
+const SIN_1 = 0.01745240643728351;
+
+/** The options of the router `reroute` (RULE-044: a corner graph with the prices of the rules, and rounds of rip-up and reroute). */
+export interface RerouteOptions {
+  /** The price of a link in a narrow channel, from 0 to 2. The default is 1. */
+  readonly alpha: number;
+  /** The price of each edge of another key on a link, from 0 to 2. The default is 0.5. */
+  readonly beta: number;
+  /** The discount of a link that an edge of the same key uses, from 0 to 2. The default is 0.5. */
+  readonly gamma: number;
+  /** The price of a turn, in units of `clearance`, from 0 to 2. The default is 0.25. */
+  readonly tau: number;
+  /** The number of rounds of rip-up and reroute, from 1 to 5. The default is 2. */
+  readonly rounds: number;
+  /** The share of the edges that each round rips up: the edges with the largest price over their direct length, from 0.05 to 0.3. The default is 0.15. */
+  readonly q: number;
+  /** A channel narrower than this width gets the price `alpha`, from 4 to 64. The default is 16. */
+  readonly clearance: number;
+}
+
+/** The default options of the router `reroute`. */
+export const REROUTE_DEFAULTS: Readonly<RerouteOptions> = Object.freeze({ alpha: 1, beta: 0.5, gamma: 0.5, tau: 0.25, rounds: 2, q: 0.15, clearance: 16 });
+
+/** The declarations of the options of the router `reroute` (RULE-044). */
+export const REROUTE_SCHEMA: OptionSchema<RerouteOptions> = {
+  alpha: { type: "number", min: 0, max: 2, step: 0.05, marks: [0, 1, 2], default: 1, describe: "The price of a link in a narrow channel." },
+  beta: { type: "number", min: 0, max: 2, step: 0.05, marks: [0, 0.5, 1], default: 0.5, describe: "The price of each edge of another key on a link." },
+  gamma: { type: "number", min: 0, max: 2, step: 0.05, marks: [0, 0.5, 1], default: 0.5, describe: "The discount of a link that an edge of the same key uses." },
+  tau: { type: "number", min: 0, max: 2, step: 0.05, marks: [0, 0.25, 1], default: 0.25, describe: "The price of a turn, in units of the clearance." },
+  rounds: { type: "integer", min: 1, max: 5, step: 1, marks: [1, 2, 3, 5], default: 2, describe: "The number of rounds of rip-up and reroute." },
+  q: { type: "number", min: 0.05, max: 0.3, step: 0.05, marks: [0.05, 0.15, 0.3], default: 0.15, describe: "The share of the edges that each round rips up: the edges with the largest price over their direct length." },
+  clearance: { type: "number", min: 4, max: 64, step: 1, marks: [8, 16, 32], default: 16, describe: "A channel narrower than this width gets the price alpha." },
+};
+
+/** This function gives the number of turns of a way: the points where the direction changes by more than 1 degree. */
+export function turnsOf(seq: readonly Point[]): number {
+  let turns = 0;
+  for (let i = 1; i + 1 < seq.length; i++) {
+    const a = seq[i - 1]!;
+    const b = seq[i]!;
+    const c = seq[i + 1]!;
+    const ux = b.x - a.x;
+    const uy = b.y - a.y;
+    const vx = c.x - b.x;
+    const vy = c.y - b.y;
+    const lu = Math.sqrt(ux * ux + uy * uy);
+    const lv = Math.sqrt(vx * vx + vy * vy);
+    if (lu <= 1e-9 || lv <= 1e-9) continue;
+    if (Math.abs(ux * vy - uy * vx) > SIN_1 * lu * lv || ux * vx + uy * vy < 0) turns++;
+  }
+  return turns;
+}
+
+/** The use of one link of the corner graph: the number of edges of each key on it. */
+type LinkUse = Map<string, number>;
+
+/**
+ * This function rips up and reroutes the ways of `shared` (RULE-044, after the rip-up and reroute of PathFinder, McMurchie 1995).
+ * The price factor of a link is `max(0.05, 1 + alpha × narrow + beta × others - gamma × same)`.
+ * `narrow` is `max(0, 1 - width / clearance)`. `others` counts the edges of the other keys on the link.
+ * `same` is 1 when an edge of the same key uses the link.
+ * The price of a way is the sum of the price factor times the length of each link, plus `tau × clearance` for each turn.
+ * Each round takes the share `q` of the ways with the largest price over their direct length. Each one gets a new search with the prices of the links.
+ * The new way stays only when its price is lower. The search has no state for the turns, so only the comparison reads `tau`.
+ */
+export function rerouteWays(ways: readonly Way[], search: SharedSearch, options: Partial<RerouteOptions> = {}): void {
+  const o = { ...REROUTE_DEFAULTS, ...options };
+  const n = search.corners;
+  const use = new Map<number, LinkUse>();
+  const linksOf = (w: Way): number[] => {
+    const out: number[] = [];
+    for (let i = 1; i < w.ids.length; i++) {
+      const a = w.ids[i - 1]!;
+      const b = w.ids[i]!;
+      if (a < n && b < n) out.push(search.link(a, b));
+    }
+    return out;
+  };
+  const change = (w: Way, by: number): void => {
+    for (const k of linksOf(w)) {
+      let m = use.get(k);
+      if (!m) use.set(k, (m = new Map()));
+      const next = (m.get(w.key) ?? 0) + by;
+      if (next > 0) m.set(w.key, next);
+      else m.delete(w.key);
+    }
+  };
+  const found = ways.filter((w) => w.found && w.ids.length >= 2);
+  for (const w of found) change(w, 1);
+  const factor = (i: number, j: number, key: string): number => {
+    const m = use.get(search.link(i, j));
+    let others = 0;
+    let same = 0;
+    for (const [k, c] of m ?? []) {
+      if (k === key) same = 1;
+      else others += c;
+    }
+    const narrow = o.alpha > 0 ? Math.max(0, 1 - search.width(i, j) / o.clearance) : 0;
+    return Math.max(0.05, 1 + o.alpha * narrow + o.beta * others - o.gamma * same);
+  };
+  const priceOf = (seq: readonly Point[], ids: readonly number[], key: string): number => {
+    let p = 0;
+    for (let i = 1; i < seq.length; i++) {
+      const a = ids[i - 1]!;
+      const b = ids[i]!;
+      const d = dist(seq[i - 1]!, seq[i]!);
+      p += a < n && b < n ? d * factor(a, b, key) : d;
+    }
+    return p + o.tau * o.clearance * turnsOf(seq);
+  };
+  const floor = Math.max(0.05, 1 - o.gamma);
+  const count = (share: number): number => Math.max(1, Math.round(share * found.length));
+  for (let round = 0; round < Math.max(1, Math.floor(o.rounds)); round++) {
+    const ranked = found
+      .map((w) => ({ w, score: priceOf(w.seq, w.ids, w.key) / Math.max(1e-9, dist(w.ps.point, w.pt.point)) }))
+      .sort((a, b) => b.score - a.score || (a.w.edge.id < b.w.edge.id ? -1 : a.w.edge.id > b.w.edge.id ? 1 : 0));
+    let moved = 0;
+    for (const { w } of ranked.slice(0, count(Math.min(0.3, Math.max(0.05, o.q))))) {
+      change(w, -1);
+      const before = priceOf(w.seq, w.ids, w.key);
+      const next = search.find(w, (i, j, d) => d * factor(i, j, w.key), floor);
+      if (next && priceOf(next.seq, next.ids, w.key) < before - 1e-9) {
+        w.seq = next.seq;
+        w.ids = next.ids;
+        moved++;
+      }
+      change(w, 1);
+    }
+    if (moved === 0) break;
+  }
+}
+
+/**
+ * This function makes the router `reroute` (RULE-044). It is the router `shared`, then the rounds of rip-up and reroute of `rerouteWays`.
+ * The runs and the bundles come from the ways after the rounds.
+ */
+export function rerouteRouter(options: Partial<RerouteOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...REROUTE_DEFAULTS, ...options };
+  return sharedRouter({ name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) }, undefined, {
+    refine: (ways, search) => rerouteWays(ways, search, o),
+  });
+}
+
+/**
+ * The router strategy `reroute` (RULE-044), 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 rerouteStrategy: Strategy<"router", RerouteOptions> = defineStrategy({
+  step: "router",
+  name: "reroute",
+  describe: "Rule prices and rip-up (RULE-044). The ways of `shared` with the largest prices of narrow channels, other keys and turns get a new search.",
+  defaults: { ...REROUTE_DEFAULTS },
+  schema: REROUTE_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<RerouteOptions>): Result => rerouteRouter({ ...o, name: "reroute", rule: byCollection }).route(graph),
+});

package/src/routers/shared.ts

@@ -92,6 +92,35 @@ export interface SharedNegotiation {
   readonly laneWidth: number;
 }
 
+/**
+ * The search of the corner graph of one route of `shared`, for the hooks of `SharedHooks`.
+ * An index below `corners` is a corner of the graph. Each end of a way gets an index from `corners`, one for each place.
+ */
+export interface SharedSearch {
+  /** The graph of the route, without the inner edges of a frame. */
+  readonly graph: Graph;
+  /** The number of corners of the corner graph. */
+  readonly corners: number;
+  /** This function gives the key of the link between the indices `i` and `j`, for each order of the two. */
+  link(i: number, j: number): number;
+  /**
+   * This function gives a shortest way of `w` through the corner graph, with its points and their indices, or `undefined`.
+   * The function `cost` can change the cost of the link from corner `i` to corner `j`, of length `d`. It must give at least `floor` × `d`.
+   */
+  find(w: Way, cost?: (i: number, j: number, d: number) => number, floor?: number): { seq: Point[]; ids: number[] } | undefined;
+  /** This function gives the free space across the link from corner `i` to corner `j` (`channelWidth`). The router keeps each width that it finds. */
+  width(i: number, j: number): number;
+}
+
+/**
+ * The hooks of a router that `shared` runs (WILD-023, RULE-021). The router `shared` itself has no hooks.
+ * `order` gives the order of the ways before the first pass. `refine` changes the ways after the passes, before the runs.
+ */
+export interface SharedHooks {
+  readonly order?: (ways: readonly Way[], search: SharedSearch) => Way[];
+  readonly refine?: (ways: readonly Way[], search: SharedSearch) => void;
+}
+
 /** A way of one edge through the corner graph. */
 export interface Way {
   readonly edge: Edge;
@@ -129,7 +158,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, negotiation?: SharedNegotiation): Router {
+export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation, hooks?: SharedHooks): 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));
@@ -177,7 +206,18 @@ export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotia
 
       // The edges of one key go one after the other, by default the longest first, so that the short edges join the long ways.
       const discounted = new Map<string, Map<number, string[]>>();
-      const order = orderWays(all, options.order ?? "span", graph);
+      const search: SharedSearch = {
+        graph,
+        corners: corners.points.length,
+        link,
+        find: (w, cost, floor = 1) => {
+          const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
+          return way && { seq: way, ids: way.map((p, i) => (i === 0 || i === way.length - 1 ? endId(p) : index.get(p)!)) };
+        },
+        width: (i, j) => widthOf(i, j),
+      };
+      const sorted = orderWays(all, options.order ?? "span", graph);
+      const order = hooks?.order ? hooks.order(sorted, search) : sorted;
       // The largest number of edges on one link of each key. The cost share of that number is the floor of the search.
       const top = new Map<string, number>();
       // The width of the channel of each link, for the option `capacity`. Each link gets its width at its first use.
@@ -308,6 +348,7 @@ export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotia
         }
       }
 
+      hooks?.refine?.(order, search);
       // With `merge: snell`, each route that joins or leaves a run moves its merge point along the run to the Snell angle.
       if (options.merge === "snell") {
         const pad = ways.margin / 2;

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,10 @@ 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 { BALANCE_DEFAULTS, balancePlan, type BalanceOptions } from "../highways/balance/index.ts";
+import { MANIFOLD_DEFAULTS, manifoldPlan, type ManifoldOptions } from "../highways/manifolds/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,11 +76,14 @@ 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 { DETAIL_DEFAULTS, detailLevels, type DetailOptions } from "../levels/detail/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 { LEADER_DEFAULTS, leaderEnds, type LeaderOptions } from "../plugs/leaders/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";
@@ -87,11 +94,16 @@ 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 { CURRICULUM_DEFAULTS, curriculum, type CurriculumOptions } from "../whole/curriculum/index.ts";
+import { SLOT_DEFAULTS, slotPlan, type SlotOptions } from "../highways/slots/index.ts";
+import { PREFERENCE_DEFAULTS, preferences, type PreferenceOptions } from "../whole/preferences/index.ts";
+import { FIREFLY_DEFAULTS, fireflies, type FireflyOptions } from "../whole/fireflies/index.ts";
+import { TRACING_DEFAULTS, tracing, type TracingOptions } from "../whole/tracing/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, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_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, BALANCE_SCHEMA, MANIFOLD_SCHEMA, LEADER_SCHEMA, DETAIL_SCHEMA, CURRICULUM_SCHEMA, SLOT_SCHEMA, PREFERENCE_SCHEMA, FIREFLY_SCHEMA, TRACING_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">;
@@ -475,6 +487,11 @@ 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 balance: Strategy<"highway", BalanceOptions>;
+  readonly manifolds: Strategy<"highway", ManifoldOptions>;
+  readonly slots: Strategy<"highway", SlotOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -950,6 +967,51 @@ 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),
+  }),
+  balance: defineStrategy({
+    step: "highway",
+    name: "balance",
+    describe: "Stretch balance in a bundle (EDA-017). A price for each edge grows while its stretch is above the target, and the price moves its exit forward.",
+    defaults: { ...BALANCE_DEFAULTS } as BalanceOptions,
+    schema: BALANCE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<BalanceOptions>) => balancePlan(input, o),
+  }),
+  manifolds: defineStrategy({
+    step: "highway",
+    name: "manifolds",
+    describe: "Manifolds for a fan to a row (WILD-036). A straight header in the gap before the row, with taps at right angles and one feed from the node.",
+    defaults: { ...MANIFOLD_DEFAULTS } as ManifoldOptions,
+    schema: MANIFOLD_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ManifoldOptions>) => manifoldPlan(input, o),
+  }),
+  slots: defineStrategy({
+    step: "highway",
+    name: "slots",
+    describe: "A pull toward the lane slots of the trunks (RULE-047). An edge near a trunk joins it on a new lane when the pull is larger than its detour.",
+    defaults: { ...SLOT_DEFAULTS } as SlotOptions,
+    schema: SLOT_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SlotOptions>) => slotPlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),
@@ -963,6 +1025,7 @@ export const plugStrategies: {
   readonly side: Strategy<"plugs", SidePlugOptions>;
   readonly justify: Strategy<"plugs", JustifyOptions>;
   readonly spread: Strategy<"plugs", SpreadOptions>;
+  readonly leaders: Strategy<"plugs", LeaderOptions>;
 } = Object.freeze({
   facing: defineStrategy({
     step: "plugs",
@@ -996,11 +1059,21 @@ export const plugStrategies: {
     schema: SPREAD_SCHEMA,
     run: (input, o) => spreadEnds(input, o),
   }),
+  leaders: defineStrategy<"plugs", LeaderOptions>({
+    step: "plugs",
+    name: "leaders",
+    describe: "Boundary leaders as plug stubs (EDA-041). The plugs of each wall take the order of po-leaders with no crossing, and keep a least gap.",
+    defaults: { ...LEADER_DEFAULTS },
+    schema: LEADER_SCHEMA,
+    run: (input, o) => leaderEnds(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>;
+  readonly detail: Strategy<"levels", DetailOptions>;
 } = Object.freeze({
   depths: defineStrategy<"levels", DepthLevelOptions>({
     step: "levels",
@@ -1010,14 +1083,57 @@ 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),
+  }),
+  detail: defineStrategy<"levels", DetailOptions>({
+    step: "levels",
+    name: "detail",
+    describe: "The level of detail of the bundles (WILD-016 with EDA-038). Legs of level links closer than a few pixels at the scale of their level become one stroke.",
+    defaults: { ...DETAIL_DEFAULTS },
+    schema: DETAIL_SCHEMA,
+    run: (input, o) => detailLevels(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 pool of routes of the whole strategy `curriculum` (RULE-048), in order: the routers of the base of the screen. The first one gives the first answer.
+ * The option `settings` takes the first ones.
+ */
+export const CURRICULUM_POOL: readonly PortfolioSetting[] = Object.freeze(
+  (["corners", "shared", "trunks"] as const).map((name) => Object.freeze({ name, pipeline: { router: routerStrategies[name] as Strategy<"router"> } })),
+);
+
 /**
  * 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>;
+  readonly curriculum: Strategy<"whole", CurriculumOptions>;
+  readonly preferences: Strategy<"whole", PreferenceOptions>;
+  readonly fireflies: Strategy<"whole", FireflyOptions>;
+  readonly tracing: Strategy<"whole", TracingOptions>;
 } = Object.freeze({
   pipeline: defineStrategy<"whole", PipelineOptions>({
     step: "whole",
@@ -1027,6 +1143,46 @@ 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,
+  }),
+  curriculum: defineStrategy<"whole", CurriculumOptions>({
+    step: "whole",
+    name: "curriculum",
+    describe: "A curriculum of rules (RULE-048). Each stage adds one rule, and each edge takes the route of a pool that improves it with no loss on the earlier rules.",
+    defaults: { ...CURRICULUM_DEFAULTS },
+    schema: CURRICULUM_SCHEMA,
+    run: (graph, o) => curriculum(graph, CURRICULUM_POOL, o),
+  }),
+  preferences: defineStrategy<"whole", PreferenceOptions>({
+    step: "whole",
+    name: "preferences",
+    describe: "Rule weights from preferences (RULE-038). A fit to made-up pairs gives the weights, and each edge takes the route of a pool with the least weighted cost.",
+    defaults: { ...PREFERENCE_DEFAULTS },
+    schema: PREFERENCE_SCHEMA,
+    run: (graph, o) => preferences(graph, CURRICULUM_POOL, o),
+  }),
+  fireflies: defineStrategy<"whole", FireflyOptions>({
+    step: "whole",
+    name: "fireflies",
+    describe: "Firefly and bee searches (NAT-047). A seeded swarm searches the discount and the margin of `shared` on the board, within a budget of settings.",
+    defaults: { ...FIREFLY_DEFAULTS },
+    schema: FIREFLY_SCHEMA,
+    run: (graph, o) => fireflies(graph, routerStrategies.shared as Strategy<"router">, o).output,
+  }),
+  tracing: defineStrategy<"whole", TracingOptions>({
+    step: "whole",
+    name: "tracing",
+    describe: "The least tracing load (WILD-057). The pipeline tries a fixed list of settings, and the least load of crossings, merges and bends on one edge wins.",
+    defaults: { ...TRACING_DEFAULTS },
+    schema: TRACING_SCHEMA,
+    run: (graph, o) => tracing(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])`. */