@mark1russell7/highways 0.8.1 → 0.9.1

package/src/levels/depths/index.ts

@@ -0,0 +1,57 @@
+import { levelLinks, type ItemPair, type LevelLinkOptions } from "../../levels.ts";
+import type { Level, Route } from "../../model.ts";
+import { levelCut, treeDepth } from "../../sections.ts";
+import type { LevelInput } from "../../strategies/model.ts";
+
+/** The options of the level strategy `depths`: the limits of the level links, and the depths that get a level with groups. */
+export interface DepthLevelOptions extends Omit<LevelLinkOptions, "smooth"> {
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+}
+
+/**
+ * This function gives the zoom levels of the level strategy `depths`.
+ * It gives one level for each depth of the tree, and a last level with each node alone.
+ * It is the default of the router `sections`. With the option `levels`, only those depths get a level with groups.
+ * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
+ * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
+ * In the last level, the points of a link are the route of its first edge.
+ */
+export function depthLevels(input: LevelInput, options: DepthLevelOptions = {}): Level[] {
+  const { graph, root } = input;
+  const routeOf = new Map<string, Route>(input.routes.map((r) => [r.edge, r]));
+  const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+  const levels: Level[] = [];
+  const deepest = treeDepth(root);
+  const shown = options.levels && new Set(options.levels);
+  for (let d = 0; d <= deepest + 1; d++) {
+    if (shown && d <= deepest && !shown.has(d)) continue;
+    const { items, owner } = levelCut(graph.nodes, root, d);
+    const links = new Map<string, { source: string; target: string; count: number; edge: string }>();
+    for (const e of graph.edges) {
+      const iu = indexOfNode.get(e.source.node);
+      const iv = indexOfNode.get(e.target.node);
+      if (iu === undefined || iv === undefined) continue;
+      const a = owner[iu]!;
+      const b = owner[iv]!;
+      if (a === b) continue;
+      const ida = items[a]!.id;
+      const idb = items[b]!.id;
+      const key = `${ida}\u0000${idb}`;
+      const link = links.get(key);
+      if (link) {
+        link.count++;
+        continue;
+      }
+      links.set(key, { source: ida, target: idb, count: 1, edge: e.id });
+    }
+    const pairs: ItemPair[] = [...links.values()].map(({ source, target, count }) => ({ source, target, count }));
+    if (d > deepest)
+      levels.push({ depth: d, items, links: [...links.values()].map(({ edge, ...l }) => ({ ...l, points: routeOf.get(edge)?.points ?? [] })) });
+    else levels.push({ depth: d, items, links: levelLinks(items, pairs, options) });
+  }
+  return levels;
+}

package/src/model.ts

@@ -1,3 +1,4 @@
+import { portPoint } from "@mark1russell7/layout-contract";
 import type { Box, Point } from "./geom.ts";
 
 /** A side of a node box. */
