@mark1russell7/highways 0.4.0 → 0.4.2

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -38,6 +38,7 @@
     "build": "tsdown",
     "test": "vitest run",
     "bench": "node scripts/bench.ts",
+    "ideas": "node scripts/ideas.ts",
     "bench:join": "node scripts/bench-join.ts",
     "profile": "node scripts/profile.ts",
     "levels": "node scripts/levels.ts",

package/src/bench/measures/bundles.ts

@@ -1,7 +1,8 @@
-import { dist, polylineLength } from "../../geom.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
 import { rng } from "../../fixtures.ts";
-import type { Graph, Route } from "../../model.ts";
+import type { Graph, Result, Route } from "../../model.ts";
 import { drawnSegments, segmentKey } from "./routes.ts";
+import { quantile } from "./stats.ts";
 
 /**
  * This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
@@ -117,3 +118,101 @@ export function ambiguity(graph: Graph, routes: readonly Route[], options: Ambig
   });
   return { value: all ? wrong / all : 0, estimated: !exact };
 }
+
+/** The drawn segments of each route, as keys, in the order of its points. A segment shorter than the grain of `segmentKey` has no key. */
+function routeKeys(routes: readonly Route[]): { readonly keys: Map<string, string[]>; readonly users: Map<string, Set<string>> } {
+  const keys = new Map<string, string[]>();
+  const users = new Map<string, Set<string>>();
+  for (const r of routes) {
+    const own: string[] = [];
+    for (let i = 1; i < r.points.length; i++) {
+      const k = segmentKey(r.points[i - 1]!, r.points[i]!);
+      if (k === undefined) continue;
+      own.push(k);
+      let set = users.get(k);
+      if (!set) users.set(k, (set = new Set()));
+      set.add(r.edge);
+    }
+    keys.set(r.edge, own);
+  }
+  return { keys, users };
+}
+
+/**
+ * This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
+ * An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
+ * The scale is 0 to 1. A higher value is better only in context. The cost is linear.
+ */
+export function bundledShare(result: Result): number {
+  const routes = result.routes;
+  if (routes.length === 0) return 0;
+  const shared = new Set<string>();
+  for (const run of result.runs ?? []) for (const e of run.edges) shared.add(e);
+  for (const b of result.bundles ?? []) if (b.edges.length > 1) for (const e of b.edges) shared.add(e);
+  const { keys, users } = routeKeys(routes);
+  for (const [edge, own] of keys) if (own.some((k) => (users.get(k)?.size ?? 0) > 1)) shared.add(edge);
+  let count = 0;
+  for (const r of routes) if (shared.has(r.edge)) count++;
+  return count / routes.length;
+}
+
+/** The bundle stretch of the routes against base routes (B3 of MEAS0). */
+export interface BundleStretch {
+  /** The median of `st(e) = L(r_e) / L(r*_e)`. A value of 1 is the length of the base route. Lower is better. */
+  readonly median: number;
+  /** The `0.95` quantile of `st(e)`: the tail of long detours that the bundles add. */
+  readonly q95: number;
+  /** The number of edges with a route in both lists and a base route longer than 1 unit. */
+  readonly edges: number;
+}
+
+/**
+ * This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
+ * The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
+ * The cost is an extra run of the base router, and then linear.
+ */
+export function bundleStretch(routes: readonly Route[], base: readonly Route[]): BundleStretch {
+  const baseLength = new Map<string, number>();
+  for (const r of base) baseLength.set(r.edge, polylineLength(r.points));
+  const st: number[] = [];
+  for (const r of routes) {
+    const b = baseLength.get(r.edge);
+    if (b === undefined || b <= 1 || r.points.length < 2) continue;
+    st.push(polylineLength(r.points) / b);
+  }
+  if (st.length === 0) return { median: 1, q95: 1, edges: 0 };
+  return { median: quantile(st, 0.5), q95: quantile(st, 0.95), edges: st.length };
+}
+
+/**
+ * This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
+ * A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
+ * One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
+ * Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
+ */
+export function mergeAngle(routes: readonly Route[]): number {
+  const { users } = routeKeys(routes);
+  const sig = new Map<string, string>();
+  for (const [k, set] of users) sig.set(k, [...set].sort().join("\u0000"));
+  let max = 0;
+  for (const r of routes) {
+    // The vertices of the route, with each segment that has no key dropped.
+    let prev: { readonly k: string; readonly a: Point; readonly b: Point } | undefined;
+    for (let i = 1; i < r.points.length; i++) {
+      const a = r.points[i - 1]!;
+      const b = r.points[i]!;
+      const k = segmentKey(a, b);
+      if (k === undefined) continue;
+      if (prev && sig.get(prev.k) !== sig.get(k) && ((users.get(prev.k)?.size ?? 0) > 1 || (users.get(k)?.size ?? 0) > 1)) {
+        const ux = prev.b.x - prev.a.x;
+        const uy = prev.b.y - prev.a.y;
+        const vx = b.x - a.x;
+        const vy = b.y - a.y;
+        const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+        max = Math.max(max, (turn * 180) / Math.PI);
+      }
+      prev = { k, a, b };
+    }
+  }
+  return max;
+}

