@mark1russell7/highways 0.8.1 → 0.9.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mark1russell7/layout-contract": "^0.2.8"
+    "@mark1russell7/layout-contract": "^0.2.14"
   },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",
@@ -43,6 +43,7 @@
     "test": "vitest run",
     "bench": "node scripts/bench.ts",
     "ideas": "node scripts/ideas.ts",
+    "queue": "node scripts/queue.ts",
     "bench:join": "node scripts/bench-join.ts",
     "profile": "node scripts/profile.ts",
     "levels": "node scripts/levels.ts",

package/src/bench/compare.ts

@@ -1,15 +1,21 @@
 import type { CurveSegment } from "../curves/model.ts";
-import { polylineLength } from "../geom.ts";
-import type { Graph, Result } from "../model.ts";
+import { polylineLength, type Box } from "../geom.ts";
+import { highwayRouterStrategy } from "../highways/router.ts";
+import type { Graph, LevelLink, Node, Result } from "../model.ts";
+import { openGaps, roomLinks } from "../room/index.ts";
+import { cornersRouter } from "../routers/corners.ts";
+import { sectionsRouter } from "../routers/sections.ts";
 import type { Section } from "../sections.ts";
 import { runKey, segmentsOf } from "../segments.ts";
 import { STRATEGIES } from "../strategies/builtins.ts";
-import { asRouter, getStrategy, listStrategies, type LaneBoard, type Registry, type Step } from "../strategies/model.ts";
+import { asRouter, createRegistry, defineStrategy, getStrategy, listStrategies, STEPS, type AnyStrategy, type LaneBoard, type Registry, type Step, type Strategy } from "../strategies/model.ts";
 import { peakCurvature } from "./curves.ts";
 import { measureLevelFaults, sumFaults } from "./links.ts";
 import { paretoFront, type Objective } from "./measures/pareto.ts";
+import { roomOrderFaults } from "./measures/room.ts";
 import { boardUnit } from "./measures/routes.ts";
 import { changeGraph, routeStability } from "./measures/stability.ts";
+import { farLinks, measureBoard } from "./room.ts";
 import { benchRun } from "./run.ts";
 import { curveRuns, fixtureGroupOptions, FRONT_OBJECTIVES, groupRun, routeMeasures } from "./suite.ts";
 
@@ -42,11 +48,24 @@ function laneBoard(result: Result, lanes: { readonly width: number; readonly max
   return { graph, open, width: lanes.width, ...(lanes.maxWidth === undefined ? {} : { maxWidth: lanes.maxWidth }) };
 }
 
+/**
+ * The steps whose strategies give no routes alone. `compareAnyStep` and the screen compare each strategy of these steps as a router (`stepRouterStrategy`).
+ * The step `highway` gives a plan, and the step `plugs` gives the plugs.
+ * The step `levels` gives the zoom levels, and the step `whole` gives a board with its routes.
+ */
+export type RoutedStep = "plugs" | "highway" | "levels" | "whole";
+
+/** The steps of `RoutedStep`, in the order of the pipeline. */
+export const ROUTED_STEPS: readonly RoutedStep[] = ["plugs", "highway", "levels", "whole"];
+
+/** This function tells if a step is a step of `RoutedStep`. */
+export const isRoutedStep = (step: Step): step is RoutedStep => (ROUTED_STEPS as readonly Step[]).includes(step);
+
 /**
  * The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list.
- * The step `highway` gives a plan, not routes. The screen routes each plan with `follow` and compares it as a router.
+ * The steps of `RoutedStep` give no routes alone, so they are not in the list. `compareAnyStep` compares them as routers.
  */
-export type CompareStep = Exclude<Step, "room" | "highway">;
+export type CompareStep = Exclude<Step, "room" | RoutedStep>;
 
 /** The steps that `compareStep` compares, in the order of the pipeline. */
 export const COMPARE_STEPS: readonly CompareStep[] = ["group", "router", "curve"];
@@ -178,3 +197,153 @@ export function compareStep(step: CompareStep, graph: Graph, options: CompareOpt
     excluded: rows.filter((r) => !fair.includes(r)).map((r) => r.strategy),
   };
 }
