@mark1russell7/highways 0.9.3 → 0.9.5

package/src/families/index.ts

@@ -1,12 +1,14 @@
 // The corpus families of highways on the shared registry of `@mark1russell7/layout-contract` (CORPUS-GEN, L45).
 import { createFamilyRegistry, type FamilyRegistry } from "@mark1russell7/layout-contract";
 import { HUB_CHAIN, MANY_GROUPS, PACKED_GRID } from "./cases.ts";
+import { COVERAGE_FAMILIES } from "./coverage.ts";
 import { DENSE_GROUPS, SMALL_CLUSTERED, TINY_UNIFORM } from "./fixtures.ts";
 import type { HighwaysBoard, HighwaysFamily } from "./model.ts";
 
 export * from "./model.ts";
 export { DENSE_GROUPS, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, fixtureParams, fixtureSpecOf, SMALL_CLUSTERED, TINY_UNIFORM } from "./fixtures.ts";
 export { HUB_CHAIN, MANY_GROUPS, PACKED_GRID } from "./cases.ts";
+export { BIPARTITE, BIPARTITE_LAYOUTS, COVERAGE_FAMILIES, FAN_OUT, FRAME_ROWS, LOCAL_MESH, PIPELINE, SPARSE_LONG, THIN_BARS, TWO_HUBS, UNEVEN_SIZES } from "./coverage.ts";
 // The parts of the shared registry that a host of the families uses. The site imports only `@mark1russell7/highways`.
 export {
   createFamilyRegistry,
@@ -26,9 +28,10 @@ export {
 
 /**
  * The corpus families of highways, in the order of the screen sets. Each family at its defaults makes the board of its screen family.
+ * The first 6 families are the families of `screen-v1` and `screen-v2`. The 9 families of `COVERAGE_FAMILIES` follow them (CORPUS-FAMILIES).
  * An import registers nothing. A host makes a registry with `createFamilyRegistry(HIGHWAYS_FAMILIES)`, or with the lists of other engines too.
  */
-export const HIGHWAYS_FAMILIES: readonly HighwaysFamily[] = Object.freeze([TINY_UNIFORM, SMALL_CLUSTERED, DENSE_GROUPS, HUB_CHAIN, MANY_GROUPS, PACKED_GRID]);
+export const HIGHWAYS_FAMILIES: readonly HighwaysFamily[] = Object.freeze([TINY_UNIFORM, SMALL_CLUSTERED, DENSE_GROUPS, HUB_CHAIN, MANY_GROUPS, PACKED_GRID, ...COVERAGE_FAMILIES]);
 
 /** This function gives a new registry of `HIGHWAYS_FAMILIES`. */
 export function highwaysRegistry(): FamilyRegistry<HighwaysBoard> {

package/src/highways/balance/index.ts

@@ -0,0 +1,93 @@
+/**
+ * The highway strategy `balance` (EDA-017): the stretch of each edge of a bundle stays near a target.
+ * A Lagrange price for each edge grows while its stretch is above the target, and the price moves the exit of the edge forward.
+ */
+import { polylineLength } from "../../geom.ts";
+import { outerGraph, type Graph } from "../../model.ts";
+import { basePlan, tidyPlan, type HighwayBase } from "../base.ts";
+import { follow } from "../follow.ts";
+import { lengthBetween, memberAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The end of a ride that the price moves: the exit, the entry, or both by half. */
+export type BalanceEnd = "exit" | "entry" | "both";
+
+/** The values of `BalanceEnd`. */
+export const BALANCE_ENDS: readonly BalanceEnd[] = Object.freeze(["exit", "entry", "both"]);
+
+/** The options of the highway strategy `balance` (EDA-017). */
+export interface BalanceOptions {
+  /** The target of the stretch of an edge: its route on the plan over its route alone, from 1.1 to 2. The default is 1.2. */
+  readonly tau: number;
+  /** The number of updates of the prices, from 5 to 30. The default is 5. */
+  readonly iterations: number;
+  /** The end of a ride that the price moves. The default is `exit`. */
+  readonly end: BalanceEnd;
+  /** The plan that the strategy balances. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+
+/** The default options of the strategy `balance`. */
+export const BALANCE_DEFAULTS: Readonly<BalanceOptions> = Object.freeze({ tau: 1.2, iterations: 5, end: "exit", from: "shared-ways" });
+
+/** The margin of the way finder of `follow`. A ride shorter than this length leaves the plan. */
+const MARGIN = 5;
+
+/** This function gives the length of the route of each edge of a plan after `follow`. */
+function routeLengths(graph: Graph, plan: HighwayPlan): Map<string, number> {
+  return new Map(follow(graph, plan).routes.map((r) => [r.edge, polylineLength(r.points)]));
+}
+
+/**
+ * This function gives the plan of the highway strategy `balance` (EDA-017, after the Lagrange relaxation of the stretch).
+ * The stretch of an edge is its route on the plan over its route alone, as the gate `stretch` measures it.
+ * At each update, an edge with a stretch above `tau` adds `stretch - tau` to its price. Each of its rides keeps the share `1 - price` of its first length.
+ * A ride shorter than the margin leaves the plan. The updates stop when no edge is above `tau`.
+ */
+export function balancePlan(input: HighwayInput, options: Partial<BalanceOptions> = {}): HighwayPlan {
+  const o = { ...BALANCE_DEFAULTS, ...options };
+  const graph = outerGraph(input.graph);
+  return balanceOf(graph, basePlan({ ...input, graph }, o.from), o);
+}
+
+/** This function balances the plan `first` of the graph, as `balancePlan` does. It reads all the options except `from`. */
+export function balanceOf(graph: Graph, first: HighwayPlan, options: Partial<BalanceOptions> = {}): HighwayPlan {
+  const o = { ...BALANCE_DEFAULTS, ...options };
+  const riders = new Set(first.highways.flatMap((h) => h.members.map((m) => m.edge)));
+  if (riders.size === 0) return first;
+  const sub: Graph = { nodes: graph.nodes, edges: graph.edges.filter((e) => riders.has(e.id)) };
+  const alone = routeLengths(sub, { highways: [] });
+  const price = new Map<string, number>();
+  let plan = first;
+  for (let k = 0; k < Math.max(1, Math.floor(o.iterations)); k++) {
+    const along = routeLengths(sub, plan);
+    let over = false;
+    for (const [edge, length] of along) {
+      const base = alone.get(edge) ?? 0;
+      if (base <= 1e-9) continue;
+      const stretch = length / base;
+      if (stretch <= o.tau + 1e-9) continue;
+      price.set(edge, (price.get(edge) ?? 0) + stretch - o.tau);
+      over = true;
+    }
+    if (!over) break;
+    // Each update cuts the rides of the first plan by the prices as they are now.
+    plan = tidyPlan({
+      highways: first.highways.map((h) => ({
+        ...h,
+        members: h.members.flatMap((m): HighwayMember[] => {
+          const keep = 1 - Math.min(1, price.get(m.edge) ?? 0);
+          if (keep >= 1) return [m];
+          const span = m.off - m.on;
+          // The exit moves back toward the entry, the entry moves forward toward the exit, or each moves by half the cut.
+          const cut = (1 - keep) * span;
+          const on = o.end === "entry" ? m.on + cut : o.end === "both" ? m.on + cut / 2 : m.on;
+          const off = o.end === "exit" ? m.off - cut : o.end === "both" ? m.off - cut / 2 : m.off;
+          if (lengthBetween(h.spine, Math.min(on, off), Math.max(on, off)) < MARGIN) return [];
+          return [memberAt(h.spine, m.edge, on, off, m.seq)];
+        }),
+      })),
+    });
+    if (plan.highways.length === 0) break;
+  }
+  return plan;
+}

package/src/highways/bronchial/index.ts

@@ -0,0 +1,144 @@
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+import { rootOf } from "../knee/root.ts";
+
+/** The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap of the angles. */
+export type BronchialSplit = "count" | "weight" | "gap";
+
+/** The values of `BronchialSplit`. */
+export const BRONCHIAL_SPLITS: readonly BronchialSplit[] = Object.freeze(["count", "weight", "gap"]);
+
+/** The options of the highway strategy `bronchial` (NAT-019 of the nature notes). */
+export interface BronchialOptions {
+  /**
+   * The rule of the split. With `count`, each half gets half of the targets. With `weight`, the two halves get near-equal sums of the distances from the tip.
+   * With `gap`, the cut goes at the widest gap between the angles of the targets. The default is `count`.
+   */
+  readonly split: BronchialSplit;
+  /** The share of the distance to the center of the targets that a branch grows, from 0.3 to 0.7. The default is 0.5. */
+  readonly share: number;
+  /** A set with this number of targets or fewer stops the splits, from 1 to 3. Each of its targets gets its own way from the tip. The default is 1. */
+  readonly smallest: number;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `bronchial`. */
+export const BRONCHIAL_DEFAULTS: Readonly<BronchialOptions> = Object.freeze({ split: "count", share: 0.5, smallest: 1, detour: 1.5, minSize: 2 });
+
+/**
+ * This function gives the diamond angle of the direction `(dx, dy)`: a value from 0 to 4 that grows with the angle, with no trigonometry.
+ * The value 0 is the direction of the positive x axis.
+ */
+export function diamondAngle(dx: number, dy: number): number {
+  const s = Math.abs(dx) + Math.abs(dy);
+  if (s <= 1e-12) return 0;
+  if (dy >= 0) return dx >= 0 ? dy / s : 1 - dx / s;
+  return dx < 0 ? 2 - dy / s : 3 + dx / s;
+}
+
+/**
+ * This function splits the targets of a tip in two halves (NAT-019). The targets go in the order of their angles around the tip.
+ * The order starts after the widest gap of the angles, so each half is a sector. The rule of `split` then cuts the order in two.
+ */
+export function splitTargets(tip: Point, targets: readonly Point[], ids: readonly number[], split: BronchialSplit): [number[], number[]] {
+  const sorted = [...ids].sort((a, b) => diamondAngle(targets[a]!.x - tip.x, targets[a]!.y - tip.y) - diamondAngle(targets[b]!.x - tip.x, targets[b]!.y - tip.y) || a - b);
+  const angle = (i: number): number => diamondAngle(targets[sorted[i]!]!.x - tip.x, targets[sorted[i]!]!.y - tip.y);
+  const n = sorted.length;
+  // The gap after each target, to the next target around the circle.
+  const gaps = sorted.map((_, i) => (i === n - 1 ? angle(0) + 4 - angle(i) : angle(i + 1) - angle(i)));
+  let widest = 0;
+  for (let i = 1; i < n; i++) if (gaps[i]! > gaps[widest]! + 1e-12) widest = i;
+  const order = [...sorted.slice(widest + 1), ...sorted.slice(0, widest + 1)];
+  let cut = Math.floor(n / 2);
+  if (split === "weight") {
+    const w = order.map((i) => dist(tip, targets[i]!));
+    const total = w.reduce((s, x) => s + x, 0);
+    let run = 0;
+    let best = Infinity;
+    for (let c = 1; c < n; c++) {
+      run += w[c - 1]!;
+      const off = Math.abs(2 * run - total);
+      if (off < best - 1e-9) [best, cut] = [off, c];
+    }
+  } else if (split === "gap") {
+    let best = -Infinity;
+    const at = (k: number): number => diamondAngle(targets[order[k]!]!.x - tip.x, targets[order[k]!]!.y - tip.y);
+    for (let c = 1; c < n; c++) {
+      const g = (at(c) - at(c - 1) + 4) % 4;
+      if (g > best + 1e-12) [best, cut] = [g, c];
+    }
+  }
+  return [order.slice(0, cut), order.slice(cut)];
+}
+
+/**
+ * This function gives the highways of the bronchial trees (NAT-019, after Kitaoka and others, 1999). The edges from one source node get one tree.
+ * The root of a tree is the out point of the plug nearest the center of the targets.
+ * From the tip, the tree grows a share of the way to the center of its targets. Then it splits the targets in two and grows a branch for each half.
+ * A branch that hits a box grows half as far, or not at all. A small set of targets gets its own ways from the tip, through the corner graph.
+ * Each edge takes its path in the tree when that path is short enough, and the stretches that two edges or more share become highways.
+ */
+export function bronchialPlan(input: HighwayInput, o: Readonly<BronchialOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const pad = finder.margin / 2;
+  const first = firstRoutes(input);
+  const groups = new Map<string, { edge: string; key: string; s: Point; t: Point; base: number }[]>();
+  for (const p of edgePlugs(input.graph)) {
+    const s = finder.out(p.ps);
+    const t = finder.out(p.pt);
+    const route = first.get(p.edge.id);
+    const group = p.edge.source.node;
+    const list = groups.get(group) ?? [];
+    list.push({ edge: p.edge.id, key: p.edge.source.node, s, t, base: route ? polylineLength(route) : dist(s, t) });
+    groups.set(group, list);
+  }
+  const share = Math.min(0.7, Math.max(0.3, o.share));
+  const smallest = Math.min(3, Math.max(1, Math.floor(o.smallest)));
+  const ways: KeyedWay[] = [];
+  for (const group of [...groups.keys()].sort()) {
+    const list = groups.get(group)!;
+    if (list.length < 2) continue;
+    const goals = list.map((e) => e.t);
+    const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+    const paths: (Point[] | undefined)[] = list.map(() => undefined);
+    const grow = (trunk: readonly Point[], ids: readonly number[]): void => {
+      const tip = trunk[trunk.length - 1]!;
+      if (ids.length <= smallest) {
+        for (const i of ids) {
+          const way = finder.corners.path(tip, goals[i]!);
+          if (way) paths[i] = [...trunk, ...finder.corners.pull(way).slice(1)];
+        }
+        return;
+      }
+      const c = { x: ids.reduce((s, i) => s + goals[i]!.x, 0) / ids.length, y: ids.reduce((s, i) => s + goals[i]!.y, 0) / ids.length };
+      let next = trunk;
+      for (let f = share; f > share / 8; f /= 2) {
+        const p = { x: tip.x + f * (c.x - tip.x), y: tip.y + f * (c.y - tip.y) };
+        if (dist(p, tip) <= 1e-6) break;
+        if (!finder.obstacles.inside(p, pad) && finder.obstacles.clearPath([tip, p], pad)) {
+          next = [...trunk, p];
+          break;
+        }
+      }
+      const [a, b] = splitTargets(next[next.length - 1]!, goals, ids, o.split);
+      grow(next, a);
+      grow(next, b);
+    };
+    grow([root], list.map((_, i) => i));
+    list.forEach((e, i) => {
+      const tail = paths[i];
+      const lead = leads[i];
+      if (!tail || !lead) return;
+      const points = [...lead, ...tail.slice(1)];
+      if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+      ways.push({ edge: e.edge, key: e.key, points });
+    });
+  }
+  return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}

package/src/highways/index.ts

@@ -102,6 +102,11 @@ export { oneSteiner, spanningTree, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_MET
 export { GAP_DEFAULTS, gapPlan, type GapOptions } from "./gaps/index.ts";
 export { STREET_DEFAULTS, streetPlan, type StreetOptions } from "./streets/index.ts";
 export { SEARCH_DEFAULTS, SEARCH_MOVES, searchPlan, searchScore, type SearchMove, type SearchOptions } from "./search/index.ts";
+export { KNEE_DEFAULTS, KNEE_RULES, kneeOf, kneePlan, type KneeOptions, type KneeRule, type KneeTree } from "./knee/index.ts";
+export { BALANCE_DEFAULTS, BALANCE_ENDS, balanceOf, balancePlan, type BalanceEnd, type BalanceOptions } from "./balance/index.ts";
+export { SLOT_DEFAULTS, SLOT_KEYS, slotJoin, slotPlan, slotsOf, type SlotJoin, type SlotKeys, type SlotOptions } from "./slots/index.ts";
+export { MANIFOLD_DEFAULTS, MANIFOLD_SIDES, manifoldPlan, type ManifoldOptions, type ManifoldSide } from "./manifolds/index.ts";
+export { BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, bronchialPlan, diamondAngle, splitTargets, type BronchialOptions, type BronchialSplit } from "./bronchial/index.ts";
 export { INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, interchangeCandidates, interchangePlan, type Interchange, type InterchangeBase, type InterchangeOptions } from "./interchanges/index.ts";
 export { SCALE_SPACE_DEFAULTS, scaleClusters, scaleSpaceGroups, scaleSpacePlan, type ScaleCluster, type ScaleSpaceOptions } from "./scale-space/index.ts";
 export * from "./gates/index.ts";

package/src/highways/knee/index.ts

@@ -0,0 +1,154 @@
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { balancedFan, fanPath, type Fan } from "../../routers/fan.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+import { rootOf } from "./root.ts";
+
+/** The rule that picks one tree on the front: the knee of the chord, or the least weighted sum. */
+export type KneeRule = "chord" | "weights";
+
+/** The values of `KneeRule`. */
+export const KNEE_RULES: readonly KneeRule[] = Object.freeze(["chord", "weights"]);
+
+/** The options of the highway strategy `knee` (NAT-018 of the nature notes, on the trees of NAT-017). */
+export interface KneeOptions {
+  /** The number of points of the sweep of the balancing factor, from 5 to 21. The default is 11. */
+  readonly sweep: number;
+  /** The rule that picks one tree on the front. The default is `chord`. */
+  readonly rule: KneeRule;
+  /** The weight of the ink in the rule `weights`, from 0 to 1. The rest of the weight goes to the path length. The default is 0.5. */
+  readonly ink: number;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `knee`. */
+export const KNEE_DEFAULTS: Readonly<KneeOptions> = Object.freeze({ sweep: 11, rule: "chord", ink: 0.5, detour: 1.5, minSize: 2 });
+
+/** One tree of the sweep: its balancing factor, its ink `L`, the sum of its path lengths `S`, and the tree. */
+export interface KneeTree {
+  readonly bf: number;
+  readonly ink: number;
+  readonly paths: number;
+  readonly fan: Fan;
+}
+
+/** This function gives the ink of a fan: the sum of the lengths of its links. */
+function fanInk(fan: Fan): number {
+  let sum = 0;
+  for (const p of fan.points) if (p.parent >= 0) sum += dist(p.point, fan.points[p.parent]!.point);
+  return sum;
+}
+
+/**
+ * This function adds a stub point at `stub` from the end of the last link of a way. The tree of NAT-017 joins a new branch only at an open point or on a link to one.
+ * The last point of a way is not open, so without the stub no branch joins the last link.
+ */
+function withStub(way: Point[], stub: number): Point[] {
+  if (way.length < 2) return way;
+  const a = way[way.length - 2]!;
+  const b = way[way.length - 1]!;
+  const d = dist(a, b);
+  if (d <= 2 * stub) return way;
+  return [...way.slice(0, -1), { x: b.x + ((a.x - b.x) * stub) / d, y: b.y + ((a.y - b.y) * stub) / d }, b];
+}
+
+/**
+ * This function gives the index of the tree that the rule picks on the front of the trees (NAT-018).
+ * The front holds the trees that no other tree beats on the ink and on the path lengths. The two values go to the range from 0 to 1.
+ * With `chord`, the pick is the tree of the front farthest from the line between the two ends of the front.
+ * With `weights`, the pick is the tree with the least `ink × L + (1 - ink) × S`. A tie goes to the earlier tree.
+ */
+export function kneeOf(trees: readonly Pick<KneeTree, "ink" | "paths">[], rule: KneeRule, ink: number): number {
+  if (trees.length === 0) return -1;
+  const front = trees.map((_, i) => i).filter((i) => !trees.some((q, j) => j !== i && q.ink <= trees[i]!.ink && q.paths <= trees[i]!.paths && (q.ink < trees[i]!.ink || q.paths < trees[i]!.paths)));
+  const lo = { x: Math.min(...front.map((i) => trees[i]!.ink)), y: Math.min(...front.map((i) => trees[i]!.paths)) };
+  const hi = { x: Math.max(...front.map((i) => trees[i]!.ink)), y: Math.max(...front.map((i) => trees[i]!.paths)) };
+  const norm = (i: number): Point => ({
+    x: hi.x - lo.x > 1e-9 ? (trees[i]!.ink - lo.x) / (hi.x - lo.x) : 0,
+    y: hi.y - lo.y > 1e-9 ? (trees[i]!.paths - lo.y) / (hi.y - lo.y) : 0,
+  });
+  let best = front[0]!;
+  let score = rule === "chord" ? -Infinity : Infinity;
+  if (rule === "weights") {
+    const w = Math.min(1, Math.max(0, ink));
+    for (const i of front) {
+      const p = norm(i);
+      const s = w * p.x + (1 - w) * p.y;
+      if (s < score - 1e-12) [best, score] = [i, s];
+    }
+    return best;
+  }
+  // The ends of the front: the tree with the least ink, and the tree with the least path lengths.
+  const a = front.reduce((u, i) => (trees[i]!.ink < trees[u]!.ink || (trees[i]!.ink === trees[u]!.ink && trees[i]!.paths < trees[u]!.paths) ? i : u));
+  const b = front.reduce((u, i) => (trees[i]!.paths < trees[u]!.paths || (trees[i]!.paths === trees[u]!.paths && trees[i]!.ink < trees[u]!.ink) ? i : u));
+  const A = norm(a);
+  const B = norm(b);
+  const len = dist(A, B);
+  if (len <= 1e-12) return a;
+  for (const i of front) {
+    const p = norm(i);
+    const s = Math.abs((B.x - A.x) * (A.y - p.y) - (A.x - p.x) * (B.y - A.y)) / len;
+    if (s > score + 1e-12) [best, score] = [i, s];
+  }
+  return best;
+}
+
+/**
+ * This function gives the highways of the knee trees (NAT-018). The edges from one source node get one tree. Its root is the out point of the plug nearest the center of the targets.
+ * A sweep of the balancing factor of NAT-017 gives trees from the least ink to the most direct paths.
+ * The tree at the knee of the front of ink and path lengths is the pick. Each edge takes its path in the tree, when that path is short enough.
+ * The stretches of the tree that two edges or more share become highways.
+ */
+export function kneePlan(input: HighwayInput, o: Readonly<KneeOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const first = firstRoutes(input);
+  const groups = new Map<string, { edge: string; key: string; s: Point; t: Point; base: number }[]>();
+  for (const p of edgePlugs(input.graph)) {
+    const s = finder.out(p.ps);
+    const t = finder.out(p.pt);
+    const route = first.get(p.edge.id);
+    const group = p.edge.source.node;
+    const list = groups.get(group) ?? [];
+    list.push({ edge: p.edge.id, key: p.edge.source.node, s, t, base: route ? polylineLength(route) : dist(s, t) });
+    groups.set(group, list);
+  }
+  const sweep = Math.min(21, Math.max(2, Math.floor(o.sweep)));
+  const ways: KeyedWay[] = [];
+  for (const group of [...groups.keys()].sort()) {
+    const list = groups.get(group)!;
+    if (list.length < 2) continue;
+    const goals = list.map((e) => e.t);
+    const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+    const lost = new Set<number>();
+    const branch = (from: Point, t: number): Point[] => {
+      const way = finder.corners.path(from, goals[t]!);
+      if (way) return withStub(finder.corners.pull(way), finder.margin);
+      lost.add(t);
+      return [from, goals[t]!];
+    };
+    // The sweep: the cost `a L + (1 - a) S` for `a` from `1 / sweep` to 1, as the balancing factor `bf = (1 - a) / a`.
+    const trees: KneeTree[] = [];
+    for (let k = 0; k < sweep; k++) {
+      const a = (k + 1) / sweep;
+      const bf = (1 - a) / a;
+      const fan = balancedFan(root, goals, bf, branch);
+      let paths = 0;
+      for (const leaf of fan.leaf) paths += fan.points[leaf]!.pl;
+      trees.push({ bf, ink: fanInk(fan), paths, fan });
+    }
+    const pick = trees[kneeOf(trees, o.rule, o.ink)]!;
+    list.forEach((e, t) => {
+      const lead = leads[t];
+      if (lost.has(t) || !lead) return;
+      const points = [...lead, ...fanPath(pick.fan, pick.fan.leaf[t]!).slice(1)];
+      if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+      ways.push({ edge: e.edge, key: e.key, points });
+    });
+  }
+  return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}

package/src/highways/knee/root.ts

@@ -0,0 +1,19 @@
+import { dist, type Point } from "../../geom.ts";
+import type { WayFinder } from "../../ways.ts";
+
+/**
+ * This function gives the root of the tree of one source node (NAT-018, NAT-019): the start point nearest the center of the targets.
+ * It also gives the lead of each edge, the way from its own start point to the root. A lead is `undefined` when the corner graph has no way.
+ */
+export function rootOf(finder: WayFinder, starts: readonly Point[], goals: readonly Point[]): { root: Point; leads: (Point[] | undefined)[] } {
+  const c = { x: goals.reduce((s, p) => s + p.x, 0) / goals.length, y: goals.reduce((s, p) => s + p.y, 0) / goals.length };
+  let root = starts[0]!;
+  for (const s of starts) if (dist(s, c) < dist(root, c) - 1e-9) root = s;
+  const leads = starts.map((s) => {
+    if (dist(s, root) <= 1e-9) return [root];
+    if (finder.obstacles.clearPath([s, root], finder.margin / 2)) return [s, root];
+    const way = finder.corners.path(s, root);
+    return way ? finder.corners.pull(way) : undefined;
+  });
+  return { root, leads };
+}

package/src/highways/manifolds/index.ts

@@ -0,0 +1,157 @@
+/**
+ * The highway strategy `manifolds` (WILD-036): a header for a fan from one node to a row of nodes.
+ * The header lies in the gap before the row, the taps leave it at right angles, and the feed joins it from the node.
+ */
+import { center, dist, type Point } from "../../geom.ts";
+import { nodeIndex, outerGraph, type Node } from "../../model.ts";
+import { basePlan, tidyPlan, type HighwayBase } from "../base.ts";
+import { keepMembers } from "../gates/model.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { snapPlan, type SnapLine } from "../snap.ts";
+
+/** The place of the header in the gap before the row: near the row, or near the feed node. */
+export type ManifoldSide = "near" | "far";
+
+/** The values of `ManifoldSide`. */
+export const MANIFOLD_SIDES: readonly ManifoldSide[] = Object.freeze(["near", "far"]);
+
+/** The options of the highway strategy `manifolds` (WILD-036). */
+export interface ManifoldOptions {
+  /** A manifold has this number of taps or more, from 3 to 8. The default is 3. */
+  readonly kMin: number;
+  /** The nodes of one row have centers in a band of this many median box heights, from 0.5 to 2. The default is 1. */
+  readonly band: number;
+  /** The place of the header in the gap before the row. The default is `near`. */
+  readonly side: ManifoldSide;
+  /** A tap stays on the manifold only when its way is this many times the direct line or less, from 1 to 3. The default is 1.5. */
+  readonly detour: number;
+  /** The plan of the edges that are not on a manifold. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+
+/** The default options of the strategy `manifolds`. */
+export const MANIFOLD_DEFAULTS: Readonly<ManifoldOptions> = Object.freeze({ kMin: 3, band: 1, side: "near", detour: 1.5, from: "shared-ways" });
+
+/** One end of a fan: an edge from the feed node to a far node. */
+interface Tap {
+  readonly edge: string;
+  readonly far: Node;
+  /** With `true`, the feed node is the source of the edge. */
+  readonly out: boolean;
+}
+
+/** A manifold that the strategy can make: the feed node, the axis of the header, its place across the axis and its taps. */
+interface Candidate {
+  readonly feed: Node;
+  /** With `x`, the header is horizontal. With `y`, the header is vertical. */
+  readonly axis: "x" | "y";
+  readonly at: number;
+  readonly taps: readonly Tap[];
+}
+
+/** This function gives the median of the values, or 0 when there is none. */
+function median(values: readonly number[]): number {
+  if (values.length === 0) return 0;
+  const s = [...values].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)]!;
+}
+
+/** This function compares two texts in the order of their code units. */
+function byId(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * This function gives the manifolds that the strategy can make from one feed node, for one axis of the header.
+ * The far centers go in bands across the axis. A band with `kMin` taps or more, wholly on one side of the feed node, is a candidate.
+ */
+function candidatesOf(feed: Node, taps: readonly Tap[], axis: "x" | "y", band: number, o: Readonly<ManifoldOptions>, margin: number): Candidate[] {
+  const across = axis === "x" ? "y" : "x";
+  const size = axis === "x" ? "h" : "w";
+  const sorted = [...taps].sort((a, b) => center(a.far.box)[across] - center(b.far.box)[across] || byId(a.edge, b.edge));
+  const out: Candidate[] = [];
+  const lo = feed.box[across];
+  const hi = lo + feed.box[size];
+  // The share of the gap from the row to its header: a third with `near`, two thirds with `far`.
+  const share = o.side === "near" ? 1 / 3 : 2 / 3;
+  for (let i = 0; i < sorted.length; ) {
+    let j = i;
+    const first = center(sorted[i]!.far.box)[across];
+    while (j + 1 < sorted.length && center(sorted[j + 1]!.far.box)[across] - first <= band) j++;
+    const row = sorted.slice(i, j + 1);
+    i = j + 1;
+    if (row.length < o.kMin) continue;
+    const top = Math.min(...row.map((t) => t.far.box[across]));
+    const bottom = Math.max(...row.map((t) => t.far.box[across] + t.far.box[size]));
+    if (hi + 2 * margin <= top) out.push({ feed, axis, at: top - share * (top - hi), taps: row });
+    else if (bottom + 2 * margin <= lo) out.push({ feed, axis, at: bottom + share * (lo - bottom), taps: row });
+  }
+  return out;
+}
+
+/**
+ * This function gives the plan of the highway strategy `manifolds` (WILD-036, after the headers of pipes and of bus bars).
+ * A fan of `kMin` edges or more from one node to a row of nodes gets a straight header in the gap before the row.
+ * Each edge of the fan joins the header at the feed point, in line with the center of the node. It leaves the header at its tap, in line with the center of its far node.
+ * A tap whose way is more than `detour` times the direct line leaves the manifold. Each edge is on one manifold at most. The other edges keep the plan `from`.
+ */
+export function manifoldPlan(input: HighwayInput, options: Partial<ManifoldOptions> = {}): HighwayPlan {
+  const o = { ...MANIFOLD_DEFAULTS, ...options };
+  const graph = outerGraph(input.graph);
+  const nodes = nodeIndex(graph);
+  const margin = 5;
+  const bandOf = { x: o.band * median(graph.nodes.map((n) => n.box.h)), y: o.band * median(graph.nodes.map((n) => n.box.w)) };
+  const fans = new Map<string, Tap[]>();
+  const add = (id: string, tap: Tap): void => {
+    const list = fans.get(id);
+    if (list) list.push(tap);
+    else fans.set(id, [tap]);
+  };
+  for (const e of graph.edges) {
+    const s = nodes.get(e.source.node);
+    const t = nodes.get(e.target.node);
+    if (!s || !t || s === t) continue;
+    add(s.id, { edge: e.id, far: t, out: true });
+    add(t.id, { edge: e.id, far: s, out: false });
+  }
+  const all: Candidate[] = [];
+  for (const [id, taps] of fans) {
+    if (taps.length < o.kMin) continue;
+    const feed = nodes.get(id)!;
+    for (const axis of ["x", "y"] as const) all.push(...candidatesOf(feed, taps, axis, bandOf[axis], o, margin));
+  }
+  // The largest manifolds go first. A tie goes to the node id, then to the axis, so the plan does not depend on the order of the map.
+  all.sort((a, b) => b.taps.length - a.taps.length || byId(a.feed.id, b.feed.id) || byId(a.axis, b.axis) || a.at - b.at);
+  const used = new Set<string>();
+  const lines: SnapLine[] = [];
+  for (const c of all) {
+    const fc = center(c.feed.box);
+    const feedPoint: Point = c.axis === "x" ? { x: fc.x, y: c.at } : { x: c.at, y: fc.y };
+    const tapOf = (t: Tap): Point => {
+      const tc = center(t.far.box);
+      return c.axis === "x" ? { x: tc.x, y: c.at } : { x: c.at, y: tc.y };
+    };
+    const taps = c.taps.filter((t) => {
+      if (used.has(t.edge)) return false;
+      const tc = center(t.far.box);
+      return dist(fc, feedPoint) + dist(feedPoint, tapOf(t)) + dist(tapOf(t), tc) <= o.detour * dist(fc, tc);
+    });
+    if (taps.length < o.kMin) continue;
+    const along = [feedPoint, ...taps.map(tapOf)].map((p) => p[c.axis]);
+    const lo = Math.min(...along);
+    const hi = Math.max(...along);
+    const a: Point = c.axis === "x" ? { x: lo, y: c.at } : { x: c.at, y: lo };
+    const b: Point = c.axis === "x" ? { x: hi, y: c.at } : { x: c.at, y: hi };
+    for (const t of taps) used.add(t.edge);
+    lines.push({
+      key: `manifold:${c.feed.id}:${c.axis}`,
+      a,
+      b,
+      members: taps.map((t) => (t.out ? { edge: t.edge, from: feedPoint, to: tapOf(t), at: 0.5 } : { edge: t.edge, from: tapOf(t), to: feedPoint, at: 0.5 })),
+    });
+  }
+  const manifolds = snapPlan({ graph }, lines, { minSize: Math.max(2, o.kMin), direct: true });
+  const riding = new Set(manifolds.highways.flatMap((h) => h.members.map((m) => m.edge)));
+  const base = keepMembers(basePlan({ ...input, graph }, o.from), (_, m) => !riding.has(m.edge));
+  return tidyPlan({ highways: [...manifolds.highways, ...base.highways] });
+}