@mark1russell7/highways 0.4.0 → 0.4.2

package/src/highways/weiszfeld/index.ts

@@ -0,0 +1,105 @@
+import { dist, type Point } from "../../geom.ts";
+import { basePlan, nearestPlace, planRoutes, routeIndex, tidyPlan, tripsOf, type HighwayBase } from "../base.ts";
+import { memberAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `weiszfeld` (HWY-043 of the note on highways). */
+export interface WeiszfeldOptions {
+  /** The plan whose highways get new meeting points. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The weight of the trunk is `k^alpha` for `k` members. With 0, the trunk costs its ink one time. With 1, it costs each lane. The default is 0.5. */
+  readonly alpha: number;
+  /** The number of steps of Weiszfeld. The default is 20. */
+  readonly steps: number;
+}
+
+/** The default options of the strategy `weiszfeld`. */
+export const WEISZFELD_DEFAULTS: Readonly<WeiszfeldOptions> = Object.freeze({ from: "shared-ways", alpha: 0.5, steps: 20 });
+
+const TINY = 1e-9;
+
+/** This function gives one step of Weiszfeld for the point `m`. The point `m` is near the points `ends`, and tied to `other` with the weight `w`. */
+function weiszfeldStep(m: Point, ends: readonly Point[], other: Point, w: number): Point {
+  let x = 0;
+  let y = 0;
+  let sum = 0;
+  for (const p of ends) {
+    const d = Math.max(TINY, dist(p, m));
+    x += p.x / d;
+    y += p.y / d;
+    sum += 1 / d;
+  }
+  const d = Math.max(TINY, dist(other, m));
+  x += (w * other.x) / d;
+  y += (w * other.y) / d;
+  sum += w / d;
+  return sum > 0 ? { x: x / sum, y: y / sum } : m;
+}
+
+/** This function gives the mean of a list of points that is not empty. */
+const mean = (ps: readonly Point[]): Point => ({ x: ps.reduce((s, p) => s + p.x, 0) / ps.length, y: ps.reduce((s, p) => s + p.y, 0) / ps.length });
+
+/**
+ * This function gives the meeting points `M1` and `M2` of a bundle with the least weighted ink (HWY-043):
+ * `Σ |a_i - M1| + w |M1 - M2| + Σ |M2 - b_i|`. The lists `a` and `b` are the ends of the edges on each side, and `w` is the weight of the trunk.
+ * The function starts at the means of `a` and `b`. Each step moves `M1` and then `M2` by one step of Weiszfeld.
+ */
+export function meetingPoints(a: readonly Point[], b: readonly Point[], w: number, steps: number): [Point, Point] {
+  if (a.length === 0 || b.length === 0) throw new Error("A side of the bundle has no end.");
+  let m1 = mean(a);
+  let m2 = mean(b);
+  for (let s = 0; s < steps; s++) {
+    m1 = weiszfeldStep(m1, a, m2, w);
+    m2 = weiszfeldStep(m2, b, m1, w);
+  }
+  return [m1, m2];
+}
+
+/**
+ * This function gives the highways of the plan `from`, with the meeting points of Weiszfeld (HWY-043).
+ * The ends of a member are the points where its edge comes to the highway and goes away from it after `follow` of the plan.
+ * They are the plugs, or the split point of the highway before and the merge point of the highway after.
+ * The weight of the trunk is `k^alpha` for `k` members. The trunk stays on the spine: the function projects `M1` and `M2` on the spine.
+ * Each member then joins the spine at `M1` and leaves it at `M2`, but not outside its own stretch. So a member only gets shorter on the spine.
+ */
+export function weiszfeldPlan(input: HighwayInput, o: Readonly<WeiszfeldOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  if (plan.highways.length === 0) return plan;
+  const routes = routeIndex(planRoutes(input.graph, plan).routes);
+  const trips = tripsOf(plan);
+  const highways = plan.highways.map((h, hi) => {
+    const a: Point[] = [];
+    const b: Point[] = [];
+    for (const m of h.members) {
+      const trip = trips.get(m.edge) ?? [];
+      const route = routes.get(m.edge);
+      const k = trip.findIndex((s) => s.h === hi);
+      const before = k > 0 ? trip[k - 1]!.m.split : route?.[0];
+      const after = k >= 0 && k < trip.length - 1 ? trip[k + 1]!.m.merge : route?.[route.length - 1];
+      if (!before || !after) continue;
+      if (m.on <= m.off) {
+        a.push(before);
+        b.push(after);
+      } else {
+        a.push(after);
+        b.push(before);
+      }
+    }
+    if (a.length < 2) return h;
+    const [m1, m2] = meetingPoints(a, b, h.members.length ** Math.max(0, o.alpha), Math.max(0, Math.round(o.steps)));
+    const pa = nearestPlace(h.spine, m1);
+    const pb = nearestPlace(h.spine, m2);
+    if (pb - pa <= 1e-6) return h;
+    const members: HighwayMember[] = h.members.map((m) => {
+      if (m.on <= m.off) {
+        const on = Math.max(m.on, pa);
+        const off = Math.min(m.off, pb);
+        return off - on > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+      }
+      const on = Math.min(m.on, pb);
+      const off = Math.max(m.off, pa);
+      return on - off > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+    });
+    return { ...h, members };
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/wspd/index.ts

@@ -0,0 +1,130 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `wspd` (HWY-018 of the note on highways). */
+export interface WspdOptions {
+  /** The separation `s` of the pairs: the gap between two sets is at least `s` times the radius of the larger set. The default is 2. */
+  readonly separation: number;
+  /** A pair with this number of edges or more gets a highway. The default is 3. */
+  readonly minSize: number;
+  /** The spine of each pair. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `wspd`. */
+export const WSPD_DEFAULTS: Readonly<WspdOptions> = Object.freeze({ separation: 2, minSize: 3, spine: "trunk" });
+
+/** A cell of the split tree: the points at the places `lo` to `hi - 1` of the order, with their bounding circle. */
+export interface SplitCell {
+  readonly id: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly c: Point;
+  readonly r: number;
+  readonly kids?: readonly [SplitCell, SplitCell];
+}
+
+/**
+ * The split tree of a set of points and its well-separated pairs (Callahan and Kosaraju 1995).
+ * Each cell splits at the middle of the longer side of its bounding box. A cell of equal points is a leaf.
+ */
+export class SplitTree {
+  readonly root: SplitCell;
+  /** The place of each point in the order of the tree. */
+  readonly #at: Int32Array;
+  #count = 0;
+
+  /** This constructor builds the tree of the points. */
+  constructor(points: readonly Point[]) {
+    const order = points.map((_, i) => i);
+    this.#at = new Int32Array(points.length);
+    this.root = this.#build(points, order, 0, points.length);
+    order.forEach((p, i) => (this.#at[p] = i));
+  }
+
+  #build(points: readonly Point[], order: number[], lo: number, hi: number): SplitCell {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (let i = lo; i < hi; i++) {
+      const p = points[order[i]!]!;
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+    const id = this.#count++;
+    const c = center({ x: x0, y: y0, w: x1 - x0, h: y1 - y0 });
+    const r = Math.hypot(x1 - x0, y1 - y0) / 2;
+    if (hi - lo <= 1 || r <= 1e-9) return { id, lo, hi, c, r };
+    const byX = x1 - x0 >= y1 - y0;
+    const cut = byX ? (x0 + x1) / 2 : (y0 + y1) / 2;
+    const part = order.slice(lo, hi);
+    const left = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) <= cut);
+    const right = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) > cut);
+    [...left, ...right].forEach((p, k) => (order[lo + k] = p));
+    const mid = lo + left.length;
+    return { id, lo, hi, c, r, kids: [this.#build(points, order, lo, mid), this.#build(points, order, mid, hi)] };
+  }
+
+  /** This method tells if the cell holds the point `i`. */
+  holds(cell: SplitCell, i: number): boolean {
+    const at = this.#at[i]!;
+    return at >= cell.lo && at < cell.hi;
+  }
+
+  /**
+   * This method gives the well-separated pair that holds the pair of points `u` and `v`, with the cell of `u` first.
+   * Each pair of two different points is in one pair of the decomposition. Two equal points give `undefined`.
+   */
+  pairOf(u: number, v: number, s: number): [SplitCell, SplitCell] | undefined {
+    let cell = this.root;
+    while (cell.kids) {
+      const next = cell.kids.find((k) => this.holds(k, u) && this.holds(k, v));
+      if (!next) break;
+      cell = next;
+    }
+    if (!cell.kids) return undefined;
+    let a = cell.kids.find((k) => this.holds(k, u))!;
+    let b = cell.kids.find((k) => this.holds(k, v))!;
+    for (;;) {
+      const r = Math.max(a.r, b.r);
+      if (dist(a.c, b.c) - 2 * r >= s * r) return [a, b];
+      if (a.r >= b.r && a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else if (b.kids) b = b.kids.find((k) => this.holds(k, v))!;
+      else if (a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else return [a, b];
+    }
+  }
+}
+
+/**
+ * This function gives the groups of the edges by the well-separated pair of their two nodes (HWY-018).
+ * The points are the centers of the boxes. The edges of one pair, in either direction, are one group.
+ */
+export function wspdGroups(input: HighwayInput, o: Readonly<WspdOptions>): Map<string, EdgeGroup> {
+  const nodes = input.graph.nodes;
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const tree = new SplitTree(nodes.map((n) => center(n.box)));
+  const groups = new Map<string, EdgeGroup>();
+  for (const e of input.graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined || u === v) continue;
+    const pair = tree.pairOf(u, v, o.separation);
+    if (!pair) continue;
+    const [a, b] = pair;
+    groups.set(e.id, a.id < b.id ? { key: `w${a.id}:${b.id}`, flip: false } : { key: `w${b.id}:${a.id}`, flip: true });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of clustered edge routing with the WSPD (HWY-018, after Bouts and Speckmann 2015).
+ * The well-separated pairs split all the pairs of nodes. The edges of one pair with `minSize` edges or more get one highway from one set to the other.
+ */
+export function wspdPlan(input: HighwayInput, o: Readonly<WspdOptions>): HighwayPlan {
+  return groupedPlan(input, wspdGroups(input, o), { spine: o.spine, minSize: o.minSize });
+}

package/src/highways/zipper/index.ts

@@ -0,0 +1,168 @@
+import { boardUnit, segmentKey } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import { Grid, segmentBounds } from "../../grid.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, orderAlongRoutes, planRoutes, routeIndex, tidyPlan, type HighwayBase } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `zipper` (NAT-022 with WILD-037 of the notes). */
+export interface ZipperOptions {
+  /** The plan whose routes the zipper joins. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two legs zip when they are this distance apart or nearer, in units of the board (the median short side of the boxes). The default is 1. */
+  readonly near: number;
+  /** Two legs zip when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly maxAngle: number;
+  /** The adhesion over the tension: two legs zip when `adhesion * overlap` is more than the length that the zip adds. The default is 0.3. */
+  readonly adhesion: number;
+  /** Two legs zip when they overlap along this length or more, in units of the board. The default is 1. */
+  readonly minOverlap: number;
+  /** The number of passes. Each pass routes the plan and zips the legs again. The default is 1. */
+  readonly passes: number;
+}
+
+/** The default options of the strategy `zipper`. */
+export const ZIPPER_DEFAULTS: Readonly<ZipperOptions> = Object.freeze({ from: "shared-ways", near: 1, maxAngle: 15, adhesion: 0.3, minOverlap: 1, passes: 1 });
+
+/** One leg of a route that no other route shares. */
+interface Leg {
+  readonly edge: string;
+  readonly a: Point;
+  readonly b: Point;
+  readonly len: number;
+}
+
+/** A pair of legs that can zip, with the line of the zip. */
+export interface Zip {
+  readonly gain: number;
+  /** The first point of the zipped line. */
+  readonly from: Point;
+  /** The last point of the zipped line. */
+  readonly to: Point;
+  /** This value is `true` when the leg goes from `from` to `to`, for each of the two legs. */
+  readonly forward: readonly [boolean, boolean];
+}
+
+/** The limits of `zipLegs`, in the units of the board. */
+export interface ZipLimits {
+  readonly near: number;
+  readonly maxAngle: number;
+  readonly adhesion: number;
+  readonly minOverlap: number;
+}
+
+/**
+ * This function tells if two legs zip (NAT-022), and gives the zipped line.
+ * The zipped line is the mean of the two legs, with the weight of their lengths, along the stretch where they overlap.
+ * The legs zip when the angle between them is `maxAngle` or less, and they are `near` or nearer along the overlap.
+ * The overlap must be `minOverlap` or more.
+ * The zip adds two jogs to each leg, so it adds the length `2 (d_a + d_b)`, with the distances of the legs to the zipped line.
+ * The legs zip only when `adhesion * overlap` is more than that length.
+ */
+export function zipLegs(a0: Point, a1: Point, b0: Point, b1: Point, o: ZipLimits): Zip | undefined {
+  const la = dist(a0, a1);
+  const lb = dist(b0, b1);
+  if (la <= 1e-9 || lb <= 1e-9) return undefined;
+  const ua = { x: (a1.x - a0.x) / la, y: (a1.y - a0.y) / la };
+  const ub = { x: (b1.x - b0.x) / lb, y: (b1.y - b0.y) / lb };
+  const dot = ua.x * ub.x + ua.y * ub.y;
+  if (Math.abs(dot) < Math.cos((o.maxAngle * Math.PI) / 180) - 1e-12) return undefined;
+  const sign = dot >= 0 ? 1 : -1;
+  const dx = ua.x * la + sign * ub.x * lb;
+  const dy = ua.y * la + sign * ub.y * lb;
+  const dl = Math.hypot(dx, dy);
+  if (dl <= 1e-9) return undefined;
+  const u = { x: dx / dl, y: dy / dl };
+  const o0 = { x: ((a0.x + a1.x) * la + (b0.x + b1.x) * lb) / (2 * (la + lb)), y: ((a0.y + a1.y) * la + (b0.y + b1.y) * lb) / (2 * (la + lb)) };
+  const along = (p: Point): number => (p.x - o0.x) * u.x + (p.y - o0.y) * u.y;
+  const across = (p: Point): number => (p.x - o0.x) * u.y - (p.y - o0.y) * u.x;
+  const ta = [along(a0), along(a1)] as const;
+  const tb = [along(b0), along(b1)] as const;
+  const lo = Math.max(Math.min(...ta), Math.min(...tb));
+  const hi = Math.min(Math.max(...ta), Math.max(...tb));
+  const overlap = hi - lo;
+  if (overlap < o.minOverlap || overlap <= 1e-9) return undefined;
+  // The offset of a leg from the zipped line at the place t along it.
+  const offset = (p0: Point, p1: Point, t0: number, t1: number, t: number): number => {
+    const s = Math.abs(t1 - t0) <= 1e-12 ? 0 : (t - t0) / (t1 - t0);
+    return across({ x: p0.x + (p1.x - p0.x) * s, y: p0.y + (p1.y - p0.y) * s });
+  };
+  let jog = 0;
+  for (const t of [lo, hi]) {
+    const da = offset(a0, a1, ta[0], ta[1], t);
+    const db = offset(b0, b1, tb[0], tb[1], t);
+    if (Math.abs(da - db) > o.near) return undefined;
+    jog += Math.abs(da) + Math.abs(db);
+  }
+  const gain = o.adhesion * overlap - jog;
+  if (!(gain > 0)) return undefined;
+  const from = { x: o0.x + u.x * lo, y: o0.y + u.y * lo };
+  const to = { x: o0.x + u.x * hi, y: o0.y + u.y * hi };
+  return { gain, from, to, forward: [ua.x * u.x + ua.y * u.y > 0, ub.x * u.x + ub.y * u.y > 0] };
+}
+
+/**
+ * This function gives the highways of the plan `from`, with the legs that run near and nearly parallel zipped together (NAT-022, WILD-037).
+ * A pass routes the plan with `follow` and takes each leg that no other route shares. A grid of the legs finds the near pairs.
+ * The pairs that zip (`zipLegs`) go from the largest gain to the smallest, and each leg zips one time in a pass at most.
+ * A zipped line that goes into a box, made larger by 1, does not zip.
+ * Each zip is a new highway of two members. The `seq` of each member follows the place of its merge point along the route of the edge.
+ */
+export function zipperPlan(input: HighwayInput, o: Readonly<ZipperOptions>): HighwayPlan {
+  const graph = input.graph;
+  const unit = boardUnit(graph);
+  const limits: ZipLimits = { near: o.near * unit, maxAngle: o.maxAngle, adhesion: o.adhesion, minOverlap: Math.max(1e-6, o.minOverlap * unit) };
+  const obstacles = new WayFinder(graph.nodes).obstacles;
+  let plan = basePlan(input, o.from);
+  for (let pass = 0; pass < Math.max(1, Math.round(o.passes)); pass++) {
+    const routes = planRoutes(graph, plan).routes;
+    const users = new Map<string, number>();
+    for (const r of routes) {
+      const own = new Set<string>();
+      for (let i = 1; i < r.points.length; i++) {
+        const k = segmentKey(r.points[i - 1]!, r.points[i]!);
+        if (k !== undefined) own.add(k);
+      }
+      for (const k of own) users.set(k, (users.get(k) ?? 0) + 1);
+    }
+    const legs: Leg[] = [];
+    for (const r of routes)
+      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);
+        const len = dist(a, b);
+        if (k === undefined || (users.get(k) ?? 0) > 1 || len < limits.minOverlap) continue;
+        legs.push({ edge: r.edge, a, b, len });
+      }
+    const grid = new Grid<number>(Math.max(32, 4 * limits.near));
+    legs.forEach((l, i) => {
+      const bx = segmentBounds(l.a, l.b);
+      grid.add(i, { x: bx.x - limits.near, y: bx.y - limits.near, w: bx.w + 2 * limits.near, h: bx.h + 2 * limits.near });
+    });
+    const found: { i: number; j: number; zip: Zip }[] = [];
+    legs.forEach((l, i) => {
+      grid.query(segmentBounds(l.a, l.b), (j) => {
+        if (j <= i || legs[j]!.edge === l.edge) return;
+        const m = legs[j]!;
+        const zip = zipLegs(l.a, l.b, m.a, m.b, limits);
+        if (zip) found.push({ i, j, zip });
+      });
+    });
+    found.sort((p, q) => q.zip.gain - p.zip.gain || p.i - q.i || p.j - q.j);
+    const used = new Set<number>();
+    const added: Highway[] = [];
+    for (const { i, j, zip } of found) {
+      if (used.has(i) || used.has(j)) continue;
+      if (!obstacles.clear(zip.from, zip.to, 1)) continue;
+      used.add(i);
+      used.add(j);
+      const spine = [zip.from, zip.to];
+      const members = [legs[i]!, legs[j]!].map((l, k) => (zip.forward[k] ? memberAt(spine, l.edge, 0, 1) : memberAt(spine, l.edge, 1, 0)));
+      added.push({ id: "", key: `zip${pass}`, spine, lanes: members.map((m) => m.edge), members });
+    }
+    if (added.length === 0) break;
+    plan = tidyPlan(orderAlongRoutes({ highways: [...plan.highways, ...added] }, routeIndex(routes)));
+  }
+  return tidyPlan(plan);
+}

package/src/index.ts

@@ -29,3 +29,5 @@ export * from "./strategies/index.ts";
 export * from "./bench/compare.ts";
 export * from "./bench/screen/index.ts";
 export * from "./highways/index.ts";
+export * from "./order/index.ts";
+export * from "./repair/index.ts";

package/src/order/index.ts

@@ -0,0 +1,65 @@
+import { fnv1a32 } from "../bench/screen/hash.ts";
+import { rng } from "../fixtures.ts";
+import type { Edge, Graph, Result, Router } from "../model.ts";
+import { defineStrategy, type Strategy } from "../strategies/model.ts";
+
+/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
+function byHash(a: { readonly h: number; readonly e: Edge }, b: { readonly h: number; readonly e: Edge }): number {
+  if (a.h !== b.h) return a.h - b.h;
+  return a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0;
+}
+
+/**
+ * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
+ * The nodes and the edges do not change. Two orders of the same edges give the same graph.
+ * The hash spreads the edges, so the stable order does not favor the edges of one node or one collection.
+ */
+export function stableOrder(graph: Graph): Graph {
+  const edges = graph.edges.map((e) => ({ h: fnv1a32(e.id), e })).sort(byHash).map((x) => x.e);
+  return { ...graph, edges };
+}
+
+/** This function gives the graph with its edges in a random order of the seed. The same graph and seed always give the same order. */
+export function shuffleEdges(graph: Graph, seed: number): Graph {
+  const edges = [...graph.edges];
+  const r = rng(seed);
+  for (let i = edges.length - 1; i > 0; i--) {
+    const j = Math.floor(r() * (i + 1));
+    [edges[i], edges[j]] = [edges[j]!, edges[i]!];
+  }
+  return { ...graph, edges };
+}
+
+/**
+ * This function routes the graph in the stable order of `stableOrder`, with the function `route`.
+ * The routes come back in the order of the input edges, so the caller sees no change of order.
+ * The bundles, the runs and the levels come from the stable order. Thus each order of the input gives the same data.
+ */
+export function routeInStableOrder(graph: Graph, route: (graph: Graph) => Result): Result {
+  const result = route(stableOrder(graph));
+  const index = new Map(graph.edges.map((e, i) => [e.id, i] as const));
+  const at = (edge: string): number => index.get(edge) ?? Number.MAX_SAFE_INTEGER;
+  const routes = [...result.routes].sort((a, b) => at(a.edge) - at(b.edge));
+  return { ...result, routes };
+}
+
+/** This function gives a router that routes each graph in the stable order of WILD-053. It keeps the name and the `maxNodes` of the router. */
+export function withStableOrder(router: Router): Router {
+  return { ...router, route: (graph: Graph): Result => routeInStableOrder(graph, (g) => router.route(g)) };
+}
+
+/**
+ * This function gives a router strategy that runs `strategy` in the stable order of WILD-053. The output does not depend on the order of the input edges.
+ * The new strategy has the name `<name>+stable`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+ */
+export function stableOrderStrategy<O extends object>(strategy: Strategy<"router", O>): Strategy<"router", O> {
+  return defineStrategy<"router", O>({
+    step: "router",
+    name: `${strategy.name}+stable`,
+    describe: `${strategy.describe} The edges go in a stable order: by a hash of their ids.`,
+    defaults: { ...strategy.defaults } as O,
+    ...(strategy.schema === undefined ? {} : { schema: strategy.schema }),
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    run: (graph: Graph, options: Readonly<O>): Result => routeInStableOrder(graph, (g) => strategy.run(g, options)),
+  });
+}

package/src/plugs/justify.ts

@@ -0,0 +1,48 @@
+/**
+ * Plug justification (WILD-002, with NAT-031): the plugs of one side keep their order and a minimum gap.
+ * They move the least distance from their ideal places.
+ */
+
+/**
+ * This function places `ideal.length` points on the segment from `lo` to `hi` of one side.
+ * The points keep the order of their ideal places. Two neighbours are at least `gap` apart, or the side divided evenly when it is too short.
+ * The sum of the squares of the moves is the least. The answer is exact: a fit by pool adjacent violators.
+ *
+ * The function `tie` orders two points with the same ideal place. The result is in the order of `ideal`.
+ */
+export function justifyPlugs(ideal: readonly number[], lo: number, hi: number, gap: number, tie?: (i: number) => number): number[] {
+  const k = ideal.length;
+  if (k === 0) return [];
+  const order = ideal.map((_, i) => i).sort((a, b) => ideal[a]! - ideal[b]! || (tie ? tie(a) - tie(b) : 0) || a - b);
+  const s = k > 1 ? Math.max(0, Math.min(gap, (hi - lo) / (k - 1))) : 0;
+  // With y_i = x_i - i·s, the gap becomes the rule y_i <= y_(i+1): an isotonic fit of a_i - i·s.
+  const y = isotonic(order.map((j, i) => ideal[j]! - i * s));
+  const top = Math.max(lo, hi - (k - 1) * s);
+  const out = new Array<number>(k);
+  order.forEach((j, i) => {
+    out[j] = Math.max(lo, Math.min(top, y[i]!)) + i * s;
+  });
+  return out;
+}
+
+/** This function gives the non-decreasing sequence nearest to `v` in the sum of squares (pool adjacent violators). */
+export function isotonic(v: readonly number[]): number[] {
+  const mean: number[] = [];
+  const size: number[] = [];
+  for (const x of v) {
+    mean.push(x);
+    size.push(1);
+    while (mean.length > 1 && mean[mean.length - 2]! > mean[mean.length - 1]!) {
+      const m = mean.pop()!;
+      const n = size.pop()!;
+      const i = mean.length - 1;
+      mean[i] = (mean[i]! * size[i]! + m * n) / (size[i]! + n);
+      size[i]! += n;
+    }
+  }
+  const out: number[] = [];
+  mean.forEach((m, i) => {
+    for (let j = 0; j < size[i]!; j++) out.push(m);
+  });
+  return out;
+}

package/src/plugs/side.ts

@@ -0,0 +1,138 @@
+/**
+ * Free plugs on a side (WILD-001): the search of a route starts from the whole free side, not from one point of it.
+ * Thus the first leg goes straight out to the first corner of the way, and the plug is the foot of that leg.
+ */
+import { center, dist, type Box, type Point } from "../geom.ts";
+import { fixedPortPoint, type End, type Node, type Side } from "../model.ts";
+import { placePlug, pointOnSide, SIDE_NORMAL, sideToward, type Plug } from "../plugs.ts";
+import type { Terminal } from "../visibility.ts";
+import type { WayFinder } from "../ways.ts";
+
+/** The options of `sidePlugs`. */
+export interface SidePlugOptions {
+  /** The cost of a slant first leg: the length of the leg grows by `bend` × its angle to the normal, in radians. The default is 1. */
+  readonly bend?: number;
+  /** The distance from a plug to a corner of its box. The default is 6, as in `pointOnSide`. */
+  readonly inset?: number;
+  /** The largest number of places that the search tries on each side. The default is 16. */
+  readonly most?: number;
+}
+
+/** A free side of one end: its node, its side and its range on the axis along the side. It also has the plug that faces the other end. */
+interface FreeSide {
+  readonly node: Node;
+  readonly side: Side;
+  readonly normal: Point;
+  /** The axis along the side. */
+  readonly along: "x" | "y";
+  /** The place of the side on the other axis. */
+  readonly at: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly facing: Plug;
+}
+
+/** A place that the search tries: the plug, and the free point where the search starts from it, with its cost. */
+interface Start extends Terminal {
+  readonly plug: Plug;
+}
+
+/** This function gives the free side of an end, or `undefined` when the plug of the end is fixed. */
+function freeSide(node: Node, end: End, toward: Point, inset: number): FreeSide | undefined {
+  if (fixedPortPoint(node, end)) return undefined;
+  const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+  const side = port?.side ?? sideToward(node.box, toward);
+  const b: Box = node.box;
+  const along = side === "east" || side === "west" ? "y" : "x";
+  const start = along === "y" ? b.y : b.x;
+  const len = along === "y" ? b.h : b.w;
+  const m = Math.min(inset, len / 4);
+  const at = side === "east" ? b.x + b.w : side === "west" ? b.x : side === "south" ? b.y + b.h : b.y;
+  const point = pointOnSide(b, side, toward, inset);
+  return { node, side, normal: SIDE_NORMAL[side], along, at, lo: start + m, hi: start + len - m, facing: { point, normal: SIDE_NORMAL[side] } };
+}
+
+/** This function gives the point of the side at `v` on the axis along the side. */
+function footAt(f: FreeSide, v: number): Point {
+  return f.along === "y" ? { x: f.at, y: v } : { x: v, y: f.at };
+}
+
+/**
+ * This function gives the places that the search tries on one free side. A place is the out point of a plug on the side.
+ * A place is also a corner in front of the side. The plug of a corner is the foot of the leg to it.
+ */
+function startsOf(ways: WayFinder, f: FreeSide, others: readonly number[], bend: number, most: number): Start[] {
+  const margin = ways.margin;
+  const pad = margin / 2;
+  const own = new Set<Node>([f.node]);
+  const starts: Start[] = [];
+  const out = (p: Point): Point => ({ x: p.x + f.normal.x * margin, y: p.y + f.normal.y * margin });
+  const plugAt = (v: number): Plug => ({ point: footAt(f, v), normal: f.normal });
+  // The plug that faces the other end is always a place of the search, so the search is never worse than the default.
+  starts.push({ plug: f.facing, point: out(f.facing.point), cost: margin });
+  const mid = (f.lo + f.hi) / 2;
+  for (const v of [f.lo, mid, f.hi, ...others]) {
+    if (v < f.lo - 1e-9 || v > f.hi + 1e-9) continue;
+    const p = out(footAt(f, v));
+    if (!ways.obstacles.inside(p, 0, f.node)) starts.push({ plug: plugAt(v), point: p, cost: margin });
+  }
+  // The corners in front of the side that its out points see.
+  const seen = new Set<number>();
+  for (const v of [f.lo, mid, f.hi, f.facing.point[f.along]]) for (const c of ways.corners.nearestVisible(out(footAt(f, v)), 16)) seen.add(c);
+  for (const c of seen) {
+    const q = ways.corners.points[c]!;
+    const across = f.along === "y" ? "x" : "y";
+    const depth = (q[across] - f.at) * f.normal[across];
+    if (depth < margin - 1e-9) continue;
+    const v = Math.max(f.lo, Math.min(f.hi, q[f.along]));
+    const foot = footAt(f, v);
+    const angle = Math.atan2(Math.abs(q[f.along] - v), depth);
+    if (angle > Math.PI / 4 + 1e-9) continue;
+    if (!ways.obstacles.clear(foot, q, pad, own)) continue;
+    starts.push({ plug: plugAt(v), point: q, cost: dist(foot, q) * (1 + bend * angle) });
+  }
+  // One place for each foot: the cheapest. The places nearest to the facing plug come first.
+  const best = new Map<number, Start>();
+  for (const s of starts) {
+    const key = Math.round(s.plug.point[f.along] * 2);
+    const old = best.get(key);
+    if (!old || s.cost < old.cost) best.set(key, s);
+  }
+  const facing = f.facing.point[f.along];
+  const list = [...best.values()].sort((a, b) => Math.abs(a.plug.point[f.along] - facing) - Math.abs(b.plug.point[f.along] - facing));
+  return list.slice(0, Math.max(1, most));
+}
+
+/**
+ * This function places the two plugs of an edge with a free side. A fixed plug stays at its point.
+ * The search (A*) starts from each place of the free side of the source. It ends at each place of the free side of the target.
+ * The plugs are the places of the shortest way. Without a way, the plugs face the other end, as `placePlug` places them.
+ */
+export function sidePlugs(ways: WayFinder, s: Node, es: End, t: Node, et: End, options: SidePlugOptions = {}): [Plug, Plug] {
+  const inset = options.inset ?? 6;
+  const ps = placePlug(s, es, center(t.box));
+  const pt = placePlug(t, et, center(s.box));
+  if (s === t) return [ps, pt];
+  const fs = freeSide(s, es, center(t.box), inset);
+  const ft = freeSide(t, et, center(s.box), inset);
+  if (!fs && !ft) return [ps, pt];
+  const bend = options.bend ?? 1;
+  const most = options.most ?? 16;
+  const fixed = (p: Plug): Start[] => [{ plug: p, point: ways.out(p), cost: ways.margin }];
+  // Two sides that face each other on one axis share the places of a straight line.
+  const facingPair = fs && ft && fs.along === ft.along && fs.normal.x === -ft.normal.x && fs.normal.y === -ft.normal.y;
+  const shared = (a: FreeSide | undefined, b: FreeSide | undefined, p: Plug): number[] => {
+    if (!a) return [];
+    if (facingPair && b) {
+      const lo = Math.max(a.lo, b.lo);
+      const hi = Math.min(a.hi, b.hi);
+      return lo <= hi ? [lo, (lo + hi) / 2, hi] : [];
+    }
+    return [p.point[a.along]];
+  };
+  const from = fs ? startsOf(ways, fs, shared(fs, ft, pt), bend, most) : fixed(ps);
+  const to = ft ? startsOf(ways, ft, shared(ft, fs, ps), bend, most) : fixed(pt);
+  const way = ways.corners.pathAmong(from, to);
+  if (!way) return [ps, pt];
+  return [from[way.from]!.plug, to[way.to]!.plug];
+}