+
+// The core runs in any host, so it reads the clock without the types of Node or the browser.
+const now = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** The steps that `compareAnyStep` compares: each step of `STEPS`, in the order of the pipeline. */
+export const COMPARE_ALL_STEPS: readonly Step[] = STEPS;
+
+/**
+ * This function gives a router for each highway strategy of a registry, in the order of the registry.
+ * Each router makes the plan of its strategy and routes the plan with `follow` (`highwayRouterStrategy`).
+ * The screen and `compareAnyStep` compare the highway strategies as these routers.
+ */
+export function highwayRouters(registry: Registry): Strategy<"router">[] {
+  return listStrategies(registry, "highway").map((s) => highwayRouterStrategy(s) as Strategy<"router">);
+}
+
+/**
+ * This function gives a router strategy that runs a strategy of a step of `RoutedStep`. The router has the name, the options and the schema of the strategy.
+ * - A highway strategy makes its plan, and `follow` routes the plan (`highwayRouterStrategy`).
+ * - A plug rule gives the plugs of the router `corners` (its option `plug`).
+ * - A level rule gives the zoom levels of the router `sections` (its option `level`).
+ * - A whole strategy gives the routes of its output. A room strategy in its options can change the board, but the measures read the input graph.
+ */
+export function stepRouterStrategy(strategy: Strategy<RoutedStep>): Strategy<"router"> {
+  if (strategy.step === "highway") return highwayRouterStrategy(strategy as Strategy<"highway">) as Strategy<"router">;
+  const { name, describe, defaults } = strategy;
+  const own = (maxNodes: number | undefined, route: (graph: Graph, options: object) => Result): Strategy<"router"> =>
+    defineStrategy<"router", object>({
+      step: "router",
+      name,
+      describe,
+      defaults,
+      ...(strategy.schema === undefined ? {} : { schema: strategy.schema }),
+      ...(maxNodes === undefined ? {} : { maxNodes }),
+      run: route,
+    });
+  if (strategy.step === "plugs") return own(strategy.maxNodes ?? 10_000, (graph, o) => cornersRouter({ name, plug: strategy as Strategy<"plugs">, plugOptions: o }).route(graph));
+  if (strategy.step === "levels") return own(strategy.maxNodes ?? 100_000, (graph, o) => sectionsRouter({ name, level: strategy as Strategy<"levels">, levelOptions: o }).route(graph));
+  return own(strategy.maxNodes, (graph, o) => (strategy as Strategy<"whole">).run(graph, o).result);
+}
+
+/** This function gives a router for each strategy of one step of `RoutedStep` in a registry, in the order of the registry (`stepRouterStrategy`). */
+export function stepRouters(registry: Registry, step: RoutedStep): Strategy<"router">[] {
+  return (listStrategies(registry, step) as readonly Strategy<RoutedStep>[]).map((s) => stepRouterStrategy(s));
+}
+
+/** One strategy of any step on one graph: a row of `compareStep`, or a row of the steps `highway` and `room`. */
+export interface AnyCompareRow extends Omit<CompareRow, "step"> {
+  readonly step: Step;
+  /** The boxes of the board that the room strategy opens, in the order of the nodes, for the step `room`. */
+  readonly boxes?: readonly Box[];
+  /** The links of the far view on the board that the room strategy opens, for the step `room`. */
+  readonly links?: readonly LevelLink[];
+}
+
+/** The comparison of the strategies of any step on one graph. */
+export interface AnyStepComparison extends Omit<StepComparison, "step" | "rows"> {
+  readonly step: Step;
+  /** One row for each strategy of the step, in the order of the registry. */
+  readonly rows: readonly AnyCompareRow[];
+}
+
+/** The options of `compareAnyStep`. */
+export interface AnyCompareOptions extends CompareOptions {
+  /** This function gets each row when its strategy is done, with the number of rows that are done and the number of all rows. A host can show the progress. */
+  readonly onRow?: (row: AnyCompareRow, done: number, total: number) => void;
+}
+
+/** This function gives the area of the bounding box of the nodes. */
+function boundsArea(nodes: readonly Node[]): number {
+  let [x0, y0, x1, y1] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const n of nodes) {
+    x0 = Math.min(x0, n.box.x);
+    y0 = Math.min(y0, n.box.y);
+    x1 = Math.max(x1, n.box.x + n.box.w);
+    y1 = Math.max(y1, n.box.y + n.box.h);
+  }
+  return nodes.length ? (x1 - x0) * (y1 - y0) : 0;
+}
+
+/**
+ * This function gives the measures of a board that a room strategy opened.
+ * It uses the keys and the lane spacing 4 of the step `room` of `runSuite`.
+ * The measures are the area against the board before (`M1.area`), the lane routes through a box (`M4.laneThrough`), the faults of the far view and `room-order`.
+ */
+export function roomValues(graph: Graph, open: readonly Node[]): Record<string, number> {
+  const area0 = boundsArea(graph.nodes);
+  const m = measureBoard({ nodes: open, edges: graph.edges }, 4);
+  return {
+    "M1.area": area0 > 0 ? boundsArea(open) / area0 : 1,
+    "M4.laneThrough": m.laneThrough,
+    crossings: m.crossings,
+    through: m.faults.through,
+    "R6.worstDetour": m.faults.worstDetour,
+    "room-order": roomOrderFaults(graph.nodes, open),
+  };
+}
+
+/** This function runs one room strategy on the boxes of a graph, opens the gaps of the board and measures the open board. */
+function roomRow(strategy: Strategy<"room">, graph: Graph, options: object | undefined): AnyCompareRow {
+  const t0 = now();
+  const gaps = strategy.run({ items: graph.nodes, links: roomLinks(graph) }, options);
+  const open = openGaps(graph.nodes, gaps);
+  const ms = now() - t0;
+  const values = { ...roomValues(graph, open), ms };
+  return { step: "room", strategy: strategy.name, violations: 0, ms, values, boxes: open.map((n) => n.box), links: farLinks({ nodes: open, edges: graph.edges }) };
+}
+
+/** This function runs one strategy of one step on one graph, as `compareAnyStep` does. */
+function compareOne(step: Step, strategy: AnyStrategy, graph: Graph, registry: Registry, options: CompareOptions): AnyCompareRow {
+  if (step === "room") return roomRow(strategy as Strategy<"room">, graph, options.options?.[strategy.name]);
+  if (isRoutedStep(step)) {
+    const one = createRegistry([stepRouterStrategy(strategy as Strategy<RoutedStep>) as AnyStrategy]);
+    return { ...compareStep("router", graph, { ...options, registry: one }).rows[0]!, step };
+  }
+  const curveRouter = step === "curve" ? [getStrategy(registry, "router", options.curveRouter ?? "corners") as AnyStrategy] : [];
+  return compareStep(step, graph, { ...options, registry: createRegistry([...curveRouter, strategy]) }).rows[0]!;
+}
+
+/**
+ * This function runs each strategy of any step of `STEPS` on one graph and measures it. Then it gives the Pareto front of `FRONT_OBJECTIVES`.
+ * The steps `group`, `router` and `curve` give the rows of `compareStep`.
+ * The step `highway` makes the plan of each strategy and routes it with `follow`, as the screen does. It measures the routes as the step `router`.
+ * The steps `plugs`, `levels` and `whole` also run each strategy as a router (`stepRouterStrategy`), and measure the routes as the step `router`.
+ * The step `room` opens the gaps of the board with each strategy (`openGaps`). It measures the open board as the step `room` of `runSuite`.
+ * The step `room` expects a packed board, for example `packedGridBoard`. On a board with wide gaps, a gap opens only when its links need more room.
+ *
+ * The function runs one strategy at a time and gives each row to `onRow`. The same graph and the same options give the same measures. Only the times change.
+ */
+export function compareAnyStep(step: Step, graph: Graph, options: AnyCompareOptions = {}): AnyStepComparison {
+  const registry = options.registry ?? STRATEGIES;
+  const { onRow, ...rest } = options;
+  const strategies = listStrategies(registry, step) as readonly AnyStrategy[];
+  const rows: AnyCompareRow[] = [];
+  for (const strategy of strategies) {
+    const over = graph.nodes.length > (strategy.maxNodes ?? Infinity);
+    const row: AnyCompareRow = over ? { step, strategy: strategy.name, violations: 0, ms: 0, values: {}, skipped: `over ${strategy.maxNodes} nodes` } : compareOne(step, strategy, graph, registry, rest);
+    rows.push(row);
+    onRow?.(row, rows.length, strategies.length);
+  }
+  const objectives = FRONT_OBJECTIVES[step];
+  const fair = rows.filter((r) => r.violations === 0 && r.skipped === undefined);
+  return {
+    step,
+    rows,
+    objectives,
+    front: paretoFront(fair, (r) => r.values, objectives).map((r) => r.strategy),
+    excluded: rows.filter((r) => !fair.includes(r)).map((r) => r.strategy),
+  };
+}

