@mark1russell7/highways 0.1.2 → 0.1.4

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -39,6 +39,7 @@
     "test": "vitest run",
     "bench": "node scripts/bench.ts",
     "profile": "node scripts/profile.ts",
+    "levels": "node scripts/levels.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"
   }

package/src/bench/curves.ts

@@ -0,0 +1,98 @@
+import { curveOf, CURVE_TYPES, curveSpace, sampleCurve, type CurveType } from "../curves/index.ts";
+import { polylineLength } from "../geom.ts";
+import { nodeIndex, type Graph, type Router } from "../model.ts";
+import { nearestSide, SIDE_NORMAL } from "../plugs.ts";
+import { measureLinks, type MeasuredLink } from "./links.ts";
+
+// 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();
+
+/** One row of the benchmark of the curves: one curve type on the routes of one router on one fixture. */
+export interface CurveBenchRow {
+  readonly router: string;
+  readonly fixture: string;
+  readonly type: CurveType;
+  /** The number of routes. */
+  readonly links: number;
+  /** The number of polylines that go through a box that is not one of their ends (`measureLinks`). */
+  readonly through: number;
+  /** The number of curves without a free space that go through such a box. */
+  readonly free: number;
+  /** The number of curves with the free space of the nodes (`curveSpace`) that go through such a box. */
+  readonly clamped: number;
+  /** The ratio of the length of all curves with the free space to the length of all polylines. */
+  readonly length: number;
+  /** The time to make all curves with the free space, in milliseconds. */
+  readonly ms: number;
+}
+
+/** The options of `benchCurves`. */
+export interface CurveBenchOptions {
+  /** The radius of the types `rounded` and `arc`. The default is 12. */
+  readonly radius?: number;
+  /** The tolerance of the samples of the curves. The default is 0.25. */
+  readonly tolerance?: number;
+}
+
+/**
+ * This function routes a graph with a router and makes each curve type of each route.
+ * It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+ * The type `spline` leaves each plug along the normal of the nearest side of its node.
+ */
+export function benchCurves(router: Router, fixture: string, graph: Graph, options: CurveBenchOptions = {}): CurveBenchRow[] {
+  const tolerance = options.tolerance ?? 0.25;
+  const result = router.route(graph);
+  const byId = nodeIndex(graph);
+  const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+  const edges = new Map(graph.edges.map((e) => [e.id, e]));
+  const space = curveSpace(
+    graph.nodes.map((n) => n.box),
+    tolerance,
+  );
+  const routes = result.routes.flatMap((r) => {
+    const e = edges.get(r.edge);
+    const s = e && byId.get(e.source.node);
+    const t = e && byId.get(e.target.node);
+    if (!e || !s || !t || r.points.length < 2) return [];
+    const first = r.points[0]!;
+    const last = r.points[r.points.length - 1]!;
+    return [{ source: s.id, target: t.id, points: r.points, startNormal: SIDE_NORMAL[nearestSide(s.box, first)], endNormal: SIDE_NORMAL[nearestSide(t.box, last)] }];
+  });
+  const base = measureLinks(boxes, routes);
+  const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
+  return CURVE_TYPES.map((type): CurveBenchRow => {
+    const make = (withSpace: boolean): MeasuredLink[] =>
+      routes.map((r) => ({
+        source: r.source,
+        target: r.target,
+        points: sampleCurve(
+          curveOf(r.points, { type, radius: options.radius ?? 12, startNormal: r.startNormal, endNormal: r.endNormal, ...(withSpace ? { space } : {}) }),
+          tolerance,
+        ),
+      }));
+    const free = measureLinks(boxes, make(false));
+    const t0 = now();
+    const clamped = make(true);
+    const ms = now() - t0;
+    const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
+    return {
+      router: router.name,
+      fixture,
+      type,
+      links: routes.length,
+      through: base.through,
+      free: free.through,
+      clamped: measureLinks(boxes, clamped).through,
+      length: ink > 0 ? length / ink : 1,
+      ms,
+    };
+  });
+}
+
+/** This function writes the rows of `benchCurves` as a Markdown table. */
+export function formatCurves(rows: readonly CurveBenchRow[]): string {
+  const head = "| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |";
+  const line = "|---|---|---|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`);
+  return [head, line, ...body].join("\n");
+}

package/src/bench/links.ts