@@ -5,7 +6,8 @@ export type Side = "north" | "east" | "south" | "west";
 
 /**
  * A plug of a node: a place where edges go into the node.
- * A plug with `at` is fixed. The router does not move it. A plug without `at` is free: the router places it.
+ * A plug with `at` is fixed. The router does not move it. A plug with `side` and `along` is fixed too.
+ * Another plug is free: the router places it.
  */
 export interface Port {
   readonly id: string;
@@ -13,6 +15,12 @@ export interface Port {
   readonly at?: Point;
   /** This side is where a free plug goes. Without it, the router picks the side. */
   readonly side?: Side;
+  /**
+   * This fraction from 0 to 1 fixes the plug on its `side`. The plug is at the side start plus `along` times the side length.
+   * The start of `north` and `south` is the left end. The start of `east` and `west` is the top end.
+   * A plug with `along` needs a `side` and has no `at`. `resolvePorts` throws a `RangeError` for a bad value.
+   */
+  readonly along?: number;
 }
 
 /** A node: a box that routes must not go through. */
@@ -131,10 +139,58 @@ export function nodeIndex(g: Graph): Map<string, Node> {
   return m;
 }
 
-/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+/** The names of the sides in `@mark1russell7/layout-contract`. */
+const CONTRACT_SIDE = { north: "top", east: "right", south: "bottom", west: "left" } as const;
+
+/**
+ * This function gives the place of a fixed plug, relative to the top-left corner of the node box, or `undefined` for a free plug.
+ * A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
+ */
+export function portOffset(box: Box, port: Port): Point | undefined {
+  if (port.at !== undefined) return port.at;
+  if (port.side === undefined || port.along === undefined) return undefined;
+  return portPoint(box, { id: port.id, side: CONTRACT_SIDE[port.side], along: port.along });
+}
+
+/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+export function checkPort(node: Node, port: Port): void {
+  if (port.along === undefined) return;
+  const at = `The plug "${port.id}" of the node "${node.id}"`;
+  if (typeof port.along !== "number" || !Number.isFinite(port.along) || port.along < 0 || port.along > 1)
+    throw new RangeError(`${at} has the along value ${String(port.along)}. It must be a finite number from 0 to 1.`);
+  if (port.side === undefined) throw new RangeError(`${at} has an along value and no side. A plug with along needs a side.`);
+  if (port.at !== undefined) throw new RangeError(`${at} has an along value and an at point. Give one of the two.`);
+}
+
+/**
+ * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
+ * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
+ * It throws a `RangeError` for a bad `along` (`checkPort`).
+ */
+export function resolvePorts(graph: Graph): Graph {
+  let found = false;
+  for (const n of graph.nodes)
+    for (const p of n.ports ?? []) {
+      checkPort(n, p);
+      if (p.along !== undefined) found = true;
+    }
+  if (!found) return graph;
+  const nodes = graph.nodes.map((n): Node => {
+    if (!n.ports?.some((p) => p.along !== undefined)) return n;
+    const ports = n.ports.map((p): Port => {
+      if (p.along === undefined) return p;
+      return { id: p.id, side: p.side!, at: portOffset(n.box, p)! };
+    });
+    return { ...n, ports };
+  });
+  return { ...graph, nodes };
+}
+
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
 export function fixedPortPoint(node: Node, end: End): Point | undefined {
   if (end.port === undefined) return undefined;
   const p = node.ports?.find((q) => q.id === end.port);
-  if (p?.at === undefined) return undefined;
-  return { x: node.box.x + p.at.x, y: node.box.y + p.at.y };
+  const at = p === undefined ? undefined : portOffset(node.box, p);
+  if (at === undefined) return undefined;
+  return { x: node.box.x + at.x, y: node.box.y + at.y };
 }

package/src/plugs/facing/index.ts

@@ -0,0 +1,22 @@
+import { center } from "../../geom.ts";
+import { nodeIndex } from "../../model.ts";
+import { placePlug } from "../../plugs.ts";
+import type { PlugPair, PlugInput } from "../../strategies/model.ts";
+
+/**
+ * This function gives the plugs of the plug strategy `facing`: each free plug faces the other end of its edge (`placePlug`).
+ * A fixed plug stays at its point, and a plug with a side stays on that side. It is the default of the router `corners`.
+ * The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export function facingEnds(input: PlugInput): PlugPair[] {
+  const { graph } = input;
+  const byId = nodeIndex(graph);
+  const out: PlugPair[] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    out.push({ edge: e.id, source: placePlug(s, e.source, center(t.box)), target: placePlug(t, e.target, center(s.box)) });
+  }
+  return out;
+}

package/src/portfolio/router.ts

@@ -4,6 +4,7 @@
 import { pickMoves, portfolio, type Member, type PortfolioTrace } from "../bench/screen/portfolio-pick.ts";
 import type { Graph, Result, Router } from "../model.ts";
 import { asRouter, defineStrategy, type Strategy } from "../strategies/model.ts";
+import type { OptionSchema } from "../strategies/options.ts";
 import { PORTFOLIO_CAPS, PORTFOLIO_KS_API, PORTFOLIO_RULES, portfolioBand, type PortfolioCap, type PortfolioRule } from "./bands.ts";
 import { PORTFOLIO_FIT } from "./fit.ts";
 import { portfolioKey } from "./key.ts";
@@ -135,6 +136,47 @@ export function portfolioRouter(options: PortfolioRouterOptions = {}): Router {
   return { name: portfolioName(options), maxNodes: 10_000, route: (graph) => routePortfolio(graph, options).result };
 }
 
+/** The largest count of members after the base: the largest list of the fit and of the sets. */
+const MAX_AFTER_BASE = Math.max(...PORTFOLIO_KS_API, ...Object.values(PORTFOLIO_FIT).map((l) => l.length), ...Object.values(PORTFOLIO_SETS).map((l) => l.length));
+
+/**
+ * The declarations of the options of the portfolio router (SCHEMA-GAPS). The lists of values come from the constants, so a new rule or cap needs no change here.
+ * The option `now` has no declaration. It is a clock for the tests, not a choice of the layout, and no control or sweep can set a function.
+ */
+const PORTFOLIO_SCHEMA: OptionSchema<Omit<PortfolioRouterOptions, "now">> = {
+  rule: { type: "enum", values: PORTFOLIO_RULES, default: "collection", describe: "With `collection`, a shared segment holds edges of one collection only. With `all`, collections can mix." },
+  cap: {
+    type: "number",
+    min: Math.min(...PORTFOLIO_CAPS),
+    max: Math.max(...PORTFOLIO_CAPS),
+    values: PORTFOLIO_CAPS,
+    default: 1.5,
+    describe: "The stretch cap. An output with an edge above the cap does not win.",
+  },
+  k: {
+    type: "integer",
+    min: Math.min(...PORTFOLIO_KS_API),
+    max: Math.max(...PORTFOLIO_KS_API),
+    values: PORTFOLIO_KS_API,
+    describe: "The count of members after the base. Without it, the router uses the fit of the size band.",
+  },
+  budgetMs: {
+    type: "integer",
+    min: 0,
+    max: 10_000,
+    step: 10,
+    describe: "The time limit of the pick in milliseconds. Without it, there is no limit. A cut by the limit makes the output depend on the machine.",
+  },
+  maxMembers: {
+    type: "integer",
+    min: 1,
+    max: 1 + MAX_AFTER_BASE,
+    step: 1,
+    describe: "The largest count of members that run, with the base. Without it, each member of the pick runs.",
+  },
+  hashes: { type: "enum", values: PORTFOLIO_HASHES, default: "pick", describe: "With `pick`, only the base and the winner get an output hash in the trace. With `all`, each member gets one." },
+};
+
 /**
  * The portfolio router as a router strategy. It is not in the registry `STRATEGIES`, so the benchmark and the site do not race it by default.
  * A caller adds it to a registry of its own, or calls `routePortfolio` for the trace.
@@ -144,6 +186,8 @@ export const portfolioStrategy: Strategy<"router", PortfolioRouterOptions> = def
   name: "portfolio",
   describe: "The portfolio router (PORTFOLIO-API). It runs `shared` and the fit of the size band, and gives the output with the most ink saved inside the rule and the cap.",
   defaults: { rule: "collection", cap: 1.5 },
+  // The schema leaves out the clock `now`, so its type is the options without `now`.
+  schema: PORTFOLIO_SCHEMA as OptionSchema<PortfolioRouterOptions>,
   maxNodes: 10_000,
   run: (graph, options) => routePortfolio(graph, options).result,
 });

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,8 +1,9 @@
 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, 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";
 
 /** The ways to place a free plug of the corner router. */
@@ -24,6 +25,13 @@ export interface CornersOptions extends WayOptions {
    * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
    */
   readonly plugGap?: number;
+  /**
+   * The plug rule: a strategy of the step `plugs` that places the plugs of each edge. It takes the place of the option `plugs`.
+   * Without it, the router places the plugs with the option `plugs`. An edge without plugs from the strategy gets the plugs of `facing`.
+   */
+  readonly plug?: Strategy<"plugs">;
+  /** The options of the strategy `plug`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly plugOptions?: object;
 }
 
 /**
@@ -34,11 +42,12 @@ export interface CornersOptions extends WayOptions {
 export function cornersRouter(options: CornersOptions): Router {
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const routes: Route[] = [];
-      if ((options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
+      if (!options.plug && (options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
         for (const e of graph.edges) {
           const s = byId.get(e.source.node);
           const t = byId.get(e.target.node);
@@ -51,12 +60,17 @@ export function cornersRouter(options: CornersOptions): Router {
       }
       // 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][] = [];
+      const placed = options.plug ? plugsByEdge(options.plug.run({ graph, ways }, options.plugOptions)) : undefined;
       for (const e of graph.edges) {
         const s = byId.get(e.source.node);
         const t = byId.get(e.target.node);
         if (!s || !t) continue;
-        const [ps, pt] =
-          options.plugs === "side" ? sidePlugs(ways, s, e.source, t, e.target) : [placePlug(s, e.source, center(t.box)), placePlug(t, e.target, center(s.box))];
+        const own = placed?.get(e.id)?.shift();
+        const [ps, pt]: [Plug, Plug] = own
+          ? [own.source, own.target]
+          : options.plugs === "side" && !placed
+            ? sidePlugs(ways, s, e.source, t, e.target)
+            : [placePlug(s, e.source, center(t.box)), placePlug(t, e.target, center(s.box))];
         ends.push([e, s, t, ps, pt]);
       }
       if ((options.plugGap ?? 0) > 0) spacePlugs(ends, options.plugGap!);
@@ -67,6 +81,17 @@ export function cornersRouter(options: CornersOptions): Router {
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
 }
 
+/** This function gives the plugs of a plug strategy by the edge id. Two edges with one id take the entries of that id in order. */
+function plugsByEdge(list: readonly PlugPair[]): Map<string, PlugPair[]> {
+  const out = new Map<string, PlugPair[]>();
+  for (const p of list) {
+    const own = out.get(p.edge);
+    if (own) own.push(p);
+    else out.set(p.edge, [p]);
+  }
+  return out;
+}
+
 /**
  * This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
  * The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
@@ -80,8 +105,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/index.ts

@@ -9,7 +9,8 @@ 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 { 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, resolvePorts, 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 = resolvePorts(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/sections.ts

@@ -1,9 +1,10 @@
 import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
 import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
-import { LEVEL_LINK_DEFAULTS, levelLinks, type ItemPair, type LevelLinkOptions } from "../levels.ts";
-import { nodeIndex, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { LEVEL_LINK_DEFAULTS, type LevelLinkOptions } from "../levels.ts";
+import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
+import { nodeIndex, resolvePorts, 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, levelCut, SECTION_DEFAULTS, treeDepth, type Section, type SectionOptions } from "../sections.ts";
+import { allSections, buildSections, checkSections, SECTION_DEFAULTS, type Section, type SectionOptions } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import type { Strategy } from "../strategies/model.ts";
 import { WayFinder } from "../ways.ts";
@@ -45,6 +46,14 @@ export interface SectionsOptions extends LevelLinkOptions, SectionOptions {
    * The default is each depth, from 0 to the depth of the deepest section.
    */
   readonly levels?: readonly number[];
+  /**
+   * The level rule: a strategy of the step `levels` that makes the zoom levels from the tree and the routes.
+   * Without it, the router uses the strategy `depths` (`depthLevels`). The strategy gets the options `levels`, `margin`, `k`, `tightMargin`, `plugInset` and `throughCost` of the router,
+   * and then `levelOptions`.
+   */
+  readonly level?: Strategy<"levels">;
+  /** The options of the strategy `level`. They go over the level options of the router. */
+  readonly levelOptions?: object;
   /** The lane order of the runs. With `run`, the default, each run gets its order alone. With `bundle`, two edges keep one order on each run of their common stretch. */
   readonly laneOrder?: RunOrder;
   /** The benchmark skips a fixture with more nodes. */
@@ -82,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 = resolvePorts(input);
       const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
       const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
       const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;
@@ -210,7 +220,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         if (list.length < 2 || p.length < 2) continue;
         runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!), options.laneOrder) });
       }
