@mark1russell7/highways 0.9.3 → 0.9.5

package/src/whole/portfolio/index.ts

@@ -0,0 +1,108 @@
+import { inkSaved } from "../../bench/measures/bundles.ts";
+import { detourSpread } from "../../bench/measures/routes.ts";
+import { checkProperties } from "../../bench/properties.ts";
+import { measureQuality } from "../../bench/quality.ts";
+import type { Graph, Result } from "../../model.ts";
+import type { WholeOutput } from "../../strategies/model.ts";
+import { runPipeline, type PipelineOptions } from "../pipeline/index.ts";
+
+/** The clock in milliseconds. */
+const clock = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** One setting of the portfolio: a name and the options of the pipeline. */
+export interface PortfolioSetting {
+  readonly name: string;
+  readonly pipeline: PipelineOptions;
+}
+
+/** The options of the whole strategy `board-portfolio` (WILD-045). */
+export interface BoardPortfolioOptions {
+  /** The number of settings that the portfolio tries, from the start of its list, from 3 to 12. The default is 4. */
+  readonly settings: number;
+  /** The weight of the crossings (R1) in the score, from 0 to 4. The default is 1. */
+  readonly crossings: number;
+  /** The weight of the median detour (R5) in the score, from 0 to 4. The default is 1. */
+  readonly detour: number;
+  /** The weight of the ink saved (B1) in the score, from 0 to 4. The default is 1. */
+  readonly ink: number;
+  /**
+   * The time budget in seconds, from 0 to 10. After the budget, no new setting starts. The first setting always runs.
+   * The value 0, the default, sets no budget, so the output does not depend on the speed of the machine.
+   */
+  readonly budget: number;
+}
+
+/** The default options of the strategy `board-portfolio`. */
+export const BOARD_PORTFOLIO_DEFAULTS: Readonly<BoardPortfolioOptions> = Object.freeze({ settings: 4, crossings: 1, detour: 1, ink: 1, budget: 0 });
+
+/** The measures of one setting on the board, and its output. */
+export interface PortfolioEntry {
+  readonly name: string;
+  readonly output: WholeOutput;
+  readonly crossings: number;
+  readonly detour: number;
+  readonly ink: number;
+}
+
+/** The result of `boardPortfolio`: the output and the name of the pick. It also holds the measures of each setting with no break of a hard rule. */
+export interface BoardPortfolioRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly PortfolioEntry[];
+}
+
+/** This function gives the rank of each value from 0 (the best) to 1 (the worst). Equal values get the mean of their ranks. One value gets 0. */
+export function rankShares(values: readonly number[], lowerIsBetter: boolean): number[] {
+  const n = values.length;
+  if (n < 2) return values.map(() => 0);
+  const order = values.map((_, i) => i).sort((a, b) => (lowerIsBetter ? values[a]! - values[b]! : values[b]! - values[a]!));
+  const rank = new Array<number>(n).fill(0);
+  for (let i = 0; i < n; ) {
+    let j = i;
+    while (j + 1 < n && Math.abs(values[order[j + 1]!]! - values[order[i]!]!) <= 1e-9) j++;
+    for (let k = i; k <= j; k++) rank[order[k]!] = (i + j) / 2 / (n - 1);
+    i = j + 1;
+  }
+  return rank;
+}
+
+/**
+ * This function runs the portfolio for one board (WILD-045, after Rice, 1976). It reads only the board and the outputs of its own settings.
+ * A setting whose router or highway strategy has a node limit below the size of the board does not run.
+ * A setting with a break of a hard rule does not count. The score of a setting is `Σ w_i × the rank share of measure_i` over the settings.
+ * The measures are the crossings (R1), the median detour (R5) and the ink saved (B1). The least score wins, and a tie goes to the earlier setting.
+ */
+export function boardPortfolio(graph: Graph, list: readonly PortfolioSetting[], o: Readonly<BoardPortfolioOptions>, now: () => number = clock): BoardPortfolioRun {
+  const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+  const t0 = now();
+  const entries: PortfolioEntry[] = [];
+  let fallback: { name: string; output: WholeOutput } | undefined;
+  for (const s of list.slice(0, count)) {
+    if (o.budget > 0 && fallback !== undefined && now() - t0 > o.budget * 1000) break;
+    const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+    if (limit !== undefined && graph.nodes.length > limit) continue;
+    const output = runPipeline(graph, s.pipeline);
+    fallback ??= { name: s.name, output };
+    if (checkProperties(output.graph, output.result, 1).length > 0) continue;
+    entries.push({ name: s.name, output, ...measuresOf(output.graph, output.result) });
+  }
+  if (entries.length === 0) {
+    const first = fallback ?? { name: list[0]!.name, output: runPipeline(graph, list[0]!.pipeline) };
+    return { output: first.output, pick: first.name, entries };
+  }
+  const r1 = rankShares(entries.map((e) => e.crossings), true);
+  const r5 = rankShares(entries.map((e) => e.detour), true);
+  const b1 = rankShares(entries.map((e) => e.ink), false);
+  let best = 0;
+  let score = Infinity;
+  entries.forEach((_, i) => {
+    const s = o.crossings * r1[i]! + o.detour * r5[i]! + o.ink * b1[i]!;
+    if (s < score - 1e-9) [best, score] = [i, s];
+  });
+  return { output: entries[best]!.output, pick: entries[best]!.name, entries };
+}
+
+/** This function gives the three measures of the score of one output: the crossings, the median detour and the ink saved. */
+function measuresOf(graph: Graph, result: Result): { crossings: number; detour: number; ink: number } {
+  return { crossings: measureQuality(graph, result).crossings, detour: detourSpread(result.routes).median, ink: inkSaved(result.routes) };
+}