package/src/bench/measures/highways.ts

@@ -0,0 +1,93 @@
+import { follow } from "../../highways/follow.ts";
+import { commonEdges, matchHighways } from "../../highways/gates/model.ts";
+import type { HighwayPlan } from "../../highways/model.ts";
+import { wayOptionsOf } from "../../highways/router.ts";
+import type { Graph } from "../../model.ts";
+import type { Strategy } from "../../strategies/model.ts";
+import { changeGraph, routeStability } from "./stability.ts";
+
+/**
+ * This function gives the churn of the highways over one edit (Z10 for highways, from HWY-046). Two edges are a pair when they share a highway.
+ * The churn is the share of the pairs that come or go: `|P ∆ P'| / |P ∪ P'|`. Only the edges of `edges` count, for example the edges of both graphs.
+ * Two plans without pairs give 0. The scale is 0 to 1, and lower is better.
+ */
+export function highwayChurn(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): number {
+  const pairs = (plan: HighwayPlan): Set<string> => {
+    const out = new Set<string>();
+    for (const h of plan.highways) {
+      const list = [...new Set(h.members.map((m) => m.edge).filter((e) => edges.has(e)))].sort();
+      for (let i = 0; i < list.length; i++) for (let j = i + 1; j < list.length; j++) out.add(`${list[i]}\u0000${list[j]}`);
+    }
+    return out;
+  };
+  const a = pairs(before);
+  const b = pairs(after);
+  let common = 0;
+  for (const p of a) if (b.has(p)) common++;
+  const all = a.size + b.size - common;
+  return all === 0 ? 0 : (all - common) / all;
+}
+
+/** The match of the highways over one edit. */
+export interface HighwayIdKeep {
+  /** The number of new highways with a match in the old plan: a Jaccard index of their edges of 0.5 or more. */
+  readonly matched: number;
+  /** The number of matched highways that keep the id of their match. */
+  readonly kept: number;
+  /** `kept / matched`, or `NaN` without a match. The scale is 0 to 1, and higher is better. */
+  readonly share: number;
+}
+
+/**
+ * This function tells how many highways keep their id over one edit (HWY-054). It matches the new highways with the old ones by `matchHighways`, with the index 0.5.
+ * A matched highway keeps its id when its id is the id of its match. Only the edges of `edges` count.
+ */
+export function highwayIdKeep(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): HighwayIdKeep {
+  const match = matchHighways(before, after, 0.5, edges);
+  let kept = 0;
+  for (const [i, i0] of match) if (after.highways[i]!.id === before.highways[i0]!.id) kept++;
+  return { matched: match.size, kept, share: match.size === 0 ? Number.NaN : kept / match.size };
+}
+
+/** The stability of a highway strategy over a seeded sequence of edits. Each value is the mean over the edits. */
+export interface HighwayEdits {
+  /** The mean Fréchet distance of the routes over one edit, in units of the board (Z10). */
+  readonly mean: number;
+  /** The share of the routes that move over one edit (Z10). */
+  readonly moved: number;
+  /** The churn of the highways over one edit (`highwayChurn`). */
+  readonly churn: number;
+  /** The share of the matched highways that keep their id over one edit (`highwayIdKeep`), or `NaN` without a match. */
+  readonly ids: number;
+}
+
+/**
+ * This function measures a highway strategy over a sequence of `edits` seeded edits. Each edit is the small change of `changeGraph` with the seed `seed + i`.
+ * The strategy gets the graph and its plan before the edit as `previous`, so a strategy with memory can keep its highways.
+ * `follow` routes each plan with the way options of the strategy. The same graph, strategy, options and seed give the same values.
+ */
+export function highwayEdits(graph: Graph, strategy: Strategy<"highway", object>, options: object | undefined, edits: number, seed = 1): HighwayEdits {
+  const way = wayOptionsOf({ ...strategy.defaults, ...options });
+  let g = graph;
+  let plan = strategy.run({ graph: g }, options);
+  let routes = follow(g, plan, way);
+  const mean: number[] = [];
+  const moved: number[] = [];
+  const churn: number[] = [];
+  const ids: number[] = [];
+  for (let i = 0; i < edits; i++) {
+    const next = changeGraph(g, seed + i).graph;
+    const p = strategy.run({ graph: next, previous: { graph: g, plan } }, options);
+    const r = follow(next, p, way);
+    const s = routeStability(g, routes, r, { seed });
+    const edges = commonEdges(g, next);
+    mean.push(s.mean);
+    moved.push(s.moved);
+    churn.push(highwayChurn(plan, p, edges));
+    const keep = highwayIdKeep(plan, p, edges);
+    if (keep.matched > 0) ids.push(keep.share);
+    [g, plan, routes] = [next, p, r];
+  }
+  const avg = (v: readonly number[]): number => (v.length === 0 ? Number.NaN : v.reduce((a, b) => a + b, 0) / v.length);
+  return { mean: avg(mean), moved: avg(moved), churn: avg(churn), ids: avg(ids) };
+}

