@mark1russell7/highways 0.9.4 → 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

@@ -108,6 +108,8 @@ export interface SharedSearch {
    * 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;
 }
 
 /**
@@ -212,6 +214,7 @@ export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotia
           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;

package/src/strategies/builtins.ts

@@ -47,6 +47,8 @@ import { SCALE_SPACE_DEFAULTS, scaleSpacePlan, type ScaleSpaceOptions } from "..
 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";
@@ -75,11 +77,13 @@ import { WSPD_DEFAULTS, wspdPlan, type WspdOptions } from "../highways/wspd/inde
 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";
@@ -91,10 +95,15 @@ import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunk
 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, 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";
+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">;
@@ -480,6 +489,9 @@ export const highwayStrategies: {
   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>;
@@ -973,6 +985,33 @@ export const highwayStrategies: {
     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),
@@ -986,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",
@@ -1019,12 +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",
@@ -1042,6 +1091,14 @@ export const levelStrategies: {
     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),
+  }),
 });
 
 /**
@@ -1058,6 +1115,14 @@ export const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[] = Object.free
   ].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`.
@@ -1065,6 +1130,10 @@ export const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[] = Object.free
 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",
@@ -1082,6 +1151,38 @@ export const wholeStrategies: {
     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])`. */

package/src/strategies/schemas.ts

@@ -9,6 +9,15 @@ 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 { LeaderOptions } from "../plugs/leaders/index.ts";
+import type { BalanceOptions } from "../highways/balance/index.ts";
+import type { ManifoldOptions } from "../highways/manifolds/index.ts";
+import type { DetailOptions } from "../levels/detail/index.ts";
+import type { CurriculumOptions } from "../whole/curriculum/index.ts";
+import type { SlotOptions } from "../highways/slots/index.ts";
+import type { PreferenceOptions } from "../whole/preferences/index.ts";
+import type { FireflyOptions } from "../whole/fireflies/index.ts";
+import type { TracingOptions } from "../whole/tracing/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";
@@ -1070,3 +1079,83 @@ export const BOARD_PORTFOLIO_SCHEMA: OptionSchema<BoardPortfolioOptions> = {
   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." },
 };