-      return { routes, runs, levels: makeLevels(graph, root, routeOf, options) };
+      return { routes, runs, levels: makeLevels(graph, root, routes, options) };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
@@ -224,43 +234,16 @@ function groupNodes(graph: Graph, options: SectionsOptions): Section {
   return root;
 }
 
+/** The keys of the router options that the level rule gets. */
+const LEVEL_KEYS = ["levels", "margin", "k", "tightMargin", "plugInset", "throughCost"] as const;
+
 /**
- * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
- * With the option `levels`, only those depths get a level with groups.
- * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
- * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
- * In the last level, the points of a link are the route of its first edge.
+ * This function gives the zoom levels of the router: the levels of the strategy `level`, or else the levels of `depthLevels`.
+ * The strategy gets the level options of the router that have a value, and then `levelOptions`.
  */
-function makeLevels(graph: Graph, root: Section, routeOf: ReadonlyMap<string, Route>, options: SectionsOptions): Level[] {
-  const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
-  const levels: Level[] = [];
-  const deepest = treeDepth(root);
-  const shown = options.levels && new Set(options.levels);
-  for (let d = 0; d <= deepest + 1; d++) {
-    if (shown && d <= deepest && !shown.has(d)) continue;
-    const { items, owner } = levelCut(graph.nodes, root, d);
-    const links = new Map<string, { source: string; target: string; count: number; edge: string }>();
-    for (const e of graph.edges) {
-      const iu = indexOfNode.get(e.source.node);
-      const iv = indexOfNode.get(e.target.node);
-      if (iu === undefined || iv === undefined) continue;
-      const a = owner[iu]!;
-      const b = owner[iv]!;
-      if (a === b) continue;
-      const ida = items[a]!.id;
-      const idb = items[b]!.id;
-      const key = `${ida}\u0000${idb}`;
-      const link = links.get(key);
-      if (link) {
-        link.count++;
-        continue;
-      }
-      links.set(key, { source: ida, target: idb, count: 1, edge: e.id });
-    }
-    const pairs: ItemPair[] = [...links.values()].map(({ source, target, count }) => ({ source, target, count }));
-    if (d > deepest)
-      levels.push({ depth: d, items, links: [...links.values()].map(({ edge, ...l }) => ({ ...l, points: routeOf.get(edge)?.points ?? [] })) });
-    else levels.push({ depth: d, items, links: levelLinks(items, pairs, options) });
-  }
-  return levels;
+function makeLevels(graph: Graph, root: Section, routes: readonly Route[], options: SectionsOptions): Level[] {
+  if (!options.level) return depthLevels({ graph, root, routes }, options);
+  const own: Record<string, unknown> = {};
+  for (const key of LEVEL_KEYS) if (options[key] !== undefined) own[key] = options[key];
+  return options.level.run({ graph, root, routes }, { ...(own as DepthLevelOptions), ...options.levelOptions });
 }