package/src/bench/room.ts

@@ -85,7 +85,7 @@ export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder):
 }
 
 /** This function gives the links of the far view of a board: `levelLinks` with each node as one item. */
-function farLinks(graph: Graph): LevelLink[] {
+export function farLinks(graph: Graph): LevelLink[] {
   const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
   return levelLinks(
     items,

package/src/bench/run.ts

@@ -27,6 +27,23 @@ export interface BenchRow {
   readonly levelFaults: readonly LevelFaults[];
   /** The routes of this cell took longer than the cell limit. The cell did not start more routes. A row within the limit has no such field. */
   readonly overLimit?: OverLimit;
+  /** The time of the paired baseline arm (BENCH-GREEN). Only a cell with a baseline router has it. */
+  readonly paired?: Paired;
+}
+
+/**
+ * The paired baseline arm of a cell. The baseline router routes the same graph in turn with the router, on the same CPU.
+ * The ratio does not change with the speed of the runner, so the ratios of two runs compare better than their times.
+ */
+export interface Paired {
+  /** The name of the baseline router. */
+  readonly base: string;
+  /** The median time of one route of the router in the paired routes, in milliseconds. */
+  readonly ms: number;
+  /** The median time of one route of the baseline router, in milliseconds. */
+  readonly baseMs: number;
+  /** The ratio `ms / baseMs`. A ratio below 1 tells that the router is faster than the baseline. */
+  readonly ratio: number;
 }
 
 /** The record of a cell over its time limit. */
@@ -97,32 +114,49 @@ export interface BenchRun {
   readonly result: Result;
 }
 
-/** This function does the work of `benchOne` and also gives the result, so more measures can read it without a second route. */
-export function benchRun(router: Router, fixture: string, graph: Graph, repeat = 3, cellLimit: number = Infinity): BenchRun {
+/**
+ * This function does the work of `benchOne` and also gives the result, so more measures can read it without a second route.
+ * With a baseline router `pair`, the baseline routes the graph one time for each route of the router, in turn: first before, then after.
+ * The row then gets `paired`. The baseline routes do not count for the cell limit, and their results do not change the row.
+ */
+export function benchRun(router: Router, fixture: string, graph: Graph, repeat = 3, cellLimit: number = Infinity, pair?: Router): BenchRun {
   const times: number[] = [];
+  const baseTimes: number[] = [];
+  const timeBase = (): void => {
+    if (!pair) return;
+    const t0 = now();
+    pair.route(graph);
+    baseTimes.push(now() - t0);
+  };
   let first: Result | undefined;
   let deterministic = true;
   let spent = 0;
   for (let i = 0; i < Math.max(2, repeat); i++) {
+    // The order of the two arms changes at each route, so a warm cache helps each arm equally.
+    if (i % 2 === 0) timeBase();
     const t0 = now();
     const r = router.route(graph);
     const t = now() - t0;
     times.push(t);
     spent += t;
+    if (i % 2 === 1) timeBase();
     if (!first) first = r;
     else if (i === 1 && !sameData(r, first)) deterministic = false;
     if (spent > cellLimit) break;
   }
   const runs = times.length;
   times.sort((a, b) => a - b);
+  baseTimes.sort((a, b) => a - b);
   const result = first!;
+  const ms = times[Math.floor(times.length / 2)]!;
+  const baseMs = baseTimes[Math.floor(baseTimes.length / 2)];
   const all = checkProperties(graph, result, 1_000_000);
   const row: BenchRow = {
     router: router.name,
     fixture,
     nodes: graph.nodes.length,
     edges: graph.edges.length,
-    ms: times[Math.floor(times.length / 2)]!,
+    ms,
     deterministic,
     violations: all.length,
     sample: all.slice(0, 5),
@@ -130,6 +164,7 @@ export function benchRun(router: Router, fixture: string, graph: Graph, repeat =
     faults: measureRouteFaults(graph, result),
     levelFaults: measureLevelFaults(result),
     ...(spent > cellLimit ? { overLimit: { limit: cellLimit, runs } } : {}),
+    ...(pair && baseMs !== undefined ? { paired: { base: pair.name, ms, baseMs, ratio: baseMs > 0 ? ms / baseMs : 0 } } : {}),
   };
   return { row, result };
 }

package/src/bench/screen/generators.ts

@@ -1,10 +1,8 @@
-import type { LayoutInput, LayoutObstacle } from "./forms.ts";
-import { documentHash, mulberry32, stepSeed } from "./hash.ts";
+import { createFamilyRegistry, RECT_SCATTERED } from "@mark1russell7/layout-contract";
+import type { LayoutInput } from "./forms.ts";
 
-/** This function gives a whole number from `lo` to `hi`, both included, from a generator of random numbers. */
-export function randomInt(r: () => number, lo: number, hi: number): number {
-  return lo + Math.floor(r() * (hi - lo + 1));
-}
+/** This function gives a whole number from `lo` to `hi`, both included, from a generator of random numbers. It is the shared function of `@mark1russell7/layout-contract`. */
+export { randomInt } from "@mark1russell7/layout-contract";
 
 /** The parameters of the generator `rect-scattered`. */
 export interface RectScatteredParams {
@@ -12,43 +10,15 @@ export interface RectScatteredParams {
   readonly count: number;
 }
 
+/** The registry of the shared family `rect-scattered` (CORPUS-GEN). highways has no copy of its generator. */
+const SHARED = createFamilyRegistry([RECT_SCATTERED]);
+
 /**
  * This function makes the input of the shared generator `rect-scattered`, version 1: a fixed rectangle container, scattered obstacles and boxes without positions.
- * The repository `packing` makes the same file, byte for byte. A test in each repository pins the hashes of the seeds 1, 2 and 3.
- * The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
+ * It uses the shared family `RECT_SCATTERED` of `@mark1russell7/layout-contract` (CORPUS-GEN). The repository `packing` makes the same file, byte for byte.
+ *
+ * @deprecated Use `RECT_SCATTERED` on a registry of `createFamilyRegistry`. This function stays for the callers of today.
  */
 export function rectScattered(seed: number, params: RectScatteredParams, set = "xcheck-v1"): LayoutInput {
-  let r = mulberry32(stepSeed(seed, "container"));
-  const w = randomInt(r, 600, 1000);
-  const h = randomInt(r, 400, 800);
-  r = mulberry32(stepSeed(seed, "obstacles"));
-  const n = randomInt(r, 3, 8);
-  const obstacles: LayoutObstacle[] = [];
-  for (let i = 0; i < n; i++) {
-    const ow = randomInt(r, 40, 160);
-    const oh = randomInt(r, 40, 160);
-    const x = randomInt(r, 0, w - ow);
-    const y = randomInt(r, 0, h - oh);
-    obstacles.push({ id: `o${i}`, region: { kind: "rect", x, y, w: ow, h: oh } });
-  }
-  r = mulberry32(stepSeed(seed, "boxes"));
-  const boxes = Array.from({ length: params.count }, (_, i) => {
-    const bw = randomInt(r, 20, 120);
-    const bh = randomInt(r, 20, 80);
-    return { id: `b${i}`, w: bw, h: bh };
-  });
-  const body = {
-    schema: "layout-input/1" as const,
-    id: `${set}/rect-scattered/s${seed}`,
-    set,
-    family: "rect-scattered",
-    seed,
-    source: "made-up" as const,
-    generator: { name: "rect-scattered", version: 1, params: { count: params.count }, seed },
-    container: { w, h, fixed: "size" as const },
-    obstacles,
-    boxes,
-    edges: [],
-  };
-  return { ...body, hash: documentHash(body) };
+  return SHARED.generate("rect-scattered", seed, { count: params.count }, { set }) as unknown as LayoutInput;
 }

package/src/bench/screen/screen.ts

@@ -1,10 +1,9 @@
-import { highwayRouterStrategy } from "../../highways/router.ts";
 import type { Graph, Result, Route } from "../../model.ts";
 import { stableOrderStrategy } from "../../order/index.ts";
 import { repairStrategy } from "../../repair/index.ts";
 import { STRATEGIES } from "../../strategies/builtins.ts";
 import { asRouter, createRegistry, getStrategy, listStrategies, register, STEPS, type AnyStrategy, type Registry, type Strategy } from "../../strategies/model.ts";
-import { compareStep, type CompareRow, type CompareStep, type StepComparison } from "../compare.ts";
+import { compareStep, highwayRouters, isRoutedStep, stepRouters, type CompareRow, type CompareStep, type RoutedStep, type StepComparison } from "../compare.ts";
 import { bundledShare, bundleStretch, mergeAngle } from "../measures/bundles.ts";
 import { highwayEdits } from "../measures/highways.ts";
 import { laneArea, laneCrossings, laneFidelity, lanesThrough, occupiedArea, openLanes, orthogonality, routeSeparation, runProfile } from "../measures/lanes.ts";
@@ -27,13 +26,14 @@ import { measureByName, measureName, namedObjectives } from "./measures.ts";
 import { SCREEN_V1, screenInputs, type ScreenSet } from "./set.ts";
 
 /**
- * The steps of the screen: the steps of `compareStep` and the step `highway`.
+ * The steps of the screen: the steps of `compareStep` and the steps of `RoutedStep`.
  * The screen of the step `highway` routes the plan of each strategy with `follow`, and measures the routes as the routes of a router.
+ * The screen of the steps `plugs`, `levels` and `whole` runs each strategy as a router (`stepRouterStrategy`). It measures the routes as the routes of a router.
  */
-export type ScreenStep = CompareStep | "highway";
+export type ScreenStep = CompareStep | RoutedStep;
 
 /** The steps of the screen, in the order of the pipeline. */
-export const SCREEN_STEPS: readonly ScreenStep[] = ["group", "router", "highway", "curve"];
+export const SCREEN_STEPS: readonly ScreenStep[] = ["group", "plugs", "router", "highway", "levels", "curve", "whole"];
 
 /** The routers that the screen of the step `highway` also runs by default. They are the baselines of the note on highways. */
 export const HIGHWAY_BASE_ROUTERS: readonly string[] = ["corners", "shared", "trunks"];
@@ -54,6 +54,9 @@ const ROUTE_RULES: readonly string[] = ["complete", "ends-at-plugs", "fixed-plug
 export const SCREEN_RULES: Readonly<Record<ScreenStep, readonly string[]>> = {
   router: ROUTE_RULES,
   highway: ROUTE_RULES,
+  plugs: ROUTE_RULES,
+  levels: ROUTE_RULES,
+  whole: ROUTE_RULES,
   group: ["sections", "counts-sum", "link-ends", "same-twice"],
   curve: ["same-twice"],
 };
@@ -221,8 +224,8 @@ function screenRegistry(step: ScreenStep, strategies: readonly (Strategy<ScreenS
   return { registry: createRegistry([...others, ...(own as readonly AnyStrategy[])]), candidates };
 }
 
-/** This function tells if a step of the screen gives routes. The step `router` gives routes, and the step `highway` gives routes after `follow`. */
-const givesRoutes = (step: ScreenStep): step is "router" | "highway" => step === "router" || step === "highway";
+/** This function tells if a step of the screen gives routes. The step `router` gives routes, and each step of `RoutedStep` gives routes as a router. */
+const givesRoutes = (step: ScreenStep): step is "router" | RoutedStep => step === "router" || isRoutedStep(step);
 
 /**
  * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
@@ -347,14 +350,17 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
   const candidates = screened.candidates;
   // The step `highway` runs as the step `router`. Each highway strategy with `follow` is a router, after the base routers.
   const base = step === "highway" ? (options.baseRouters ?? HIGHWAY_BASE_ROUTERS).map((name) => getStrategy(STRATEGIES, "router", name)) : [];
+  // The steps `plugs`, `levels` and `whole` run each strategy as one router, with no base routers.
   const unwrapped =
     step === "highway"
-      ? createRegistry([...base, ...listStrategies(screened.registry, "highway").map((s) => highwayRouterStrategy(s))] as readonly AnyStrategy[])
-      : screened.registry;
+      ? createRegistry([...base, ...highwayRouters(screened.registry)] as readonly AnyStrategy[])
+      : isRoutedStep(step)
+        ? createRegistry(stepRouters(screened.registry, step) as readonly AnyStrategy[])
+        : screened.registry;
   const wrapped = givesRoutes(step) ? wrapRouters(unwrapped, options.wrap ?? []) : { registry: unwrapped, added: [] };
   const registry = wrapped.registry;
   for (const name of wrapped.added) candidates.add(name);
-  const compareAs: CompareStep = step === "highway" ? "router" : step;
+  const compareAs: CompareStep = isRoutedStep(step) ? "router" : step;
   const baseNames = new Set(base.map((s) => s.name));
   const stepOf = (name: string): ScreenStep => (baseNames.has(unwrappedName(name)) ? "router" : step);
   // A wrapped router gets the options of its router, unless the call gives its own.