package/src/bench/measures/index.ts

@@ -7,3 +7,5 @@ export * from "./groups.ts";
 export * from "./stability.ts";
 export * from "./room.ts";
 export * from "./pareto.ts";
+export * from "./order.ts";
+export * from "./highways.ts";

package/src/bench/measures/order.ts

@@ -0,0 +1,97 @@
+import type { Graph, Result, Route } from "../../model.ts";
+import { shuffleEdges } from "../../order/index.ts";
+import { sameData } from "../run.ts";
+import { inkSaved } from "./bundles.ts";
+import { crossingAngles, detourSpread, drawnSegments } from "./routes.ts";
+import { quantile } from "./stats.ts";
+
+/** The order fragility of a router on one graph (W3 of MEAS3, from WILD-056). */
+export interface OrderFragility {
+  /** The number of random orders. */
+  readonly orders: number;
+  /** `IQR / median` of the crossings (R1) over the orders. A value of 0 is a router that the order does not move. */
+  readonly crossings: number;
+  /** `IQR / median` of the median detour (R5) over the orders. */
+  readonly detour: number;
+  /** `IQR / median` of the ink saved (B1) over the orders. */
+  readonly inkSaved: number;
+  /** `IQR / median` of the ink over the orders. */
+  readonly ink: number;
+  /** The share of the orders whose routes differ from the routes of the input order. A value of 0 is a router that is free of the order. */
+  readonly changed: number;
+  /**
+   * The crossings of the input order divided by the fewest crossings over the orders (the price of anarchy of WILD-056).
+   * A value of 1 is a default order as good as the best random order. It is `NaN` when the best order has 0 crossings and the input order has more.
+   */
+  readonly poa: number;
+}
+
+/** The options of `orderFragility`. */
+export interface OrderFragilityOptions {
+  /** The number of random orders of the edges. The default is 20. */
+  readonly orders?: number;
+  /** The seed of the first order. The order `k` has the seed `seed + k`. The default is 1. */
+  readonly seed?: number;
+  /** The result of the input order, when the caller has it. Without it, the function routes the input order one time more. */
+  readonly base?: Result;
+}
+
+/**
+ * This function gives `IQR / median` of the values. Values with a median of 0 give `IQR / mean`, and values that are all 0 give 0.
+ * An IQR below `1e-9` of the median is rounding noise of the sums, so it gives 0.
+ */
+function spread(values: readonly number[]): number {
+  const iqr = quantile(values, 0.75) - quantile(values, 0.25);
+  const mid = Math.abs(quantile(values, 0.5));
+  if (iqr <= 1e-9 * Math.max(1, mid)) return 0;
+  if (mid > 0) return iqr / mid;
+  const mean = values.reduce((s, v) => s + Math.abs(v), 0) / values.length;
+  return mean > 0 ? iqr / mean : 0;
+}
+
+/** This function gives the routes by the id of the edge, in the order of the ids, so two orders of the input compare. */
+function byEdge(routes: readonly Route[]): Route[] {
+  return [...routes].sort((a, b) => (a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : 0));
+}
+
+/**
+ * This function measures the order fragility of a router on one graph (W3, from WILD-056).
+ * It routes the graph with `orders` random orders of the edges.
+ * It gives the spread `IQR / median` of the crossings, the detour, the ink saved and the ink.
+ * It also gives the share of orders that change a route, and the price of anarchy of the crossings.
+ * The cost is `orders` extra runs of the router.
+ */
+export function orderFragility(graph: Graph, route: (graph: Graph) => Result, options: OrderFragilityOptions = {}): OrderFragility {
+  const orders = Math.max(1, Math.floor(options.orders ?? 20));
+  const seed = options.seed ?? 1;
+  const base = options.base ?? route(graph);
+  const baseRoutes = byEdge(base.routes);
+  const crossings: number[] = [];
+  const detour: number[] = [];
+  const saved: number[] = [];
+  const ink: number[] = [];
+  let changed = 0;
+  for (let k = 0; k < orders; k++) {
+    // The measures read the routes in the order of the edge ids, so the order of the output does not move them.
+    const routes = byEdge(route(shuffleEdges(graph, seed + k)).routes);
+    const segs = drawnSegments(routes);
+    crossings.push(crossingAngles(segs).crossings);
+    detour.push(detourSpread(routes).median);
+    saved.push(inkSaved(routes));
+    let length = 0;
+    for (const [a, b] of segs) length += Math.hypot(b.x - a.x, b.y - a.y);
+    ink.push(length);
+    if (!sameData(routes, baseRoutes)) changed++;
+  }
+  const own = crossingAngles(drawnSegments(baseRoutes)).crossings;
+  const best = Math.min(...crossings);
+  return {
+    orders,
+    crossings: spread(crossings),
+    detour: spread(detour),
+    inkSaved: spread(saved),
+    ink: spread(ink),
+    changed: changed / orders,
+    poa: best > 0 ? own / best : own === 0 ? 1 : Number.NaN,
+  };
+}

