@mark1russell7/highways 0.9.0 → 0.9.2

package/src/routers/attraction/index.ts

@@ -0,0 +1,61 @@
+import type { Graph, GroupRule, Result, Router } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import { sharedRouter } from "../shared.ts";
+import { byCollection } from "../trunks.ts";
+
+/** The options of the router `attraction` (HWY-044 of the note on highways: negotiated attraction, PathFinder turned around). */
+export interface AttractionOptions {
+  /** The number of passes, from 1 to 10. Each pass after the first routes each edge again from no ways. The default is 3. */
+  readonly passes: number;
+  /** The pull `a` of the history of a link, from 0 to 1. A link then costs `1 - a h` times more. The default is 0.5. */
+  readonly attraction: number;
+  /** The cost weight `b` of each edge over the capacity of a link, from 0 to 10. The default is 1. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width. The default is 4. */
+  readonly laneWidth: number;
+}
+
+/** The default options of the router `attraction`. */
+export const ATTRACTION_DEFAULTS: Readonly<AttractionOptions> = Object.freeze({ passes: 3, attraction: 0.5, capacityWeight: 1, laneWidth: 4 });
+
+/** The declarations of the options of the router `attraction` (HWY-044). */
+export const ATTRACTION_SCHEMA: OptionSchema<AttractionOptions> = {
+  passes: { type: "integer", min: 1, max: 10, step: 1, marks: [2, 3, 5], default: 3, describe: "The number of passes. Each later pass routes each edge again from no ways." },
+  attraction: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.25, 0.5, 0.75], default: 0.5, describe: "The pull of the history of a link. A busy link of the passes before costs less." },
+  capacityWeight: { type: "number", min: 0, max: 10, step: 0.5, marks: [0, 1, 4], default: 1, describe: "The cost weight of each edge over the capacity of a link." },
+  laneWidth: { type: "number", min: 1, max: 12, step: 1, marks: [4, 6], default: 4, describe: "The width of one lane. The capacity of a link is its free width divided by this width." },
+};
+
+/**
+ * This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+ * After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+ * In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+ * The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+ */
+export function attractionRouter(options: Partial<AttractionOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...ATTRACTION_DEFAULTS, ...options };
+  return sharedRouter(
+    { name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) },
+    {
+      passes: Math.max(1, Math.floor(o.passes)),
+      attraction: Math.min(1, Math.max(0, o.attraction)),
+      capacityWeight: Math.max(0, o.capacityWeight),
+      laneWidth: Math.max(1e-6, o.laneWidth),
+    },
+  );
+}
+
+/**
+ * The router strategy `attraction` (HWY-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export const attractionStrategy: Strategy<"router", AttractionOptions> = defineStrategy({
+  step: "router",
+  name: "attraction",
+  describe: "Negotiated attraction (HWY-044). The router `shared` routes each edge again in each pass, and the busy links of the passes before pull the edges.",
+  defaults: { ...ATTRACTION_DEFAULTS },
+  schema: ATTRACTION_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<AttractionOptions>): Result => attractionRouter({ ...o, name: "attraction", rule: byCollection }).route(graph),
+});

package/src/routers/corners.ts

@@ -1,16 +1,17 @@
 import { center, type Point } from "../geom.ts";
-import { nodeIndex, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, fixedPortPoint, resolvePorts, splitFrames, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { justifyPlugs } from "../plugs/justify.ts";
 import { sidePlugs } from "../plugs/side.ts";
 import type { PlugPair, Strategy } from "../strategies/model.ts";
-import { WayFinder, type WayOptions } from "../ways.ts";
+import { WayFinder } from "../ways.ts";
+import { frameRoutes, type FrameOptions } from "./frames.ts";
 
 /** The ways to place a free plug of the corner router. */
 export type PlugPlace = "facing" | "side";
 
 /** The options of the corner router. */