@@ -0,0 +1,191 @@
+import { dist, inflate, pointSegmentDistance, polylineLength, segmentHitsBox, type Box, type Point } from "../geom.ts";
+import { Grid } from "../grid.ts";
+import type { Graph, Level, Result } from "../model.ts";
+import { TOLERANCE } from "./properties.ts";
+
+/**
+ * The faults of a set of links: the routes of the edges, or the links of one zoom level.
+ * Each value counts links, except `worstDetour`. Lower is better for each value.
+ */
+export interface LinkFaults {
+  /** The number of links that the measure examined. */
+  readonly links: number;
+  /**
+   * The number of links that go through the inside of a box that is not one of their two ends.
+   * A segment goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
+   */
+  readonly through: number;
+  /**
+   * The number of links that go out and back. The distance from a point of the link to its last point grows after the nearest approach.
+   * A link goes out and back when this growth is more than `BACKTRACK_SHARE` of the distance between its ends, and more than `BACKTRACK_MIN` units.
+   */
+  readonly backtrack: number;
+  /** The largest ratio of the length of a link to the distance between its ends. Links with ends nearer than 1 unit do not count. */
+  readonly worstDetour: number;
+  /**
+   * The number of links with a point outside the bounding box of all the boxes, made larger by `slack`.
+   * Both ends of a link are always in that bounding box, so such a link goes around the outer edge of the board.
+   */
+  readonly outside: number;
+}
+
+/** The faults of the links of one zoom level. */
+export interface LevelFaults extends LinkFaults {
+  readonly depth: number;
+  /** The number of items of the level. */
+  readonly items: number;
+  /** The number of items that hold more than one node. */
+  readonly groups: number;
+  /** The number of pairs of items whose boxes overlap by more than `TOLERANCE` on each axis. */
+  readonly overlaps: number;
+}
+
+/** The options of the link measures. */
+export interface LinkFaultOptions {
+  /** A link that goes farther than this distance outside the bounding box of all the boxes counts in `outside`. The default is 24. */
+  readonly slack?: number;
+}
+
+/** A link goes out and back when its distance to its target grows by more than this share of the distance between its ends. */
+export const BACKTRACK_SHARE = 0.25;
+/** A link goes out and back only when its distance to its target grows by more than this number of units. */
+export const BACKTRACK_MIN = 40;
+/** The default `slack` of `LinkFaultOptions`. */
+export const OUTSIDE_SLACK = 24;
+
+/** A link from one box to another box, as `measureLinks` sees it. */
+export interface MeasuredLink {
+  readonly source: string;
+  readonly target: string;
+  readonly points: readonly Point[];
+}
+
+/**
+ * This function gives the largest growth of the distance to the last point of a polyline.
+ * The growth at a vertex is its distance to the last point, less the nearest approach of the polyline before that vertex.
+ */
+export function backtrackOf(p: readonly Point[]): number {
+  if (p.length < 3) return 0;
+  const end = p[p.length - 1]!;
+  let near = dist(p[0]!, end);
+  let worst = 0;
+  for (let i = 1; i < p.length; i++) {
+    worst = Math.max(worst, dist(p[i]!, end) - near);
+    near = Math.min(near, pointSegmentDistance(end, p[i - 1]!, p[i]!));
+  }
+  return worst;
+}
+
+/** This function tells if the polyline `p` goes out and back: `backtrackOf(p)` is more than `BACKTRACK_MIN` and more than `BACKTRACK_SHARE` of the span. */
+export function goesOutAndBack(p: readonly Point[]): boolean {
+  if (p.length < 3) return false;
+  const span = dist(p[0]!, p[p.length - 1]!);
+  return backtrackOf(p) > Math.max(BACKTRACK_MIN, BACKTRACK_SHARE * span);
+}
+
+/**
+ * This function measures the faults of links between boxes. The map `boxes` gives the box of each end.
+ * The bounding box of `outside` is the bounding box of all the boxes of the map.
+ */
+export function measureLinks(boxes: ReadonlyMap<string, Box>, links: readonly MeasuredLink[], options: LinkFaultOptions = {}): LinkFaults {
+  const slack = options.slack ?? OUTSIDE_SLACK;
+  let size = 0;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const b of boxes.values()) {
+    size += Math.max(b.w, b.h);
+    x0 = Math.min(x0, b.x);
+    y0 = Math.min(y0, b.y);
+    x1 = Math.max(x1, b.x + b.w);
+    y1 = Math.max(y1, b.y + b.h);
+  }
+  // Large items cover many buckets of a small grid, so the buckets grow with the items.
+  const grid = new Grid<string>(Math.max(180, (2 * size) / Math.max(1, boxes.size)));
+  for (const [id, b] of boxes) grid.add(id, b);
+  let through = 0;
+  let backtrack = 0;
+  let worstDetour = 0;
+  let outside = 0;
+  for (const l of links) {
+    const p = l.points;
+    if (p.length === 0) continue;
+    let hit = false;
+    for (let i = 1; i < p.length && !hit; i++) {
+      const a = p[i - 1]!;
+      const b = p[i]!;
+      grid.querySegment(a, b, 0, (id) => {
+        if (!hit && id !== l.source && id !== l.target && segmentHitsBox(a, b, inflate(boxes.get(id)!, -TOLERANCE), TOLERANCE)) hit = true;
+      });
+    }
+    if (hit) through++;
+    if (goesOutAndBack(p)) backtrack++;
+    const span = dist(p[0]!, p[p.length - 1]!);
+    if (span > 1) worstDetour = Math.max(worstDetour, polylineLength(p) / span);
+    if (p.some((q) => q.x < x0 - slack || q.x > x1 + slack || q.y < y0 - slack || q.y > y1 + slack)) outside++;
+  }
+  return { links: links.length, through, backtrack, worstDetour, outside };
+}
+
+/** This function measures the faults of the routes of a result. The ends of a route are the nodes of its edge. */
+export function measureRouteFaults(graph: Graph, result: Result, options: LinkFaultOptions = {}): LinkFaults {
+  const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+  const edges = new Map(graph.edges.map((e) => [e.id, e]));
+  const links: MeasuredLink[] = [];
+  for (const r of result.routes) {
+    const e = edges.get(r.edge);
+    if (e) links.push({ source: e.source.node, target: e.target.node, points: r.points });
+  }
+  return measureLinks(boxes, links, options);
+}
+
+/** This function counts the pairs of boxes that overlap by more than `TOLERANCE` on each axis. */
+export function countOverlaps(boxes: readonly Box[]): number {
+  let size = 0;
+  for (const b of boxes) size += Math.max(b.w, b.h);
+  const grid = new Grid<number>(Math.max(180, (2 * size) / Math.max(1, boxes.length)));
+  boxes.forEach((b, i) => grid.add(i, b));
+  let n = 0;
+  boxes.forEach((a, i) => {
+    grid.query(a, (j) => {
+      const b = boxes[j]!;
+      if (j > i && Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x) > TOLERANCE && Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > TOLERANCE) n++;
+    });
+  });
+  return n;
+}
+
+/** This function measures the faults of the links of one zoom level. The items of the level are the boxes. */
+export function measureLevel(level: Level, options: LinkFaultOptions = {}): LevelFaults {
+  const boxes = new Map(level.items.map((i) => [i.id, i.box]));
+  return {
+    depth: level.depth,
+    items: level.items.length,
+    groups: level.items.filter((i) => i.nodes.length > 1).length,
+    overlaps: countOverlaps(level.items.map((i) => i.box)),
+    ...measureLinks(boxes, level.links, options),
+  };
+}
+
+/**
+ * This function measures the faults of each zoom level of a result that has groups: the levels of the far view.
+ * A level of single nodes only is the near view. Its links are routes, and `measureRouteFaults` measures them.
+ */
+export function measureLevelFaults(result: Result, options: LinkFaultOptions = {}): LevelFaults[] {
+  return (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1)).map((l) => measureLevel(l, options));
+}
+
+/** This function adds the faults of several levels: it sums the counts and keeps the largest `worstDetour`. */
+export function sumFaults(list: readonly LinkFaults[]): LinkFaults {
+  return list.reduce<LinkFaults>(
+    (s, f) => ({
+      links: s.links + f.links,
+      through: s.through + f.through,
+      backtrack: s.backtrack + f.backtrack,
+      worstDetour: Math.max(s.worstDetour, f.worstDetour),
+      outside: s.outside + f.outside,
+    }),
+    { links: 0, through: 0, backtrack: 0, worstDetour: 0, outside: 0 },
+  );
+}