package/src/whole/preferences/index.ts

@@ -0,0 +1,247 @@
+import { checkProperties } from "../../bench/properties.ts";
+import { rng } from "../../fixtures.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import type { Graph, Route } from "../../model.ts";
+import { turnsOf } from "../../routers/reroute/index.ts";
+import type { WholeOutput } from "../../strategies/model.ts";
+import { pairCosts } from "../curriculum/index.ts";
+import { runPipeline } from "../pipeline/index.ts";
+import type { PortfolioSetting } from "../portfolio/index.ts";
+
+/** The features of one route, in order: crossings (R1), angle cost (R2), lane overlap (R12) over 20, detour minus 1 (R5), and bends over 2. */
+export const PREFERENCE_FEATURES: readonly string[] = Object.freeze(["R1", "R2", "R12", "R5", "bends"]);
+
+/** The scale of the lane overlap in the features, in units of length. */
+const OVERLAP_SCALE = 20;
+
+/**
+ * The weights of the made-up panel that labels the made-up pairs, in the order of `PREFERENCE_FEATURES`.
+ * The order comes from the studies of the readers of graphs: the crossings count most, then the bends and the length, then the angle (Purchase 1997, Ware, Purchase, Colpoys and McGill 2002).
+ * The numbers are made up. They do not come from the screen or from a board.
+ */
+export const PREFERENCE_PANEL: readonly number[] = Object.freeze([3, 0.75, 0.5, 1.5, 1]);
+
+/** The options of the fit of the preferences. */
+export interface PreferenceFit {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The seed of the made-up pairs. The default is 1. */
+  readonly seed: number;
+  /** The number of made-up pairs, from 50 to 1000. The default is 200. */
+  readonly pairs: number;
+}
+
+/** The options of the whole strategy `preferences` (RULE-038). */
+export interface PreferenceOptions {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The number of passes over the edges, from 1 to 3. The default is 1. */
+  readonly passes: number;
+  /** The number of settings in the pool of routes, from the start of its list, from 2 to 3. The default is 3. */
+  readonly settings: number;
+  /** A new route has a detour of at most this value, or of its old route, from 1.5 to 4. The default is 2. */
+  readonly detour: number;
+}
+
+/** The default options of the strategy `preferences`. */
+export const PREFERENCE_DEFAULTS: Readonly<PreferenceOptions> = Object.freeze({ l2: 0.01, passes: 1, settings: 3, detour: 2 });
+
+/** One made-up pair: the features of two routes, and 1 when the panel prefers the first one. */
+export interface PreferencePair {
+  readonly a: readonly number[];
+  readonly b: readonly number[];
+  readonly first: 0 | 1;
+}
+
+/** The result of the fit: the weights, the agreement with held-out pairs, and the source of the pairs. */
+export interface PreferenceModel {
+  readonly weights: readonly number[];
+  /** The share of 50 held-out made-up pairs where the weights agree with the panel. */
+  readonly agreement: number;
+  readonly source: string;
+}
+
+/**
+ * This function gives a smooth step from 0 to 1, a stand-in for the logistic function with only `+`, `*`, `/` and `Math.abs`.
+ * It is `0.5 + 0.5 z / (1 + |z|)`. These operations are exact to the last bit on each platform.
+ */
+export function softStep(z: number): number {
+  return 0.5 + (0.5 * z) / (1 + Math.abs(z));
+}
+
+/** This function gives a made-up feature vector of one route. */
+function madeUpFeatures(random: () => number): number[] {
+  return [Math.floor(random() * 5), random() * 2, random() * 2, random(), Math.floor(random() * 7) / 2];
+}
+
+/** This function gives a noise with a mean of 0 and a spread of approximately 0.6: the sum of three uniform values. */
+function noise(random: () => number): number {
+  return (random() + random() + random() - 1.5) * 1.2;
+}
+
+/** This function gives the utility of a feature vector for the weights `w`. A larger utility is better. */
+function utility(w: readonly number[], f: readonly number[]): number {
+  let u = 0;
+  for (let i = 0; i < f.length; i++) u -= w[i]! * f[i]!;
+  return u;
+}
+
+/**
+ * This function gives `count` made-up pairs, with the labels of the made-up panel `PREFERENCE_PANEL` and a noise.
+ * The pairs come from the seed alone. They do not come from a board.
+ */
+export function madeUpPairs(count: number, seed: number): PreferencePair[] {
+  const random = rng(seed);
+  const out: PreferencePair[] = [];
+  for (let i = 0; i < count; i++) {
+    const a = madeUpFeatures(random);
+    const b = madeUpFeatures(random);
+    out.push({ a, b, first: utility(PREFERENCE_PANEL, a) - utility(PREFERENCE_PANEL, b) + noise(random) > 0 ? 1 : 0 });
+  }
+  return out;
+}
+
+/** This function gives the share of the pairs where the weights `w` prefer the same route as the panel. */
+export function agreementOf(w: readonly number[], pairs: readonly PreferencePair[]): number {
+  if (pairs.length === 0) return 0;
+  let n = 0;
+  for (const p of pairs) if ((utility(w, p.a) > utility(w, p.b) ? 1 : 0) === p.first) n++;
+  return n / pairs.length;
+}
+
+/** The fits of earlier calls, by their options. */
+const FITS = new Map<string, PreferenceModel>();
+
+/**
+ * This function fits the weights of the rules to made-up pairs (RULE-038, a Bradley-Terry model, after Bradley and Terry 1952).
+ * The probability that a reader prefers `a` to `b` is `softStep(u(a) - u(b))`, with `u(x) = -w · f(x)`. The fit takes 400 steps of the gradient of the score.
+ * An L2 term `l2 × |w|²` keeps the weights small. A weight below 0 becomes 0. The weights are scaled so that their sum is the number of features.
+ * The held-out pairs come from the seed plus 7919. The pairs do not come from the screen or from a board.
+ */
+export function fitPreferences(options: Partial<PreferenceFit> = {}): PreferenceModel {
+  const o = { l2: 0.01, seed: 1, pairs: 200, ...options };
+  const key = JSON.stringify(o);
+  const known = FITS.get(key);
+  if (known) return known;
+  const pairs = madeUpPairs(Math.max(1, Math.floor(o.pairs)), o.seed);
+  const n = PREFERENCE_FEATURES.length;
+  const w = new Array<number>(n).fill(1);
+  const rate = 0.5;
+  for (let step = 0; step < 400; step++) {
+    const grad = new Array<number>(n).fill(0);
+    for (const p of pairs) {
+      const d = p.b.map((v, i) => v - p.a[i]!);
+      let z = 0;
+      for (let i = 0; i < n; i++) z += w[i]! * d[i]!;
+      const e = softStep(z) - p.first;
+      for (let i = 0; i < n; i++) grad[i]! += (e * d[i]!) / pairs.length;
+    }
+    for (let i = 0; i < n; i++) w[i] = Math.max(0, w[i]! - rate * (grad[i]! + 2 * o.l2 * w[i]!));
+  }
+  const sum = w.reduce((s, v) => s + v, 0);
+  const weights = sum > 1e-12 ? w.map((v) => (v * n) / sum) : w.map(() => 1);
+  const model: PreferenceModel = {
+    weights,
+    agreement: agreementOf(weights, madeUpPairs(50, o.seed + 7919)),
+    source: `${Math.floor(o.pairs)} made-up pairs of seed ${o.seed}, labelled by the made-up panel PREFERENCE_PANEL with a noise`,
+  };
+  FITS.set(key, model);
+  return model;
+}
+
+/** A route with its bounding box, for the quick test of two routes. */
+interface Shape {
+  readonly route: Route;
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  /** The weighted cost of the route alone: its detour and its bends. */
+  readonly own: number;
+}
+
+/** This function gives the detour of a route: its length over the distance between its ends. */
+function detourOf(points: readonly Point[]): number {
+  const span = dist(points[0]!, points[points.length - 1]!);
+  return span > 1e-9 ? polylineLength(points) / span : 1;
+}
+
+/**
+ * This function runs the whole strategy `preferences` (RULE-038). It fits the weights of the rules to made-up pairs (`fitPreferences`).
+ * Each edge can take its route from any setting of the pool. The first answer is the first setting.
+ * A pass visits the edges in order. An edge takes the route of the pool with the least weighted cost, when that cost is lower than the cost of its route.
+ * The cost is the weighted sum of the features of the route against the routes of the other edges. A route with a break of a hard rule is not in the pool.
+ * The output has the routes alone, with no runs, bundles or levels.
+ */
+export function preferences(graph: Graph, list: readonly PortfolioSetting[], options: Partial<PreferenceOptions> = {}): WholeOutput {
+  const o = { ...PREFERENCE_DEFAULTS, ...options };
+  const w = fitPreferences({ l2: o.l2 }).weights;
+  const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+  const pool = new Map<string, Route[]>();
+  let first: WholeOutput | undefined;
+  for (const s of list.slice(0, count)) {
+    const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+    if (limit !== undefined && graph.nodes.length > limit) continue;
+    const output = runPipeline(graph, s.pipeline);
+    first ??= output;
+    const faulty = new Set(checkProperties(output.graph, output.result, 1_000_000).map((v) => v.edge));
+    for (const r of output.result.routes) {
+      if (faulty.has(r.edge) || r.points.length < 2) continue;
+      const own = pool.get(r.edge);
+      if (own) own.push(r);
+      else pool.set(r.edge, [r]);
+    }
+  }
+  if (!first) return runPipeline(graph, list[0]!.pipeline);
+  const shapeOf = (route: Route): Shape => {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const p of route.points) {
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+    return { route, x0, y0, x1, y1, own: w[3]! * (detourOf(route.points) - 1) + (w[4]! * turnsOf(route.points)) / 2 };
+  };
+  const current = new Map<string, Shape>(first.result.routes.map((r) => [r.edge, shapeOf(r)]));
+  for (const [edge, shape] of current) {
+    const own = pool.get(edge);
+    if (own && !own.includes(shape.route)) current.set(edge, shapeOf(own[0]!));
+  }
+  const near = 4;
+  const costOf = (edge: string, s: Shape): number => {
+    let sum = s.own;
+    for (const [other, t] of current) {
+      if (other === edge || t.x0 > s.x1 + near || t.x1 < s.x0 - near || t.y0 > s.y1 + near || t.y1 < s.y0 - near) continue;
+      const c = pairCosts(s.route.points, t.route.points);
+      sum += w[0]! * c.R1 + w[1]! * c.R2 + (w[2]! * c.R12) / OVERLAP_SCALE;
+    }
+    return sum;
+  };
+  const edges = [...current.keys()];
+  for (let pass = 0; pass < Math.max(1, Math.floor(o.passes)); pass++) {
+    let moved = 0;
+    for (const edge of edges) {
+      const now = current.get(edge)!;
+      const base = costOf(edge, now);
+      const cap = Math.max(o.detour, detourOf(now.route.points));
+      let best: { shape: Shape; cost: number } | undefined;
+      for (const r of pool.get(edge) ?? []) {
+        if (r === now.route || detourOf(r.points) > cap + 1e-9) continue;
+        const shape = shapeOf(r);
+        const c = costOf(edge, shape);
+        if (c < (best?.cost ?? base) - 1e-9) best = { shape, cost: c };
+      }
+      if (best) {
+        current.set(edge, best.shape);
+        moved++;
+      }
+    }
+    if (moved === 0) break;
+  }
+  const routes = first.result.routes.map((r) => current.get(r.edge)?.route ?? r);
+  return { graph: first.graph, result: { routes } };
+}