package/src/bench/room.ts

@@ -2,7 +2,7 @@ import type { Box } from "../geom.ts";
 import { levelLinks } from "../levels.ts";
 import type { Graph, LevelLink, Node, Result, Router } from "../model.ts";
 import { makeRoom, openGaps, roomLinks, type RoomOptions } from "../room/index.ts";
-import { gapLanes, LANE_ORDERS, type LaneOrder } from "../room/lanes.ts";
+import { gapLaneCounts, gapLanes, LANE_ORDERS, LANE_TRACKS, type LaneOrder, type LaneTracks } from "../room/lanes.ts";
 import { levelPairs, levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
 import { buildSections, levelCut, treeDepth, type SectionOptions } from "../sections.ts";
 import { sectionsRouter } from "../routers/sections.ts";
@@ -70,14 +70,7 @@ export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder):
   );
   const drawn = order ? gapLanes(graph.nodes, level, { spacing, order }) : level;
   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 q = farQuality(graph, drawn);
   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)));
@@ -91,6 +84,26 @@ 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[] {
+  const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
+  return levelLinks(
+    items,
+    roomLinks(graph).map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
+  );
+}
+
+/** This function measures the links of the far view with `measureQuality`. Each link stands for the first edge of its pair, because `measureQuality` reads routes of edges. */
+function farQuality(graph: Graph, drawn: readonly LevelLink[]): ReturnType<typeof measureQuality> {
+  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 })) };
+  return measureQuality(graph, asRoutes);
+}
+
 /**
  * This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
  * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
@@ -395,3 +408,107 @@ export function formatBendRoom(rows: readonly BendRoomRow[]): string {
   );
   return [head, line, ...body].join("\n");
 }
+
+/** One row of `benchTracks` (EDA-004): the lanes of the far view of one board with one lane rule of `gapLanes`. */
+export interface TrackBenchRow {
+  readonly fixture: string;
+  /** The board: `given` (the board as it is) or `open` (the board that `makeRoom` opens at gutter 8 and spacing 4). */
+  readonly board: string;
+  readonly tracks: LaneTracks;
+  /** The number of gaps with at least one piece. */
+  readonly gaps: number;
+  /** The sum of the lanes of the gaps. */
+  readonly lanes: number;
+  /** The sum of the densities of the gaps: the most pieces that overlap at one place. No rule gives fewer lanes. */
+  readonly density: number;
+  /** The number of gaps whose lanes are nearer than `spacing`, because the gap is too narrow for its lanes. */
+  readonly squeezed: number;
+  /** 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;
+  /** R12: the length of parallel legs of two links nearer than `spacing`, as a share of the ink. */
+  readonly separation: number;
+  /** The number of links of the far view that go through a box. */
+  readonly through: number;
+}
+
+/**
+ * This function gives R12 (lane separation) of the links. Two legs of two links are near when they are parallel and nearer than `near`.
+ * R12 is the length of the near legs, as a share of the ink.
+ * It reads only the legs on an axis. The links of the far view have no other legs.
+ */
+export function laneSeparation(links: readonly LevelLink[], near: number): number {
+  let ink = 0;
+  let close = 0;
+  for (const across of ["x", "y"] as const) {
+    const along = across === "x" ? "y" : "x";
+    const legs: { link: number; at: number; lo: number; hi: number }[] = [];
+    links.forEach((l, li) => {
+      for (let i = 1; i < l.points.length; i++) {
+        const a = l.points[i - 1]!;
+        const b = l.points[i]!;
+        if (Math.abs(a[across] - b[across]) > 1e-6 || Math.abs(a[along] - b[along]) <= 1e-6) continue;
+        legs.push({ link: li, at: a[across], lo: Math.min(a[along], b[along]), hi: Math.max(a[along], b[along]) });
+      }
+    });
+    legs.sort((p, q) => p.at - q.at);
+    for (let i = 0; i < legs.length; i++) {
+      const P = legs[i]!;
+      ink += P.hi - P.lo;
+      for (let j = i + 1; j < legs.length && legs[j]!.at - P.at < near; j++) {
+        const Q = legs[j]!;
+        if (Q.link !== P.link) close += Math.max(0, Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo));
+      }
+    }
+  }
+  return ink > 0 ? close / ink : 0;
+}
+
+/**
+ * This function measures each lane rule of `gapLanes` (EDA-004) on the board as it is, and on the board that `makeRoom` opens.
+ * The lane order is `crossings` for each rule. The lanes are `spacing` apart where the gap has room.
+ */
+export function benchTracks(fixture: string, graph: Graph, spacing: number = 4, rules: readonly LaneTracks[] = LANE_TRACKS): TrackBenchRow[] {
+  const open = makeRoom(graph.nodes, roomLinks(graph), { gutter: 8, spacing, method: "routes" }).items;
+  const rows: TrackBenchRow[] = [];
+  for (const [board, nodes] of [
+    ["given", graph.nodes],
+    ["open", open],
+  ] as const) {
+    const g: Graph = { nodes, edges: graph.edges };
+    const level = farLinks(g);
+    const boxes = new Map(nodes.map((n) => [n.id, n.box]));
+    for (const tracks of rules) {
+      const options = { spacing, order: "crossings" as const, tracks };
+      const counts = gapLaneCounts(nodes, level, options);
+      const drawn = gapLanes(nodes, level, options);
+      const q = farQuality(g, drawn);
+      rows.push({
+        fixture,
+        board,
+        tracks,
+        gaps: counts.length,
+        lanes: counts.reduce((s, c) => s + c.lanes, 0),
+        density: counts.reduce((s, c) => s + c.density, 0),
+        squeezed: counts.filter((c) => c.width / (c.lanes + 1) < spacing - 1e-9).length,
+        crossings: q.crossings,
+        ink: q.ink,
+        separation: laneSeparation(drawn, spacing),
+        through: measureLinks(boxes, drawn).through,
+      });
+    }
+  }
+  return rows;
+}
+
+/** This function writes the rows of `benchTracks` as a Markdown table. */
+export function formatTracks(rows: readonly TrackBenchRow[]): string {
+  const head = "| fixture | board | tracks | gaps | lanes | density | squeezed | crossings | ink | R12 | through |";
+  const line = "|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map(
+    (r) =>
+      `| ${r.fixture} | ${r.board} | ${r.tracks} | ${r.gaps} | ${r.lanes} | ${r.density} | ${r.squeezed} | ${r.crossings} | ${Math.round(r.ink)} | ${r.separation.toFixed(4)} | ${r.through} |`,
+  );
+  return [head, line, ...body].join("\n");
+}