package/src/bench/room.ts

@@ -0,0 +1,122 @@
+import { levelLinks } from "../levels.ts";
+import type { Graph, Node, Result } from "../model.ts";
+import { makeRoom, roomLinks, type RoomOptions } from "../room/index.ts";
+import { sectionsRouter } from "../routers/sections.ts";
+import { laneRoutes, runKey, segmentsOf } from "../segments.ts";
+import { measureLinks, measureRouteFaults, type LinkFaults } from "./links.ts";
+import { measureQuality } from "./quality.ts";
+
+// 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();
+
+/** One row of the benchmark of the room: one state of a board, packed or open, and the measures of its links. */
+export interface RoomBenchRow {
+  readonly fixture: string;
+  /** The state of the board: `packed`, `gutter` (each gap open to the gutter only), or a method of `roomDemand`. */
+  readonly board: string;
+  /** The area of the bounding box of the boxes, as a share of the area of the packed board. */
+  readonly area: number;
+  /** The faults of the links of the far view (`levelLinks` with each box as one item). */
+  readonly faults: LinkFaults;
+  /** The crossings of the links of the far view (`measureQuality`). */
+  readonly crossings: number;
+  /** The ink of the links of the far view. */
+  readonly ink: number;
+  /** The mean detour of the links of the far view. */
+  readonly detour: number;
+  /**
+   * The number of lane routes of the router `sections` that go through a box. Each shared segment opens to one lane for each edge,
+   * at the spacing of the options (`laneRoutes`).
+   */
+  readonly laneThrough: number;
+  /** The time of `makeRoom`, in milliseconds. It is 0 for the packed board. */
+  readonly ms: number;
+}
+
+/** This function gives the area of the bounding box of the nodes. */
+function areaOf(nodes: readonly Node[]): number {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -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 measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
+ * It also measures the lane routes of the router `sections` at the lane width `spacing`.
+ */
+export function measureBoard(graph: Graph, spacing: number): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms"> {
+  const links = roomLinks(graph);
+  const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
+  const drawn = levelLinks(
+    items,
+    links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
+  );
+  const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+  // `measureQuality` reads routes of edges, so each link of the far view stands for the first edge of its pair.
+  const edgeOf = new Map<string, string>();
+  for (const e of graph.edges) {
+    const key = `${e.source.node}\u0000${e.target.node}`;
+    if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+  }
+  const asRoutes: Result = { routes: drawn.map((l) => ({ edge: edgeOf.get(`${l.source}\u0000${l.target}`)!, points: l.points })) };
+  const q = measureQuality(graph, asRoutes);
+  const routed = sectionsRouter({ name: "sections" }).route(graph);
+  const segments = segmentsOf(routed);
+  const open = new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  const lanes = laneRoutes(segments, open, spacing);
+  return {
+    faults: measureLinks(boxes, drawn),
+    crossings: q.crossings,
+    ink: q.ink,
+    detour: q.detour,
+    laneThrough: measureRouteFaults(graph, { routes: lanes }).through,
+  };
+}
+
+/**
+ * This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
+ * The options of `makeRoom` are the same for each method, except `method`.
+ */
+export function benchRoom(fixture: string, graph: Graph, options: RoomOptions = {}): RoomBenchRow[] {
+  const spacing = options.spacing ?? 4;
+  const area0 = areaOf(graph.nodes);
+  const links = roomLinks(graph);
+  const row = (board: string, nodes: readonly Node[], ms: number): RoomBenchRow => ({
+    fixture,
+    board,
+    area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+    ms,
+    ...measureBoard({ nodes, edges: graph.edges }, spacing),
+  });
+  const rows = [row("packed", graph.nodes, 0)];
+  const states: [string, RoomOptions][] = [
+    ["gutter", { ...options, spacing: 0, method: "routes" }],
+    ["routes", { ...options, method: "routes" }],
+    ["lines", { ...options, method: "lines" }],
+  ];
+  for (const [board, o] of states) {
+    const t0 = now();
+    const room = makeRoom(graph.nodes, links, o);
+    rows.push(row(board, room.items, now() - t0));
+  }
+  return rows;
+}
+
+/** This function writes the rows of `benchRoom` as a Markdown table. */
+export function formatRoom(rows: readonly RoomBenchRow[]): string {
+  const head = "| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => {
+    const f = r.faults;
+    return `| ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${f.links} | ${f.through} | ${f.outside} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${r.crossings} | ${Math.round(r.ink)} | ${r.detour.toFixed(3)} | ${r.laneThrough} | ${r.ms.toFixed(1)} |`;
+  });
+  return [head, line, ...body].join("\n");
+}