package/src/whole/tracing/index.ts

@@ -0,0 +1,144 @@
+import { checkProperties } from "../../bench/properties.ts";
+import { segmentsCross, type Point } from "../../geom.ts";
+import type { Graph, Result } from "../../model.ts";
+import { turnsOf } from "../../routers/reroute/index.ts";
+import type { WholeOutput } from "../../strategies/model.ts";
+import { runPipeline } from "../pipeline/index.ts";
+import type { PortfolioSetting } from "../portfolio/index.ts";
+
+/** The value of the loads of the edges of a board that the pick reads: the median, the quantile 0.95 or the mean. */
+export type TracingQuantile = "q50" | "q95" | "mean";
+
+/** The values of `TracingQuantile`. */
+export const TRACING_QUANTILES: readonly TracingQuantile[] = Object.freeze(["q50", "q95", "mean"]);
+
+/** The weights of the places to choose on the way of one edge (WILD-057). */
+export interface TracingWeights {
+  /** The weight of a crossing, from 0 to 4. The default is 1. */
+  readonly crossing: number;
+  /** The weight of a merge or a split where the edge is not an outer lane, from 0 to 4. The default is 2. */
+  readonly merge: number;
+  /** The weight of a bend, from 0 to 4. The default is 0.5. */
+  readonly bend: number;
+}
+
+/** The default weights of the tracing load, as the record gives them. */
+export const TRACING_WEIGHTS: Readonly<TracingWeights> = Object.freeze({ crossing: 1, merge: 2, bend: 0.5 });
+
+/** The options of the whole strategy `tracing` (WILD-057). */
+export interface TracingOptions extends TracingWeights {
+  /** The number of settings that the strategy tries, from the start of its list, from 1 to 12. The default is 4. */
+  readonly settings: number;
+  /** The value of the loads that the pick reads. The default is `q95`. */
+  readonly quantile: TracingQuantile;
+}
+
+/** The default options of the strategy `tracing`. */
+export const TRACING_DEFAULTS: Readonly<TracingOptions> = Object.freeze({ ...TRACING_WEIGHTS, settings: 4, quantile: "q95" });
+
+/** The bounds of a polyline: the least x and y, and the largest x and y. */
+function boundsOf(p: readonly Point[]): [number, number, number, number] {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const q of p) {
+    x0 = Math.min(x0, q.x);
+    y0 = Math.min(y0, q.y);
+    x1 = Math.max(x1, q.x);
+    y1 = Math.max(y1, q.y);
+  }
+  return [x0, y0, x1, y1];
+}
+
+/**
+ * This function gives the tracing load of each edge of a result (WILD-057, after the tracing tasks of Ware, Purchase, Colpoys and McGill 2002).
+ * The load is `T(e) = crossing × crossings + merge × (merges and splits where e is not an outer lane) + bend × bends`.
+ * A shared run where the edge is not an outer lane gives one merge and one split. Such a bundle gives one split.
+ * A bend is a turn of more than 1 degree. The measure is W4 of MEAS3.
+ */
+export function tracingLoads(result: Result, weights: Partial<TracingWeights> = {}): Map<string, number> {
+  const w = { ...TRACING_WEIGHTS, ...weights };
+  const routes = result.routes;
+  const bounds = routes.map((r) => boundsOf(r.points));
+  const crossings = new Array<number>(routes.length).fill(0);
+  for (let i = 0; i < routes.length; i++) {
+    const a = routes[i]!.points;
+    const [ax0, ay0, ax1, ay1] = bounds[i]!;
+    for (let j = i + 1; j < routes.length; j++) {
+      const [bx0, by0, bx1, by1] = bounds[j]!;
+      if (bx0 > ax1 || bx1 < ax0 || by0 > ay1 || by1 < ay0) continue;
+      const b = routes[j]!.points;
+      let n = 0;
+      for (let p = 1; p < a.length; p++) for (let q = 1; q < b.length; q++) if (segmentsCross(a[p - 1]!, a[p]!, b[q - 1]!, b[q]!)) n++;
+      crossings[i]! += n;
+      crossings[j]! += n;
+    }
+  }
+  const choices = new Map<string, number>();
+  const inner = (edges: readonly string[], add: number): void => {
+    if (edges.length < 3) return;
+    for (const e of edges.slice(1, -1)) choices.set(e, (choices.get(e) ?? 0) + add);
+  };
+  for (const run of result.runs ?? []) inner(run.edges, 2);
+  for (const b of result.bundles ?? []) inner(b.edges, 1);
+  const out = new Map<string, number>();
+  routes.forEach((r, i) => out.set(r.edge, w.crossing * crossings[i]! + w.merge * (choices.get(r.edge) ?? 0) + w.bend * turnsOf(r.points)));
+  return out;
+}
+
+/** This function gives a value of a list of loads: the median, the quantile 0.95 by the nearest rank, or the mean. An empty list gives 0. */
+export function tracingValue(loads: Iterable<number>, quantile: TracingQuantile): number {
+  const list = [...loads].sort((a, b) => a - b);
+  if (list.length === 0) return 0;
+  if (quantile === "mean") return list.reduce((s, v) => s + v, 0) / list.length;
+  const q = quantile === "q50" ? 0.5 : 0.95;
+  return list[Math.min(list.length - 1, Math.max(0, Math.ceil(q * list.length) - 1))]!;
+}
+
+/** The tracing loads of one setting on the board: the value that the pick reads, and the median for a tie. */
+export interface TracingEntry {
+  readonly name: string;
+  readonly value: number;
+  readonly median: number;
+}
+
+/** The result of `tracing`: the output, the name of the pick and the loads of each setting with no break of a hard rule. */
+export interface TracingRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly TracingEntry[];
+}
+
+/**
+ * This function runs the whole strategy `tracing` (WILD-057). It runs the first `settings` settings of `list` on the board.
+ * A setting with a break of a hard rule, or above its node limit, does not count. The setting with the least tracing load wins.
+ * A tie goes to the least median load, then to the earlier setting. It reads only the board and the outputs of its own settings.
+ */
+export function tracing(graph: Graph, list: readonly PortfolioSetting[], options: Partial<TracingOptions> = {}): TracingRun {
+  const o = { ...TRACING_DEFAULTS, ...options };
+  const count = Math.max(1, Math.min(list.length, Math.floor(o.settings)));
+  const entries: TracingEntry[] = [];
+  const outputs: WholeOutput[] = [];
+  let fallback: { name: string; output: WholeOutput } | undefined;
+  for (const s of list.slice(0, count)) {
+    const limit = (s.pipeline.highway ?? s.pipeline.router).maxNodes;
+    if (limit !== undefined && graph.nodes.length > limit) continue;
+    const output = runPipeline(graph, s.pipeline);
+    fallback ??= { name: s.name, output };
+    if (checkProperties(output.graph, output.result, 1).length > 0) continue;
+    const loads = [...tracingLoads(output.result, o).values()];
+    entries.push({ name: s.name, value: tracingValue(loads, o.quantile), median: tracingValue(loads, "q50") });
+    outputs.push(output);
+  }
+  if (entries.length === 0) {
+    const first = fallback ?? { name: list[0]!.name, output: runPipeline(graph, list[0]!.pipeline) };
+    return { output: first.output, pick: first.name, entries };
+  }
+  let best = 0;
+  entries.forEach((e, i) => {
+    const b = entries[best]!;
+    if (e.value < b.value - 1e-9 || (Math.abs(e.value - b.value) <= 1e-9 && e.median < b.median - 1e-9)) best = i;
+  });
+  return { output: outputs[best]!, pick: entries[best]!.name, entries };
+}