package/src/bench/screen/measures.ts

@@ -49,6 +49,18 @@ const ROWS: readonly Row[] = [
   // The bundles.
   ["B1.inkSaved", "B1", "route.bundle.ink-saved", "0 to 1", "higher", false],
   ["B4.ambiguity", "B4", "route.bundle.ambiguity", "0 to 1", "lower", false],
+  // B2, B3 and B6 score the shared ways of the routes for a fixed placement, as B1 does. B3 compares with the routes of `corners` on the same input.
+  ["B2.share", "B2", "route.bundle.share", "0 to 1", "higher", false],
+  ["B3.median", "B3", "route.bundle.stretch.median", "ratio", "lower", false],
+  ["B3.q95", "B3", "route.bundle.stretch.q95", "ratio", "lower", false],
+  ["B6.max", "B6", "route.bundle.merge-angle.max", "degrees", "lower", false],
+  // The order fragility (W3 of MEAS3, from WILD-056): the spread of a measure over random orders of the edges. The placement can move it.
+  ["W3.crossings", "W3", "route.order.crossings", "IQR over the median", "lower", true],
+  ["W3.detour", "W3", "route.order.detour", "IQR over the median", "lower", true],
+  ["W3.inkSaved", "W3", "route.order.ink-saved", "IQR over the median", "lower", true],
+  ["W3.ink", "W3", "route.order.ink", "IQR over the median", "lower", true],
+  ["W3.changed", "W3", "route.order.changed", "0 to 1", "lower", true],
+  ["W3.poa", "W3", "route.order.poa", "ratio", "lower", true],
   // The stability after the small change of `changeGraph`, and against the run on the base input of a variant.
   ["Z10.mean", "Z10", "route.stability.mean", "units of the board", "lower", false],
   ["Z10.max", "Z10", "route.stability.max", "units of the board", "lower", false],
@@ -56,6 +68,11 @@ const ROWS: readonly Row[] = [
   ["Z10.base.mean", "Z10", "route.stability.base.mean", "units of the board", "lower", false],
   ["Z10.base.max", "Z10", "route.stability.base.max", "units of the board", "lower", false],
   ["Z10.base.moved", "Z10", "route.stability.base.moved", "0 to 1", "lower", false],
+  // The stability of a highway strategy over a sequence of seeded edits, with its plan before each edit (the screen option `edits`).
+  ["Z10.edits.mean", "Z10", "route.stability.edits.mean", "units of the board", "lower", false],
+  ["Z10.edits.moved", "Z10", "route.stability.edits.moved", "0 to 1", "lower", false],
+  ["Z10.churn", "Z10", "route.stability.highway-churn", "0 to 1", "lower", false],
+  ["Z10.ids", "Z10", "route.stability.highway-ids", "0 to 1", "higher", false],
   // The zoom levels and the groups. The default grouping rule reads the positions, so most of these measures depend on the placement.
   ["level-nesting", "Z6", "route.level.nesting", "count", "lower", false],
   ["Z3.through", "Z3", "route.level.through", "count", "lower", true],