package/src/bench/run.ts

@@ -1,5 +1,6 @@
 import { makeFixture, type FixtureSpec } from "../fixtures.ts";
 import type { Graph, Result, Router } from "../model.ts";
+import { measureLevelFaults, measureRouteFaults, sumFaults, type LevelFaults, type LinkFaults } from "./links.ts";
 import { checkProperties, type Violation } from "./properties.ts";
 import { measureQuality, type Quality } from "./quality.ts";
 
@@ -20,6 +21,10 @@ export interface BenchRow {
   /** The first violations, for the report. */
   readonly sample: readonly Violation[];
   readonly quality: Quality;
+  /** The faults of the routes of the edges (`measureRouteFaults`). */
+  readonly faults: LinkFaults;
+  /** The faults of each zoom level with groups (`measureLevelFaults`). The list is empty for a router without levels. */
+  readonly levelFaults: readonly LevelFaults[];
 }
 
 /** The options of a benchmark run. */
@@ -87,6 +92,8 @@ export function benchOne(router: Router, fixture: string, graph: Graph, repeat =
     violations: all.length,
     sample: all.slice(0, 5),
     quality: measureQuality(graph, result),
+    faults: measureRouteFaults(graph, result),
+    levelFaults: measureLevelFaults(result),
   };
 }
 