-export interface CornersOptions extends WayOptions {
+export interface CornersOptions extends FrameOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /** The benchmark skips a fixture with more nodes. */
@@ -38,14 +39,21 @@ export interface CornersOptions extends WayOptions {
  * This function makes a router that goes around the nodes.
  * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
  * of the box corners, without the needless corners. It enters the target plug along its normal.
+ * An inner edge (`splitFrames`) gets an inner route in the bounds of its frame (`frameRoutes`), after the outer routes.
  */
 export function cornersRouter(options: CornersOptions): Router {
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const { graph, inner } = splitFrames(resolvePorts(input));
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const routes: Route[] = [];
+      // The inner routes come after the outer routes.
+      const done = (): Result => {
+        if (inner.length > 0) routes.push(...frameRoutes(graph, inner, options));
+        return { routes };
+      };
       if (!options.plug && (options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
         for (const e of graph.edges) {
           const s = byId.get(e.source.node);
@@ -55,7 +63,7 @@ export function cornersRouter(options: CornersOptions): Router {
           const pt = placePlug(t, e.target, center(s.box));
           routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
         }
-        return { routes };
+        return done();
       }
       // First the plugs of each edge, then the gaps of the plugs of each side, then the ways between the plugs.
       const ends: [Edge, Node, Node, Plug, Plug][] = [];
@@ -74,7 +82,7 @@ export function cornersRouter(options: CornersOptions): Router {
       }
       if ((options.plugGap ?? 0) > 0) spacePlugs(ends, options.plugGap!);
       for (const [e, s, t, ps, pt] of ends) routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
-      return { routes };
+      return done();
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
@@ -104,8 +112,7 @@ function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number): void {
       [e.source, s, ps, pt, 3],
       [e.target, t, pt, ps, 4],
     ] as const) {
-      const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
-      if (port?.at !== undefined) continue;
+      if (fixedPortPoint(node, end) !== undefined) continue;
       const key = JSON.stringify([node.id, plug.normal.x, plug.normal.y]);
       let side = sides.get(key);
       if (!side) sides.set(key, (side = { node, normal: plug.normal, items: [] }));

package/src/routers/frames.ts

@@ -0,0 +1,136 @@
+import { center, dist, type Box, type Point } from "../geom.ts";
+import { nodeIndex, type Graph, type InnerEdge, type Node, type Route } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/**
+ * The rule for a node box that is not fully inside the box of its frame.
+ * With `throw`, the router throws a `RangeError`. With `skip`, the node is not an obstacle, and its inner edges get no route.
+ * With `clamp`, the router cuts the box to the bounds of the frame.
+ */
+export type Outside = "throw" | "skip" | "clamp";
+
+/** The options of the inner routes: the options of the way finder, the rule `outside` and the inset `frameInset`. */
+export interface FrameOptions extends WayOptions {
+  /** The rule for a node box outside the box of its frame. The default is `throw`. */
+  readonly outside?: Outside;
+  /** The distance from the walls of a frame to the bounds of its inner routes. The default is the margin of the router. */
+  readonly frameInset?: number;
+}
+
+/** The inside of one frame for the inner edges to one depth: the bounds, the way finder and the obstacles by id. */
+interface Room {
+  readonly ways: WayFinder;
+  readonly nodes: ReadonlyMap<string, Node>;
+}
+
+/** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
+const EPS = 1e-6;
+
+/**
+ * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
+ * the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
+ * It leaves the plug of the frame into the frame, along the normal of the wall. Each route has the id of its frame in `frame`.
+ */
+export function frameRoutes(graph: Graph, inner: readonly InnerEdge[], options: FrameOptions): Route[] {
+  const byId = nodeIndex(graph);
+  const children = new Map<string, Node[]>();
+  for (const n of graph.nodes) {
+    if (n.parent === undefined) continue;
+    const list = children.get(n.parent);
+    if (list) list.push(n);
+    else children.set(n.parent, [n]);
+  }
+  const margin = options.margin ?? 5;
+  const inset = options.frameInset ?? margin;
+  const rooms = new Map<string, Room>();
+  const routes: Route[] = [];
+  for (const { edge, frame, plug } of inner) {
+    const f = byId.get(frame)!;
+    const [own, far] = plug === "source" ? [edge.source, edge.target] : [edge.target, edge.source];
+    // The nodes between the frame and the far end: each of them holds the far end, so it is not an obstacle.
+    const chain: string[] = [];
+    for (let p = byId.get(far.node)!.parent!; p !== frame; p = byId.get(p)!.parent!) chain.push(p);
+    const key = JSON.stringify([frame, ...chain]);
+    let room = rooms.get(key);
+    if (!room) rooms.set(key, (room = makeRoom(f, chain, children, byId, inset, options)));
+    const end = room.nodes.get(far.node);
+    if (!end) continue;
+    const fp = placePlug(f, own, center(end.box));
+    const inward = { x: -fp.normal.x, y: -fp.normal.y };
+    // The way starts on the bounds, straight in from the plug of the wall.
+    const start: Plug = { point: { x: fp.point.x + inward.x * inset, y: fp.point.y + inward.y * inset }, normal: inward };
+    const ep = placePlug(end, far, fp.point);
+    const ends = new Set<Node>([end]);
+    const points =
+      plug === "source" ? stub(fp.point, room.ways.between(start, ep, ends)) : stub(fp.point, room.ways.between(ep, start, ends).reverse()).reverse();
+    routes.push({ edge: edge.id, points, frame });
+  }
+  return routes;
+}
+
+/** This function puts the plug of the wall before a way that starts on the bounds. A first point on the line of the stub goes. */
+function stub(plug: Point, way: Point[]): Point[] {
+  const [a, b] = way;
+  if (!a || dist(a, plug) === 0) return way;
+  if (b && Math.abs((a.x - plug.x) * (b.y - plug.y) - (a.y - plug.y) * (b.x - plug.x)) < 1e-9 && (a.x - plug.x) * (b.x - a.x) + (a.y - plug.y) * (b.y - a.y) > 0)
+    return [plug, ...way.slice(1)];
+  return [plug, ...way];
+}
+
+/**
+ * This function makes the room of a frame for the far ends below the nodes of `chain` (the nearest first).
+ * The obstacles are the children of the frame and of each node of the chain, except the nodes of the chain.
+ * Four walls close the bounds, so that no way leaves them.
+ */
+function makeRoom(f: Node, chain: readonly string[], children: ReadonlyMap<string, readonly Node[]>, byId: ReadonlyMap<string, Node>, inset: number, options: FrameOptions): Room {
+  const margin = options.margin ?? 5;
+  const bounds = shrink(f.box, inset);
+  const skip = new Set(chain);
+  const nodes = new Map<string, Node>();
+  for (const holder of [f.id, ...chain]) {
+    for (const n of children.get(holder) ?? []) {
+      if (skip.has(n.id)) continue;
+      const box = byId.get(holder)!.box;
+      if (inside(n.box, box)) {
+        nodes.set(n.id, n);
+        continue;
+      }
+      const rule = options.outside ?? "throw";
+      if (rule === "throw")
+        throw new RangeError(`The box of the node "${n.id}" is not inside the box of its frame "${holder}". The option outside can skip or clamp it.`);
+      if (rule === "skip") continue;
+      const cut = cutBox(n.box, bounds);
+      if (cut) nodes.set(n.id, { ...n, box: cut, ...(n.ports ? { ports: n.ports.map((p) => (p.at ? { ...p, at: { x: p.at.x + n.box.x - cut.x, y: p.at.y + n.box.y - cut.y } } : p)) } : {}) });
+    }
+  }
+  // The band of each wall starts half a margin outside the bounds, so that a way keeps in the bounds.
+  const w = shrink(bounds, -(margin / 2 + EPS));
+  const t = 2 * margin + 1;
+  const walls: Node[] = [
+    { x: w.x - t, y: w.y - t, w: w.w + 2 * t, h: t },
+    { x: w.x - t, y: w.y + w.h, w: w.w + 2 * t, h: t },
+    { x: w.x - t, y: w.y, w: t, h: w.h },
+    { x: w.x + w.w, y: w.y, w: t, h: w.h },
+  ].map((box, i) => ({ id: `\u0000wall${i}`, box }));
+  return { ways: new WayFinder([...nodes.values(), ...walls], options), nodes };
+}
+
+/** This function gives the box, smaller by `d` on each side. A negative `d` makes it larger. */
+function shrink(b: Box, d: number): Box {
+  return { x: b.x + d, y: b.y + d, w: Math.max(0, b.w - 2 * d), h: Math.max(0, b.h - 2 * d) };
+}
+
+/** This function tells if the box `a` is inside the box `b`. */
+function inside(a: Box, b: Box): boolean {
+  return a.x >= b.x && a.y >= b.y && a.x + a.w <= b.x + b.w && a.y + a.h <= b.y + b.h;
+}
+
+/** This function gives the part of the box `a` inside the box `b`, or `undefined` when they have no common area. */
+function cutBox(a: Box, b: Box): Box | undefined {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const w = Math.min(a.x + a.w, b.x + b.w) - x;
+  const h = Math.min(a.y + a.h, b.y + b.h) - y;
+  return w > 0 && h > 0 ? { x, y, w, h } : undefined;
+}

package/src/routers/index.ts

@@ -9,7 +9,9 @@ import { byCollection, trunksRouter } from "./trunks.ts";
 export { boxExit, straightRouter } from "./straight.ts";
 export { plugsRouter } from "./plugs.ts";
 export { cornersRouter, type CornersOptions } from "./corners.ts";
-export { sharedRouter, type ShareCost, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
+export { frameRoutes, type FrameOptions, type Outside } from "./frames.ts";
+export { sharedRouter, type ShareCost, type SharedNegotiation, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
+export { ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, attractionRouter, attractionStrategy, type AttractionOptions } from "./attraction/index.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";
 export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunkFan, type TrunkSplit, type TrunksOptions } from "./trunks.ts";
 

package/src/routers/plugs.ts

@@ -1,6 +1,6 @@
 import { inflectionCurve } from "../curves.ts";
 import { center } from "../geom.ts";
-import { nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, outerGraph, type Graph, type Result, type Route, type Router } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 
 /**
@@ -9,7 +9,8 @@ import { placePlug } from "../plugs.ts";
  */
 export const plugsRouter: Router = {
   name: "plugs",
-  route(graph: Graph): Result {
+  route(input: Graph): Result {
+    const graph = outerGraph(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/sections.ts

@@ -2,7 +2,7 @@ import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
 import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
 import { LEVEL_LINK_DEFAULTS, type LevelLinkOptions } from "../levels.ts";
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
-import { nodeIndex, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 import { allSections, buildSections, checkSections, SECTION_DEFAULTS, type Section, type SectionOptions } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -91,7 +91,8 @@ const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || d
 export function sectionsRouter(options: SectionsOptions): Router {
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = outerGraph(input);
       const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
       const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
       const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;

package/src/routers/shared.ts

@@ -1,5 +1,5 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { channelWidth } from "../channels.ts";
 import { orderRun } from "../lane-order.ts";
 import { stretchLaneOrders, type LaneStretchOrder } from "../lane-orders/stretch/index.ts";
@@ -77,6 +77,21 @@ export interface SharedOptions extends WayOptions {
   readonly maxNodes?: number;
 }
 
+/**
+ * The negotiation of the router `attraction` (HWY-044, PathFinder turned around). Each pass routes each edge again from no ways.
+ * A link costs `len (1 - attraction h) (1 + weight max(0, use - cap))` more than in `shared`, with `h` the history of the link.
+ */
+export interface SharedNegotiation {
+  /** The number of passes, 1 or more. */
+  readonly passes: number;
+  /** The pull of the history of a link, from 0 to 1. */
+  readonly attraction: number;
+  /** The cost weight of each edge over the capacity of a link, 0 or more. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width, and 1 or more. */
+  readonly laneWidth: number;
+}
+
 /** A way of one edge through the corner graph. */
 export interface Way {
   readonly edge: Edge;
@@ -114,7 +129,7 @@ function turn(from: Point, base: Point, to: Point): number {
  * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
  * The result gives each stretch as a run, with the order of its lanes.
  */
-export function sharedRouter(options: SharedOptions): Router {
+export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation): Router {
   const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
   const flow = options.cost === "flow";
   const alpha = Math.min(1, Math.max(0.1, options.alpha ?? 0.6));
@@ -133,7 +148,8 @@ export function sharedRouter(options: SharedOptions): Router {
   };
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = outerGraph(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const corners = ways.corners;
@@ -172,8 +188,11 @@ export function sharedRouter(options: SharedOptions): Router {
         if (wd === undefined) widths.set(k, (wd = channelWidth(ways.obstacles, corners.points[i]!, corners.points[j]!)));
         return wd;
       };
-      /** This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`. */
-      const route = (w: Way, before?: ReadonlyMap<number, number>): void => {
+      /**
+       * This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`.
+       * `history` holds the history of each link of the key, for the negotiation of `attraction`.
+       */
+      const route = (w: Way, before?: ReadonlyMap<number, number>, history?: ReadonlyMap<number, number>): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
@@ -192,6 +211,20 @@ export function sharedRouter(options: SharedOptions): Router {
           cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
           floor /= (1 + reuse * most) ** reuseExponent;
         }
+        if (negotiation !== undefined && history !== undefined) {
+          const plain = cost;
+          const a = negotiation.attraction;
+          const b = negotiation.capacityWeight;
+          let most = 0;
+          for (const h of history.values()) most = Math.max(most, h);
+          cost = (i, j, d) => {
+            const k = link(i, j);
+            const use = (mine.get(k)?.length ?? 0) + 1;
+            const cap = Math.max(1, Math.floor(widthOf(i, j) / negotiation.laneWidth));
+            return plain(i, j, d) * (1 - a * (history.get(k) ?? 0)) * (1 + b * Math.max(0, use - cap));
+          };
+          floor *= 1 - a * most;
+        }
         const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
         if (!way) return;
         w.found = true;
@@ -207,9 +240,39 @@ export function sharedRouter(options: SharedOptions): Router {
           if (flow) top.set(w.key, Math.max(top.get(w.key) ?? 0, mine.get(link(a, b))!.length));
         }
       };
-      for (const w of order) route(w);
+      /**
+       * This function gives the passes of the negotiation (HWY-044). After each pass, the history of each link grows by `use / m`,
+       * with `m` the edges of the key, up to `0.9 / attraction`. Each later pass routes each edge again from no ways.
+       */
+      const negotiate = (list: readonly Way[]): void => {
+        const nego = negotiation!;
+        const histories = new Map<string, Map<number, number>>();
+        const size = new Map<string, number>();
+        for (const w of list) size.set(w.key, (size.get(w.key) ?? 0) + 1);
+        const most = nego.attraction > 0 ? 0.9 / nego.attraction : Infinity;
+        for (let pass = 0; pass < Math.max(1, Math.floor(nego.passes)); pass++) {
+          if (pass > 0) {
+            for (const [key, links] of discounted) {
+              let h = histories.get(key);
+              if (!h) histories.set(key, (h = new Map()));
+              const m = size.get(key) ?? 1;
+              for (const [k, users] of links) h.set(k, Math.min(most, (h.get(k) ?? 0) + users.length / m));
+            }
+            discounted.clear();
+            top.clear();
+            for (const w of list) {
+              w.found = false;
+              w.seq = [];
+              w.ids = [];
+            }
+          }
+          for (const w of list) route(w, undefined, histories.get(w.key) ?? new Map());
+        }
+      };
+      if (negotiation !== undefined) negotiate(order);
+      else for (const w of order) route(w);
       // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
-      for (let pass = 1; pass < passes; pass++) {
+      for (let pass = 1; negotiation === undefined && pass < passes; pass++) {
         if (reuse > 0) {
           // Winding Roads (HWY-005): each edge finds its way again from no ways, and the busy links of the pass before pull it.
           const before = new Map<string, Map<number, number>>();

package/src/routers/straight.ts

@@ -1,5 +1,5 @@
 import { center, type Box, type Point } from "../geom.ts";
-import { fixedPortPoint, nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { fixedPortPoint, nodeIndex, outerGraph, type Graph, type Result, type Route, type Router } from "../model.ts";
 
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export function boxExit(box: Box, toward: Point): Point {
@@ -19,7 +19,8 @@ export function boxExit(box: Box, toward: Point): Point {
  */
 export const straightRouter: Router = {
   name: "straight",
-  route(graph: Graph): Result {
+  route(input: Graph): Result {
+    const graph = outerGraph(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/trunks.ts

@@ -1,5 +1,5 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
@@ -209,7 +209,8 @@ export function trunksRouter(options: TrunksOptions): Router {
   const rule = groupRuleOf(options.rule);
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = outerGraph(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const points = new Map<string, readonly Point[]>();

package/src/strategies/builtins.ts

@@ -44,6 +44,11 @@ import { TERRITORY_DEFAULTS, territoryPlan, type TerritoryOptions } from "../hig
 import { CONSENSUS_DEFAULTS, consensusPlan, type ConsensusOptions } from "../highways/consensus/index.ts";
 import { P_HUB_DEFAULTS, pHubPlan, type PHubOptions } from "../highways/p-hub/index.ts";
 import { SCALE_SPACE_DEFAULTS, scaleSpacePlan, type ScaleSpaceOptions } from "../highways/scale-space/index.ts";
+import { GAP_DEFAULTS, gapPlan, type GapOptions } from "../highways/gaps/index.ts";
+import { INTERCHANGE_DEFAULTS, interchangePlan, type InterchangeOptions } from "../highways/interchanges/index.ts";
+import { SEARCH_DEFAULTS, searchPlan, type SearchOptions } from "../highways/search/index.ts";
+import { STEINER_DEFAULTS, steinerPlan, type SteinerOptions } from "../highways/steiner/index.ts";
+import { STREET_DEFAULTS, streetPlan, type StreetOptions } from "../highways/streets/index.ts";
 import { RIDGE_DEFAULTS, ridgePlan, type RidgeOptions } from "../highways/ridges/index.ts";
 import { SOFT_KEY_DEFAULTS, softKeyPlan, type SoftKeyOptions } from "../highways/soft-keys/index.ts";
 import { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FlowFieldOptions } from "../highways/flow-field/index.ts";
@@ -83,7 +88,7 @@ import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type
 import type { OptionSchema } from "./options.ts";
 import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
 import { DEPTHS_SCHEMA, PIPELINE_SCHEMA } from "./schemas.ts";
-import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_SCHEMA } from "./schemas.ts";
 
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
@@ -462,6 +467,11 @@ export const highwayStrategies: {
   readonly consensus: Strategy<"highway", ConsensusOptions>;
   readonly "p-hub": Strategy<"highway", PHubOptions>;
   readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
+  readonly steiner: Strategy<"highway", SteinerOptions>;
+  readonly gaps: Strategy<"highway", GapOptions>;
+  readonly streets: Strategy<"highway", StreetOptions>;
+  readonly search: Strategy<"highway", SearchOptions>;
+  readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -892,6 +902,51 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<ScaleSpaceOptions>) => scaleSpacePlan(input, o),
   }),
+  steiner: defineStrategy({
+    step: "highway",
+    name: "steiner",
+    describe: "Obstacle-avoiding rectilinear Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree, and the stretches that edges share become highways.",
+    defaults: { ...STEINER_DEFAULTS } as SteinerOptions,
+    schema: STEINER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SteinerOptions>) => steinerPlan(input, o),
+  }),
+  gaps: defineStrategy({
+    step: "highway",
+    name: "gaps",
+    describe: "Gap highways (HWY-057). The free middle lines of the gaps are streets, and a street that enough edges choose becomes a highway.",
+    defaults: { ...GAP_DEFAULTS } as GapOptions,
+    schema: GAP_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<GapOptions>) => gapPlan(input, o),
+  }),
+  streets: defineStrategy({
+    step: "highway",
+    name: "streets",
+    describe: "Orthogonal streets by a greedy set cover (HWY-058). Each step takes the street that its new edges ride the most per unit of its length.",
+    defaults: { ...STREET_DEFAULTS } as StreetOptions,
+    schema: STREET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<StreetOptions>) => streetPlan(input, o),
+  }),
+  search: defineStrategy({
+    step: "highway",
+    name: "search",
+    describe: "A local search over the set of highways (HWY-059). The annealing adds, drops and moves highways, edges and points on a score of the bundle measures.",
+    defaults: { ...SEARCH_DEFAULTS } as SearchOptions,
+    schema: SEARCH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SearchOptions>) => searchPlan(input, o),
+  }),
+  interchanges: defineStrategy({
+    step: "highway",
+    name: "interchanges",
+    describe: "A network of highways with interchanges (HWY-060). Each edge rides up to a number of highways, with a cost for each change.",
+    defaults: { ...INTERCHANGE_DEFAULTS } as InterchangeOptions,
+    schema: INTERCHANGE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<InterchangeOptions>) => interchangePlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),