+
+/** The declarations of the options of the highway strategy `balance` (EDA-017). */
+export const BALANCE_SCHEMA: OptionSchema<BalanceOptions> = {
+  tau: { type: "number", min: 1.1, max: 2, step: 0.05, marks: [1.1, 1.2, 1.5, 2], default: 1.2, describe: "The target of the stretch of an edge: its route on the plan over its route alone." },
+  iterations: { type: "integer", min: 5, max: 30, step: 1, marks: [5, 10, 30], default: 5, describe: "The number of updates of the prices." },
+  end: { type: "enum", values: ["exit", "entry", "both"], default: "exit", describe: "The end of a ride that the price moves: the exit, the entry, or both by half." },
+  from: { ...HIGHWAY_BASE, default: "shared-ways" },
+};
+
+/** The declarations of the options of the highway strategy `manifolds` (WILD-036). */
+export const MANIFOLD_SCHEMA: OptionSchema<ManifoldOptions> = {
+  kMin: { type: "integer", min: 3, max: 8, step: 1, marks: [3, 4, 6, 8], default: 3, describe: "A manifold has this number of taps or more." },
+  band: { type: "number", min: 0.5, max: 2, step: 0.25, marks: [0.5, 1, 2], default: 1, describe: "The nodes of one row have centers in a band of this many median box heights." },
+  side: { type: "enum", values: ["near", "far"], default: "near", describe: "The place of the header in the gap before the row: near the row, or near the feed node." },
+  detour: { type: "number", min: 1, max: 3, step: 0.05, marks: [1.25, 1.5, 2], default: 1.5, describe: "A tap stays on the manifold only when its way is this many times the direct line or less." },
+  from: { ...HIGHWAY_BASE, default: "shared-ways" },
+};
+
+/** The declarations of the options of the highway strategy `slots` (RULE-047). */
+export const SLOT_SCHEMA: OptionSchema<SlotOptions> = {
+  pull: { type: "number", min: 0.25, max: 8, step: 0.25, marks: [0.5, 1, 2, 4, 8], default: 2, describe: "The weight of the pull toward the slot of a new lane." },
+  reach: { type: "number", min: 8, max: 64, step: 4, marks: [8, 16, 24, 48, 64], default: 24, describe: "A route point farther than this distance from a trunk gets no pull." },
+  laneSpacing: { type: "number", min: 2, max: 8, step: 1, marks: [2, 4, 8], default: 4, describe: "The distance between two lanes of a trunk." },
+  maxStretch: { type: "number", min: 1.05, max: 2, step: 0.05, marks: [1.1, 1.25, 1.5, 2], default: 1.25, describe: "The largest new length of a route over its first length after it joins a trunk." },
+  keys: { type: "enum", values: ["same", "any"], default: "same", describe: "The edges that can join a trunk: only the edges with the key of the trunk, or each edge." },
+  from: { ...HIGHWAY_BASE, default: "shared-ways" },
+};
+
+/** The declarations of the options of the plug strategy `leaders` (EDA-041). */
+export const LEADER_SCHEMA: OptionSchema<LeaderOptions> = {
+  leader: { type: "enum", values: ["s", "po", "opo"], default: "po", describe: "The type of leader: the order of the angles, the order along the wall, or even places." },
+  slotSpacing: { type: "number", min: 2, max: 8, step: 1, marks: [2, 4, 8], default: 8, describe: "The least gap between two plugs of one wall." },
+  inset: SPREAD_SCHEMA.inset,
+  rounds: { type: "integer", min: 0, max: 4, 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 level strategy `detail` (WILD-016 with EDA-038): the options of `depths`, and the limits of the collapse. */
+export const DETAIL_SCHEMA: OptionSchema<DetailOptions> = {
+  ...DEPTHS_SCHEMA,
+  pxMin: { type: "number", min: 0.5, max: 4, step: 0.5, marks: [1, 2, 3, 4], default: 3, describe: "Two parallel legs closer than this number of pixels on the screen become one stroke." },
+  minCount: { type: "integer", min: 2, max: 5, step: 1, default: 2, describe: "A stroke holds this number of edges or more." },
+  w0: { type: "number", min: 1, max: 4, step: 0.5, default: 1.5, describe: "The width of a stroke of one edge, in pixels." },
+  widthScale: { type: "enum", values: ["linear", "sqrt", "log"], default: "log", describe: "The growth of the width of a stroke with its count." },
+};
+
+/** The declarations of the options of the whole strategy `curriculum` (RULE-048). */
+export const CURRICULUM_SCHEMA: OptionSchema<CurriculumOptions> = {
+  order: { type: "enum", values: ["R1-R12-R2", "R12-R1-R2", "R1-R2-R12"], default: "R1-R12-R2", describe: "The order in which the stages add the rules." },
+  passes: { type: "integer", min: 1, max: 3, step: 1, default: 1, describe: "The number of passes over the edges in each stage." },
+  settings: { type: "integer", min: 2, max: 3, step: 1, default: 3, describe: "The number of settings in the pool of routes, from the start of its list." },
+  detour: { type: "number", min: 1.5, max: 4, step: 0.25, marks: [1.5, 2, 3], default: 2, describe: "A new route has a detour of at most this value, or of its old route." },
+};
+
+/** The declarations of the options of the whole strategy `preferences` (RULE-038). */
+export const PREFERENCE_SCHEMA: OptionSchema<PreferenceOptions> = {
+  l2: { type: "number", min: 0, max: 1, step: 0.01, marks: [0, 0.01, 0.1, 1], default: 0.01, describe: "The weight of the L2 term of the fit of the weights to the made-up pairs." },
+  passes: { type: "integer", min: 1, max: 3, step: 1, default: 1, describe: "The number of passes over the edges." },
+  settings: { type: "integer", min: 2, max: 3, step: 1, default: 3, describe: "The number of settings in the pool of routes, from the start of its list." },
+  detour: { type: "number", min: 1.5, max: 4, step: 0.25, marks: [1.5, 2, 3], default: 2, describe: "A new route has a detour of at most this value, or of its old route." },
+};
+
+/** The declarations of the options of the whole strategy `fireflies` (NAT-047). */
+export const FIREFLY_SCHEMA: OptionSchema<FireflyOptions> = {
+  search: { type: "enum", values: ["firefly", "bees"], default: "firefly", describe: "The search: the firefly algorithm, or the artificial bee colony." },
+  budget: { type: "integer", min: 4, max: 40, step: 1, marks: [4, 12, 20, 40], default: 12, describe: "The largest number of different settings that the search routes." },
+  colony: { type: "integer", min: 4, max: 20, step: 1, marks: [4, 6, 10, 20], default: 6, describe: "The number of fireflies or food sources." },
+  gamma: { type: "number", min: 0.01, max: 10, step: 0.01, scale: "log", marks: [0.01, 0.1, 1, 10], default: 1, describe: "The absorption of the light of a firefly." },
+  alpha: { type: "number", min: 0.01, max: 0.5, step: 0.01, marks: [0.01, 0.1, 0.2, 0.5], default: 0.2, describe: "The size of the random step of a firefly, as a share of the range." },
+  limit: { type: "integer", min: 10, max: 100, step: 10, marks: [10, 50, 100], default: 10, describe: "A scout bee leaves a food source after this number of tries with no gain." },
+  seed: { type: "integer", min: 0, max: 1_000_000, step: 1, marks: [1, 2, 3], default: 1, describe: "The seed of the search. The same seed gives the same routes." },
+};
+
+/** The declarations of the options of the whole strategy `tracing` (WILD-057). */
+export const TRACING_SCHEMA: OptionSchema<TracingOptions> = {
+  crossing: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1, 2, 4], default: 1, describe: "The weight of a crossing in the tracing load." },
+  merge: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1, 2, 4], default: 2, describe: "The weight of a merge or a split where the edge is not an outer lane." },
+  bend: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 0.5, 1, 4], default: 0.5, describe: "The weight of a bend in the tracing load." },
+  settings: { type: "integer", min: 1, max: 12, step: 1, marks: [1, 4, 8, 12], default: 4, describe: "The number of settings that the strategy tries, from the start of its list." },
+  quantile: { type: "enum", values: ["q50", "q95", "mean"], default: "q95", describe: "The value of the loads of the edges that the pick reads." },
+};