@@ -101,3 +108,24 @@ export function formatTable(rows: readonly BenchRow[]): string {
   });
   return [head, line, ...body].join("\n");
 }
+
+/**
+ * This function writes the faults of the rows as a Markdown table: the routes first, then the sum of the levels with groups.
+ * A router without such levels gets a dash in the columns of the levels.
+ */
+export function formatFaults(rows: readonly BenchRow[]): string {
+  const head =
+    "| router | fixture | through | out and back | worst detour | outside | level links | level overlaps | level through | level out and back | level worst detour | level outside |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => {
+    const f = r.faults;
+    const cells = [r.router, r.fixture, f.through, f.backtrack, f.worstDetour.toFixed(2), f.outside];
+    if (r.levelFaults.length === 0) cells.push("-", "-", "-", "-", "-", "-");
+    else {
+      const l = sumFaults(r.levelFaults);
+      cells.push(l.links, r.levelFaults.reduce((s, x) => s + x.overlaps, 0), l.through, l.backtrack, l.worstDetour.toFixed(2), l.outside);
+    }
+    return `| ${cells.join(" | ")} |`;
+  });
+  return [head, line, ...body].join("\n");
+}

package/src/cases.ts

@@ -0,0 +1,139 @@
+import { makeFixture, rng } from "./fixtures.ts";
+import type { Edge, Graph, Node } from "./model.ts";
+
+/**
+ * A board of made-up data that shows one known defect of the routes or of the zoom levels.
+ * The benchmark races the routers on each case, and the measures of `measureLinks` give a number for the defect.
+ */
+export interface CaseBoard {
+  readonly name: string;
+  /** The defect that the board shows, in a few words. */
+  readonly defect: string;
+  /** This function makes the graph. The same function always gives the same graph. */
+  readonly make: () => Graph;
+}
+
+/** A board while it grows: the functions add nodes and edges in order. */
+class Board {
+  readonly nodes: Node[] = [];
+  readonly edges: Edge[] = [];
+  readonly #pairs = new Set<string>();
+
+  node(id: string, x: number, y: number, w: number, h: number): string {
+    this.nodes.push({ id, box: { x, y, w, h } });
+    return id;
+  }
+
+  /** This method adds an edge. It adds nothing for a loop or for a second edge between the same two nodes. */
+  link(source: string, target: string): void {
+    const key = source < target ? `${source}|${target}` : `${target}|${source}`;
+    if (source === target || this.#pairs.has(key)) return;
+    this.#pairs.add(key);
+    this.edges.push({ id: `e${this.edges.length}`, source: { node: source }, target: { node: target } });
+  }
+
+  graph(): Graph {
+    return { nodes: this.nodes, edges: this.edges };
+  }
+}
+
+/**
+ * This function makes a dense board: 150 nodes in tight clusters. At the far view, the boxes of the groups overlap.
+ * Then a level link starts or ends in a group that another group covers.
+ */
+export function denseGroupsBoard(): Graph {
+  return makeFixture({ name: "dense-groups", kind: "clustered", nodes: 150, edgesPerNode: 2, seed: 3 });
+}
+
+/**
+ * This function makes a board of three rows of 32 cards. Each card links to the next card of its row.
+ * Forty long links join cards far apart. The hub of a section is near the middle of its cards.
+ * So a long link climbs to hubs behind its source or past its target, and comes back.
+ */
+export function hubChainBoard(): Graph {
+  const R = rng(3);
+  const b = new Board();
+  const rows = 3;
+  const cols = 32;
+  const gap = 48;
+  const id = (r: number, c: number): string => `c${r}-${c}`;
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * (80 + gap), r * (36 + gap), 80, 36);
+  for (let r = 0; r < rows; r++) for (let c = 0; c + 1 < cols; c++) b.link(id(r, c), id(r, c + 1));
+  for (let n = 0; n < 40; n++) {
+    const r = Math.floor(R() * rows);
+    const c = Math.floor(R() * cols);
+    const span = Math.floor(cols / 8 + (R() * cols) / 2);
+    if (c + span < cols) b.link(id(r, c), id((r + 1) % rows, c + span));
+  }
+  return b.graph();
+}
+
+/**
+ * This function makes a board of 32 groups in 8 columns and 4 rows. Each group has 4 cards in a square.
+ * The cards of a group link in a chain, and 96 random links join cards of two groups.
+ * On a level with many groups, some level links go around the outer edge of the board.
+ */
+export function manyGroupsBoard(): Graph {
+  const R = rng(7);
+  const b = new Board();
+  const cols = 8;
+  const rows = 4;
+  const per = 4;
+  const w = 60;
+  const h = 30;
+  const cardGap = 12;
+  const groupGap = 60;
+  const side = Math.ceil(Math.sqrt(per));
+  const gw = side * w + (side - 1) * cardGap;
+  const gh = Math.ceil(per / side) * h + (Math.ceil(per / side) - 1) * cardGap;
+  const groups: string[][] = [];
+  for (let r = 0; r < rows; r++)
+    for (let c = 0; c < cols; c++) {
+      const list: string[] = [];
+      for (let i = 0; i < per; i++) {
+        const x = c * (gw + groupGap) + (i % side) * (w + cardGap);
+        const y = r * (gh + groupGap) + Math.floor(i / side) * (h + cardGap);
+        list.push(b.node(`g${r}-${c}-${i}`, x, y, w, h));
+      }
+      groups.push(list);
+    }
+  for (const list of groups) for (let i = 1; i < list.length; i++) b.link(list[i - 1]!, list[i]!);
+  const pick = (list: readonly string[]): string => list[Math.floor(R() * list.length)]!;
+  for (let n = 0; n < groups.length * 3; n++) b.link(pick(groups[Math.floor(R() * groups.length)]!), pick(groups[Math.floor(R() * groups.length)]!));
+  return b.graph();
+}
+
+/**
+ * This function makes the far view of a board after a host layout packs it.
+ * The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+ * The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+ * The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+ *
+ * The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+ */
+export function packedGridBoard(): Graph {
+  const R = rng(11);
+  const b = new Board();
+  const cols = 12;
+  const rows = 8;
+  const w = 140;
+  const h = 90;
+  const id = (r: number, c: number): string => `p${r}-${c}`;
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * w, r * h, w, h);
+  const step = (): number => Math.floor(R() * 5) - 2;
+  for (let r = 0; r < rows; r++)
+    for (let c = 0; c < cols; c++) {
+      const rr = Math.max(0, Math.min(rows - 1, r + step()));
+      const cc = Math.max(0, Math.min(cols - 1, c + step()));
+      b.link(id(r, c), id(rr, cc));
+    }
+  for (let n = 0; n < 48; n++) b.link(id(Math.floor(R() * rows), Math.floor(R() * cols)), id(Math.floor(R() * rows), Math.floor(R() * cols)));
+  return b.graph();
+}
+
+/** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
+export const CASES: readonly CaseBoard[] = [
+  { name: "case-dense-groups", defect: "Groups overlap at the far view, and level links go through other groups.", make: denseGroupsBoard },
+  { name: "case-hub-chain", defect: "A route climbs a chain of hubs away from its target and comes back.", make: hubChainBoard },
+  { name: "case-many-groups", defect: "On a level with many groups, links go around the outer edge of the board.", make: manyGroupsBoard },
+];