@mark1russell7/highways 0.5.1 → 0.7.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mark1russell7/layout-contract": "^0.2.6"
+    "@mark1russell7/layout-contract": "^0.2.8"
   },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",

package/src/bench/exact/index.ts

@@ -219,33 +219,179 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
   return { lp, columns: binaries.length, rows: rows.length, edges: arcsOf.length, lengths, decode };
 }
 
+/** A binary heap of node indexes by a key, smallest first. A node can be in the heap more than one time. The search skips an old entry. */
+class NodeHeap {
+  #key: Float64Array = new Float64Array(64);
+  #node: Int32Array = new Int32Array(64);
+  size = 0;
+
+  push(key: number, node: number): void {
+    if (this.size === this.#key.length) {
+      const k = new Float64Array(2 * this.size);
+      k.set(this.#key);
+      this.#key = k;
+      const n = new Int32Array(2 * this.size);
+      n.set(this.#node);
+      this.#node = n;
+    }
+    const keys = this.#key;
+    const nodes = this.#node;
+    let i = this.size++;
+    while (i > 0) {
+      const up = (i - 1) >> 1;
+      if (keys[up]! <= key) break;
+      keys[i] = keys[up]!;
+      nodes[i] = nodes[up]!;
+      i = up;
+    }
+    keys[i] = key;
+    nodes[i] = node;
+  }
+
+  /** This method removes the node with the smallest key, and gives it. */
+  pop(): number {
+    const keys = this.#key;
+    const nodes = this.#node;
+    const top = nodes[0]!;
+    const n = --this.size;
+    const key = keys[n]!;
+    const node = nodes[n]!;
+    let i = 0;
+    for (;;) {
+      let c = 2 * i + 1;
+      if (c >= n) break;
+      if (c + 1 < n && keys[c + 1]! < keys[c]!) c++;
+      if (keys[c]! >= key) break;
+      keys[i] = keys[c]!;
+      nodes[i] = nodes[c]!;
+      i = c;
+    }
+    keys[i] = key;
+    nodes[i] = node;
+    return top;
+  }
+}
+
 /**
- * This function gives the stretch of each route as the exact model counts it, by the edge id.
- * The stretch of a route is its length without its two plug ends, divided by the shortest way in the network of the model.
- * The function builds the network one time. The result function then measures each list of routes of the graph, so a portfolio pays for the network once.
- * An edge without a route or without a way in the network has no value.
+ * This function gives the shortest distance from `start` to each node of `targets` (A*). The search stops when it has each target.
+ * The guide is the straight distance to the nearest target. Each link is a straight line, so the guide is not above the true distance at any time.
+ * Thus the distances are the distances of Dijkstra. Only the order of the search changes.
+ * A target that the search cannot reach gets `Infinity`.
  */
-export function exactStretches(graph: Graph, o: Readonly<WayOptions> = {}): (routes: readonly Route[]) => Map<string, number> {
-  const { adj, ends, margin } = exactNetwork(graph, o);
-  const best = new Map<number, Float64Array>();
-  const from = (a: number): Float64Array => {
-    if (!best.has(a)) best.set(a, distances(adj, a));
-    return best.get(a)!;
+function distancesTo(points: readonly Point[], adj: readonly (readonly { to: number; len: number }[])[], start: number, targets: readonly number[]): Map<number, number> {
+  const d = new Float64Array(adj.length).fill(Infinity);
+  const done = new Uint8Array(adj.length);
+  const goal = new Set(targets);
+  const ends = targets.map((t) => points[t]!);
+  const guide = (v: number): number => {
+    let h = Infinity;
+    for (const t of ends) h = Math.min(h, dist(points[v]!, t));
+    return h;
   };
+  const heap = new NodeHeap();
+  d[start] = 0;
+  heap.push(guide(start), start);
+  let left = goal.size;
+  while (heap.size > 0 && left > 0) {
+    const u = heap.pop();
+    if (done[u]) continue;
+    done[u] = 1;
+    if (goal.has(u)) left--;
+    for (const { to, len } of adj[u]!) {
+      const nd = d[u]! + len;
+      if (nd < d[to]!) {
+        d[to] = nd;
+        // A rounding error can make the guide a little too large. Then a node opens again, so its distance stays the least.
+        done[to] = 0;
+        heap.push(nd + guide(to), to);
+      }
+    }
+  }
+  return new Map(targets.map((t) => [t, d[t]!]));
+}
+
+/**
+ * This function gives the shortest distance in the network between the two end points of each edge, by the pair `a,b` of the end points.
+ * The distance does not depend on the direction, so one search serves each edge between the same two points.
+ * An end point of many edges starts one search to all its other end points. The function starts the searches from the end points with the most edges first.
+ */
+function pairDistances(network: ExactNetwork): Map<string, number> {
+  const pairKey = (a: number, b: number): string => (a < b ? `${a},${b}` : `${b},${a}`);
+  const partners = new Map<number, Set<number>>();
+  const open = new Set<string>();
+  for (const e of network.ends) {
+    if (e.a === e.b) continue;
+    const k = pairKey(e.a, e.b);
+    if (open.has(k)) continue;
+    open.add(k);
+    for (const [u, v] of [
+      [e.a, e.b],
+      [e.b, e.a],
+    ] as const) {
+      if (!partners.has(u)) partners.set(u, new Set());
+      partners.get(u)!.add(v);
+    }
+  }
+  const out = new Map<string, number>();
+  const order = [...partners.keys()].sort((u, v) => partners.get(v)!.size - partners.get(u)!.size || u - v);
+  for (const u of order) {
+    const targets = [...partners.get(u)!].filter((v) => open.has(pairKey(u, v)));
+    if (targets.length === 0) continue;
+    for (const [v, len] of distancesTo(network.points, network.adj, u, targets)) {
+      const k = pairKey(u, v);
+      out.set(k, len);
+      open.delete(k);
+    }
+  }
+  return out;
+}
+
+/** This function gives the function of the stretch of each route of the graph, from the network and the shortest distance of each edge. */
+function stretchesOf(network: ExactNetwork, best: (e: ExactNetwork["ends"][number]) => number): (routes: readonly Route[]) => Map<string, number> {
   return (routes) => {
     const byEdge = new Map(routes.map((r) => [r.edge, r]));
     const out = new Map<string, number>();
-    for (const e of ends) {
+    for (const e of network.ends) {
       const r = byEdge.get(e.edge.id);
       if (!r || r.points.length < 2 || e.a === e.b) continue;
-      const b = from(e.a)[e.b]!;
+      const b = best(e);
       if (!Number.isFinite(b) || b <= 1) continue;
-      out.set(e.edge.id, (polylineLength(r.points) - 2 * margin) / b);
+      out.set(e.edge.id, (polylineLength(r.points) - 2 * network.margin) / b);
     }
     return out;
   };
 }
 
+/**
+ * This function gives the stretch of each route as the exact model counts it, by the edge id.
+ * The stretch of a route is its length without its two plug ends, divided by the shortest way in the network of the model.
+ * The function builds the network one time. The result function then measures each list of routes of the graph, so a portfolio pays for the network once.
+ * The first call finds the shortest ways with one A* search for each end point with edges (PORTFOLIO-SPEED). The later calls use them again.
+ * An edge without a route or without a way in the network has no value.
+ */
+export function exactStretches(graph: Graph, o: Readonly<WayOptions> = {}): (routes: readonly Route[]) => Map<string, number> {
+  const network = exactNetwork(graph, o);
+  let best: Map<string, number> | undefined;
+  return stretchesOf(network, (e) => {
+    best ??= pairDistances(network);
+    return best.get(e.a < e.b ? `${e.a},${e.b}` : `${e.b},${e.a}`) ?? Infinity;
+  });
+}
+
+/**
+ * This function gives the same values as `exactStretches` with the search of the first version. That search is one full Dijkstra with a scan, from the first end point of each edge.
+ * It is slow on large boards. The tests and the check `portfolio:time --check-stretch` compare the two functions.
+ */
+export function exactStretchesReference(graph: Graph, o: Readonly<WayOptions> = {}): (routes: readonly Route[]) => Map<string, number> {
+  const network = exactNetwork(graph, o);
+  const best = new Map<number, Float64Array>();
+  const from = (a: number): Float64Array => {
+    if (!best.has(a)) best.set(a, distances(network.adj, a));
+    return best.get(a)!;
+  };
+  return stretchesOf(network, (e) => from(e.a)[e.b]!);
+}
+
 /**
  * This function gives the largest stretch of routes as the exact model counts it (`exactStretches`).
  * The cap of the model is a limit on this value.

package/src/bench/screen/portfolio-pick.ts

@@ -1,5 +1,6 @@
 // The portfolio combinator (PORTFOLIO-API): `portfolio`, `selectBest` and `pickMoves` come from `@mark1russell7/layout-contract` 0.2.6 (PORTFOLIO-FIT).
-// The rules of the pick, the time limit and the trace are in `docs/PORTFOLIO.md` of the contract.
+// The option `hashes` of `PortfolioOptions` comes from the contract 0.2.8 (HASH-LAZY).
+// The rules of the pick, the time limit, the hashes and the trace are in `docs/PORTFOLIO.md` of the contract.
 export {
   pickMoves,
   portfolio,

package/src/index.ts

@@ -29,6 +29,8 @@ export * from "./bench/suite.ts";
 export * from "./strategies/index.ts";
 export * from "./bench/compare.ts";
 export * from "./bench/screen/index.ts";
+// The stretch of the exact model, for a benchmark that compares routers with the measures of the portfolio (PORTFOLIO-SPEED).
+export { exactStretch, exactStretches } from "./bench/exact/index.ts";
 export * from "./highways/index.ts";
 export * from "./order/index.ts";
 export * from "./repair/index.ts";

package/src/portfolio/bands.ts

@@ -20,11 +20,16 @@ export interface PortfolioBand {
   readonly maxNodes: number;
 }
 
-/** The size bands: up to 12 nodes, 13 to 24 nodes, and 25 to 40 nodes. An input above 40 nodes uses the band `n25-40`. */
+/**
+ * The size bands: up to 12 nodes, 13 to 24 nodes, 25 to 40 nodes, 41 to 64 nodes and 65 to 128 nodes. An input above 128 nodes uses the band `n65-128`.
+ * The two large bands come from PORTFOLIO-SPEED. Their boards have no optima, so their sets come from the B1 under the guard.
+ */
 export const PORTFOLIO_BANDS: readonly PortfolioBand[] = [
   { id: "n1-12", maxNodes: 12 },
   { id: "n13-24", maxNodes: 24 },
   { id: "n25-40", maxNodes: 40 },
+  { id: "n41-64", maxNodes: 64 },
+  { id: "n65-128", maxNodes: 128 },
 ];
 
 /** This function gives the band of a node count: the first band whose `maxNodes` is the count or more, else the last band. */

package/src/portfolio/fit.ts

@@ -1,29 +1,41 @@
 // This file is generated by `scripts/portfolio-sets.ts` (`pnpm portfolio:sets`). Do not edit it. The test `sets.test.ts` checks that it is current.
-// The times come from the CI run 40658558076 (the workflow `Portfolio`, `portfolio:time --members`).
+// The times come from the CI run 40681241949 (the workflow `Portfolio`, `portfolio:time --members`).
 import type { PortfolioCap, PortfolioRule } from "./bands.ts";
 
 /**
  * The fit of each rule, cap and size band, by the key `<rule>|<cap>|<band>`: the members of the default of the portfolio router, in their order.
- * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 40 ms.
+ * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 45 ms.
  * The base `shared` is not in a fit: the portfolio always runs it first.
  */
 export const PORTFOLIO_FIT: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly (readonly [string, number])[]>> = {
   "collection|1.1|n1-12": [["corners-side", 12], ["w2c:select+stretch", 12], ["trunks-gilbert-a05", 12], ["w3a:spiral-a15", 12], ["trunks-tree-bf08", 12], ["hw:zipper", 12], ["w2c:level-links+stretch-b1.1", 12], ["hw:stubs", 12]],
-  "collection|1.1|n13-24": [["w3e:crossbars+stretch", 24], ["corners-side", 24], ["shared-p2", 24], ["w2c:zipper+stretch-b1.1", 18], ["trunks-tree-bf08", 18], ["hw:weiszfeld", 18]],
-  "collection|1.1|n25-40": [["w2a:shared-ways+breakeven", 32], ["w2b:weiszfeld-a1", 32]],
+  "collection|1.1|n13-24": [["w3e:crossbars+stretch", 24], ["trunks-tree-bf08", 24], ["corners-side", 24], ["shared-p2", 24], ["w2c:zipper+stretch-b1.1", 18], ["hw:weiszfeld", 18], ["trunks-gilbert-a07", 18]],
+  "collection|1.1|n25-40": [["w2a:shared-ways+breakeven", 40], ["w2b:weiszfeld-a1", 40]],
+  "collection|1.1|n41-64": [],
+  "collection|1.1|n65-128": [],
   "collection|1.25|n1-12": [["corners-side", 12], ["trunks-tree-bf06", 12], ["w3f:p-hub-a0.2", 12], ["hw:stubs", 12], ["hw:p-hub", 12], ["hw:spiral", 12], ["w2c:level-links+stretch", 12], ["w3f:spectral-c0.3", 12]],
-  "collection|1.25|n13-24": [["w2a:shared-ways+stretch", 24], ["shared-p3", 24], ["trunks-gilbert-a07", 24], ["w3e:crossbars+stretch", 24], ["trunks-tree-bf06", 18], ["w3c:hdbscan+stretch", 18], ["shared-wind-p2-r1-e2", 18], ["hw:stubs", 18]],
-  "collection|1.25|n25-40": [["w2a:shared-ways+stretch", 32], ["shared-p3", 32], ["shared-order-shortest", 32]],
+  "collection|1.25|n13-24": [["w2a:shared-ways+stretch", 24], ["shared-p3", 24], ["trunks-gilbert-a07", 24], ["w3e:crossbars+stretch", 24], ["trunks-tree-bf06", 24], ["w3c:hdbscan+stretch", 18], ["shared-wind-p2-r1-e2", 18], ["hw:stubs", 18]],
+  "collection|1.25|n25-40": [["w2a:shared-ways+stretch", 40], ["shared-p3", 40], ["shared-order-shortest", 40], ["w2b:weiszfeld-a1", 32]],
+  "collection|1.25|n41-64": [],
+  "collection|1.25|n65-128": [],
   "collection|1.5|n1-12": [["trunks-gilbert-a03", 12], ["w3e:areas-keys", 12], ["trunks-tree-bf02", 12], ["w3f:p-hub-a0.2", 12], ["w2b:zipper-a1", 12], ["w3a:spiral-a35", 12], ["w3f:spectral-c0.3", 12], ["w2c:level-links+stretch", 12]],
-  "collection|1.5|n13-24": [["shared-wind-p2-r0.5", 24], ["trunks-gilbert-a03", 24], ["w3e:crossbars+stretch", 24], ["shared-wind-p2-r1-e2", 24], ["trunks-tree-bf06", 24], ["shared-flow-a06-p3", 18], ["shared-wind-p3-r1", 18], ["trunks-gilbert-a07", 18]],
-  "collection|1.5|n25-40": [["shared-p3", 40], ["hw:lanes", 32], ["shared-wind-p2-r1-e2", 32]],
-  "all|1.1|n1-12": [["w2b:zipper-p2", 12], ["hw:cubu", 12], ["w3d:kdeeb+stretch", 12], ["w3c:hough-wide", 12], ["w3d:kdeeb-routes", 12], ["hw:stubs", 12], ["hw:spiral", 12], ["w3b:growth-s0.7", 12]],
-  "all|1.1|n13-24": [["w3e:frechet-e0.5", 24], ["w3a:diffusion-wide", 24], ["w2c:zipper+stretch-b1.1", 24], ["w3d:cubu+stretch", 18]],
-  "all|1.1|n25-40": [["w2c:zipper+stretch-b1.1", 32], ["w3a:spiral-a15", 32]],
-  "all|1.25|n1-12": [["w3d:kdeeb-routes", 12], ["w3e:mlseb+stretch", 12], ["hw:growth", 12], ["hw:level-links", 12], ["w3b:growth-input", 12], ["w3e:confluent+stretch", 12], ["w3d:kdeeb-nomask", 10], ["w3a:diffusion-g2", 10]],
-  "all|1.25|n13-24": [["w3d:kdeeb-routes", 24], ["w3e:mlseb+stretch", 18]],
+  "collection|1.5|n13-24": [["shared-wind-p2-r0.5", 24], ["trunks-gilbert-a03", 24], ["w3e:crossbars+stretch", 24], ["shared-wind-p2-r1-e2", 24], ["trunks-tree-bf06", 24], ["shared-flow-a06-p3", 24], ["shared-wind-p3-r1", 24], ["trunks-gilbert-a07", 24]],
+  "collection|1.5|n25-40": [["shared-p3", 40], ["hw:lanes", 40], ["shared-wind-p2-r1-e2", 40], ["hw:crossbars", 32]],
+  "collection|1.5|n41-64": [["shared-flow-a06-p3", 64]],
+  "collection|1.5|n65-128": [],
+  "all|1.1|n1-12": [["w2b:zipper-p2", 12], ["hw:cubu", 12], ["w3d:kdeeb+stretch", 12], ["w3c:hough-wide", 12], ["w3d:kdeeb-routes", 12], ["hw:stubs", 12], ["hw:spiral", 12], ["w3b:growth-s0.7", 10]],
+  "all|1.1|n13-24": [["w3e:frechet-e0.5", 24], ["w3a:diffusion-wide", 24], ["w2c:zipper+stretch-b1.1", 24], ["w3d:cubu+stretch", 18], ["w3a:spiral-a15", 18]],
+  "all|1.1|n25-40": [["w2c:zipper+stretch-b1.1", 40], ["w3a:spiral-a15", 32]],
+  "all|1.1|n41-64": [["hw:diffusion", 64]],
+  "all|1.1|n65-128": [],
+  "all|1.25|n1-12": [["w3d:kdeeb-routes", 12], ["w3e:mlseb+stretch", 12], ["hw:growth", 12], ["hw:level-links", 12], ["w3b:growth-input", 10], ["w3e:confluent+stretch", 10], ["w3d:kdeeb-nomask", 10]],
+  "all|1.25|n13-24": [["w3d:kdeeb-routes", 24], ["w3f:p-hub-a0.2", 24], ["w3d:kdeeb-nomask", 18], ["w3a:spiral-n3", 18]],
   "all|1.25|n25-40": [["w3d:kdeeb-routes", 32]],
-  "all|1.5|n1-12": [["w3b:growth-s0.3", 12], ["w3e:mlseb-a0", 12], ["w3e:mlseb-routes", 10], ["w3c:edge-paths-k1.5", 10]],
+  "all|1.25|n41-64": [],
+  "all|1.25|n65-128": [],
+  "all|1.5|n1-12": [["w3b:growth-s0.3", 12], ["w3e:mlseb-a0", 12], ["w3e:mlseb-routes", 10], ["w3c:edge-paths-k1.5", 10], ["w3f:territories-r2", 10]],
   "all|1.5|n13-24": [["hw:growth", 24], ["w3b:growth-input", 24]],
-  "all|1.5|n25-40": [["hw:growth", 40], ["w3b:growth-s0.7", 32], ["w3b:growth-s0.3", 32]],
+  "all|1.5|n25-40": [["hw:growth", 40], ["w3b:growth-s0.7", 40], ["w3b:growth-s0.3", 32]],
+  "all|1.5|n41-64": [],
+  "all|1.5|n65-128": [],
 };

package/src/portfolio/router.ts

@@ -30,8 +30,20 @@ export interface PortfolioRouterOptions {
   readonly maxMembers?: number;
   /** The clock in milliseconds. The default is `performance.now`. */
   readonly now?: () => number;
+  /**
+   * The members that get an output hash in the trace (HASH-LAZY). The pick does not use the hashes, so the winner and the output do not change.
+   * - With `pick` (the default), only the base and the winner get a hash, and only when the winner is not the base.
+   * - With `all`, each member that ran gets a hash, as before HASH-LAZY. Use it when you need the `outputHash` of each member.
+   */
+  readonly hashes?: PortfolioHashes;
 }
 
+/** The values of the option `hashes` of the portfolio router. */
+export type PortfolioHashes = "all" | "pick";
+
+/** The values of the option `hashes`, in order. The default is `pick`. */
+export const PORTFOLIO_HASHES: readonly PortfolioHashes[] = ["pick", "all"];
+
 /** The base member of each portfolio: the router `shared` with the rule `byCollection`. It is the fallback output above the cap. */
 export const PORTFOLIO_BASE_MEMBER = "shared";
 
@@ -49,14 +61,16 @@ export interface PortfolioRoute {
 }
 
 /** This function checks the options of the portfolio router, and gives them with their defaults. It throws a `RangeError` for a bad value. */
-function checked(o: PortfolioRouterOptions): { rule: PortfolioRule; cap: PortfolioCap; k: 3 | 5 | 8 | undefined } {
+function checked(o: PortfolioRouterOptions): { rule: PortfolioRule; cap: PortfolioCap; k: 3 | 5 | 8 | undefined; hashes: PortfolioHashes } {
   const rule = o.rule ?? "collection";
   const cap = o.cap ?? 1.5;
   const k = o.k;
+  const hashes = o.hashes ?? "pick";
   if (!PORTFOLIO_RULES.includes(rule)) throw new RangeError(`The portfolio router has the rule "${String(rule)}". It must be ${PORTFOLIO_RULES.join(" or ")}.`);
   if (!PORTFOLIO_CAPS.includes(cap)) throw new RangeError(`The portfolio router has the cap ${String(cap)}. It must be ${PORTFOLIO_CAPS.join(", ")}.`);
   if (k !== undefined && !PORTFOLIO_KS_API.includes(k)) throw new RangeError(`The portfolio router has the k ${String(k)}. It must be ${PORTFOLIO_KS_API.join(", ")}.`);
-  return { rule, cap, k };
+  if (!PORTFOLIO_HASHES.includes(hashes)) throw new RangeError(`The portfolio router has the hashes "${String(hashes)}". It must be ${PORTFOLIO_HASHES.join(" or ")}.`);
+  return { rule, cap, k, hashes };
 }
 
 /** This function gives the name of the portfolio router with the options `options`: `portfolio-<rule>-<cap>-k<k>`, or `portfolio-<rule>-<cap>-fit` without `k`. */
@@ -83,11 +97,12 @@ export function portfolioMembers(nodes: number, options: PortfolioRouterOptions
  * The key is `portfolioKey`: a member wins only when it passes the guard against the base. Of those members, the winner has the most ink saved.
  * A tie within the `minEffect` of B1 goes to the first member (`selectBest`). A member that throws does not win.
  * The result carries the trace of the pick and the move count `move.pick`.
+ * With the option `hashes` "pick" (the default), only the base and the winner get an `outputHash` in the trace. They get it only when the winner is not the base.
  */
 export function routePortfolio(graph: Graph, options: PortfolioRouterOptions = {}): PortfolioRoute {
   // A member with a node limit below the size of the graph does not run. The base `shared` has no such limit below the limit of the router.
   const names = portfolioMembers(graph.nodes.length, options).filter((name) => name === PORTFOLIO_BASE_MEMBER || (portfolioMember(name)?.maxNodes ?? Infinity) >= graph.nodes.length);
-  const { rule, cap } = checked(options);
+  const { rule, cap, hashes } = checked(options);
   // The key compares each member with the output of the base, so the run of the base keeps its output.
   let base: Result | undefined;
   const members: Member<Graph, Result>[] = names.map((name) => {
@@ -104,6 +119,7 @@ export function routePortfolio(graph: Graph, options: PortfolioRouterOptions = {
     };
   });
   const p = portfolio(portfolioName(options), members, portfolioKey(graph, rule, cap, () => base), {
+    hashes,
     ...(options.budgetMs === undefined ? {} : { budgetMs: options.budgetMs }),
     ...(options.maxMembers === undefined ? {} : { maxMembers: options.maxMembers }),
     ...(options.now === undefined ? {} : { now: options.now }),

package/src/portfolio/sets.ts

@@ -1,5 +1,5 @@
 // This file is generated by `scripts/portfolio-sets.ts` (`pnpm portfolio:sets`). Do not edit it. The test `sets.test.ts` checks that it is current.
-// The records come from the CI runs 40631516113, 40644555345, 40644557536, 40644560237, 40644562652, 40644565132, 40644567956, 40644570455, 40644572910, 40644575649, 40644578541, 40644580965, 40644583603.
+// The records come from the CI runs 40631516113, 40644555345, 40644557536, 40644560237, 40644562652, 40644565132, 40644567956, 40644570455, 40644572910, 40644575649, 40644578541, 40644580965, 40644583603, 40665016754.
 import type { PortfolioCap, PortfolioRule } from "./bands.ts";
 
 /**
@@ -8,21 +8,33 @@ import type { PortfolioCap, PortfolioRule } from "./bands.ts";
  */
 export const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly string[]>> = {
   "collection|1.1|n1-12": ["corners-side", "w2c:select+stretch", "trunks-gilbert-a05", "w3a:spiral-a15", "trunks-tree-bf08", "hw:zipper", "w2c:level-links+stretch-b1.1", "hw:stubs"],
-  "collection|1.1|n13-24": ["w3e:crossbars+stretch", "corners-side", "shared-p2", "w2c:zipper+stretch-b1.1", "trunks-tree-bf08", "hw:weiszfeld", "trunks-gilbert-a07", "hw:stubs"],
+  "collection|1.1|n13-24": ["w3e:crossbars+stretch", "trunks-tree-bf08", "corners-side", "shared-p2", "w2c:zipper+stretch-b1.1", "hw:weiszfeld", "trunks-gilbert-a07", "hw:stubs"],
   "collection|1.1|n25-40": ["w2a:shared-ways+breakeven", "w2b:weiszfeld-a1", "w2c:level-links+stretch-b1.1"],
+  "collection|1.1|n41-64": [],
+  "collection|1.1|n65-128": [],
   "collection|1.25|n1-12": ["corners-side", "trunks-tree-bf06", "w3f:p-hub-a0.2", "hw:stubs", "hw:p-hub", "hw:spiral", "w2c:level-links+stretch", "w3f:spectral-c0.3"],
   "collection|1.25|n13-24": ["w2a:shared-ways+stretch", "shared-p3", "trunks-gilbert-a07", "w3e:crossbars+stretch", "trunks-tree-bf06", "w3c:hdbscan+stretch", "shared-wind-p2-r1-e2", "hw:stubs"],
   "collection|1.25|n25-40": ["w2a:shared-ways+stretch", "shared-p3", "shared-order-shortest", "w2b:weiszfeld-a1", "w3e:crossbars+stretch", "trunks-tree-bf08", "w2a:shared-ways+ambiguity", "w2b:weiszfeld-a0"],
+  "collection|1.25|n41-64": ["hw:lanes", "w3e:crossbars+stretch", "w2a:shared-ways+stretch", "shared-flow-a06-p3"],
+  "collection|1.25|n65-128": ["hw:lanes"],
   "collection|1.5|n1-12": ["trunks-gilbert-a03", "w3e:areas-keys", "trunks-tree-bf02", "w3f:p-hub-a0.2", "w2b:zipper-a1", "w3a:spiral-a35", "w3f:spectral-c0.3", "w2c:level-links+stretch"],
   "collection|1.5|n13-24": ["shared-wind-p2-r0.5", "trunks-gilbert-a03", "w3e:crossbars+stretch", "shared-wind-p2-r1-e2", "trunks-tree-bf06", "shared-flow-a06-p3", "shared-wind-p3-r1", "trunks-gilbert-a07"],
   "collection|1.5|n25-40": ["shared-p3", "hw:lanes", "shared-wind-p2-r1-e2", "hw:crossbars", "shared-flow-a06-p3", "trunks-tree-bf06", "shared-wind-p2-r1", "shared-wind-p2-r2"],
+  "collection|1.5|n41-64": ["shared-flow-a06-p3", "hw:lanes", "shared-p2", "trunks-tree-bf06"],
+  "collection|1.5|n65-128": ["shared-p2", "shared-p3", "shared-flow-a06-p3", "hw:lanes"],
   "all|1.1|n1-12": ["w2b:zipper-p2", "hw:cubu", "w3d:kdeeb+stretch", "w3c:hough-wide", "w3d:kdeeb-routes", "hw:stubs", "hw:spiral", "w3b:growth-s0.7"],
   "all|1.1|n13-24": ["w3e:frechet-e0.5", "w3a:diffusion-wide", "w2c:zipper+stretch-b1.1", "w3d:cubu+stretch", "w3a:spiral-a15", "w3d:kdeeb-routes", "hw:diffusion", "hw:mesh"],
   "all|1.1|n25-40": ["w2c:zipper+stretch-b1.1", "w3a:spiral-a15", "w3d:mesh+stretch", "w3a:diffusion+stretch", "w3a:diffusion-wide", "w2c:road-classes-d0.3", "w3d:kdeeb-routes"],
+  "all|1.1|n41-64": ["hw:diffusion", "w3a:spiral-a15", "w2c:zipper+stretch-b1.1", "w3e:frechet-e0.5"],
+  "all|1.1|n65-128": ["hw:diffusion"],
   "all|1.25|n1-12": ["w3d:kdeeb-routes", "w3e:mlseb+stretch", "hw:growth", "hw:level-links", "w3b:growth-input", "w3e:confluent+stretch", "w3d:kdeeb-nomask", "w3a:diffusion-g2"],
-  "all|1.25|n13-24": ["w3d:kdeeb-routes", "w3e:mlseb+stretch", "w3f:p-hub-a0.2", "w3a:spiral-n3", "w3a:diffusion-l3", "trunks-tree-bf06", "hw:cubu", "w3a:spiral-a35"],
+  "all|1.25|n13-24": ["w3d:kdeeb-routes", "w3f:p-hub-a0.2", "w3d:kdeeb-nomask", "w3a:spiral-n3", "w3b:growth-input", "w3d:cubu+stretch", "w3a:spiral-a35", "trunks-tree-bf06"],
   "all|1.25|n25-40": ["w3d:kdeeb-routes", "hw:spiral", "hw:shared-ways-all", "w3a:diffusion-g2", "w3e:frechet+stretch", "hw:cubu"],
+  "all|1.25|n41-64": ["w3e:frechet+stretch", "hw:cubu", "w3a:diffusion-wide", "w2a:shared-ways+stretch", "w3a:spiral-a35"],
+  "all|1.25|n65-128": ["hw:diffusion", "w3a:diffusion-wide", "w3a:diffusion-l3"],
   "all|1.5|n1-12": ["w3b:growth-s0.3", "w3e:mlseb-a0", "w3e:mlseb-routes", "w3c:edge-paths-k1.5", "w3f:territories-r2", "hw:mlseb", "hw:growth", "w3e:mlseb-parabola"],
-  "all|1.5|n13-24": ["hw:growth", "w3b:growth-input", "hw:mlseb", "w3e:mlseb+stretch", "w3b:growth-s0.3"],
+  "all|1.5|n13-24": ["hw:growth", "w3b:growth-input", "hw:mlseb", "w3b:growth-s0.3"],
   "all|1.5|n25-40": ["hw:growth", "w3b:growth-s0.7", "w3b:growth-s0.3", "w3b:growth-t1.2", "w3b:growth-input"],
+  "all|1.5|n41-64": ["hw:growth", "w3b:growth-s0.3", "w3a:diffusion-g2", "w3b:growth-s0.7", "w3a:diffusion-l3", "w3b:growth-input"],
+  "all|1.5|n65-128": ["hw:growth", "w3b:growth-s0.3", "hw:shared-ways-all", "w3a:diffusion-g2"],
 };