@mark1russell7/highways 0.1.5 → 0.3.0

package/build/index.d.ts

@@ -96,6 +96,8 @@ export interface Node {
   readonly id: string;
   readonly box: Box;
   readonly ports?: readonly Port[];
+  /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
+  readonly data?: Readonly<Record<string, unknown>>;
 }
 /** One end of an edge: a node, and optionally one plug of that node. */
 export interface End {
@@ -244,6 +246,17 @@ export declare function hubChainBoard(): Graph;
  * On a level with many groups, some level links go around the outer edge of the board.
  */
 export declare function manyGroupsBoard(): Graph;
+/** The options of `packedGridBoard`. */
+export interface PackedGridOptions {
+  /** The seed of the links. The default is 11. */
+  readonly seed?: number;
+  /** The number of columns. The default is 12. */
+  readonly cols?: number;
+  /** The number of rows. The default is 8. */
+  readonly rows?: number;
+  /** The number of long links between boxes far apart. The default is 48. */
+  readonly long?: number;
+}
 /**
  * This function makes the far view of a board after a host layout packs it.
  * The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
@@ -251,8 +264,17 @@ export declare function manyGroupsBoard(): Graph;
  * The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
  *
  * The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+ * The options make a family of such boards for the measure suite. Without options, the board does not change.
+ */
+export declare function packedGridBoard(options?: PackedGridOptions): Graph;
+/**
+ * This function makes a packed board with three zoom levels of groups. The board has 256 touching boxes in a grid of 16 columns and 16 rows.
+ * The quadtree of `buildSections` splits it into 4, 16 and 64 groups. Each box links to a box near it, and 64 long links join boxes far apart.
+ * At each level, the boxes of the groups touch, so the level links have no channel. The roadmap item ROOM2 measures this board.
+ *
+ * The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
  */
-export declare function packedGridBoard(): Graph;
+export declare function nestedGridBoard(): Graph;
 /** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
 export declare const CASES: readonly CaseBoard[];
 /** A plug: the point where a route leaves or enters a node, and the outward normal of its side. */
@@ -312,8 +334,10 @@ export declare function roundCorners(p: readonly Point[], radius: number, steps?
  * - `rounded`: a quadratic Bezier curve at each corner, as `roundCorners` draws it.
  * - `spline`: a centripetal Catmull-Rom spline through the points. It does not overshoot or make loops.
  * - `arc`: a circular arc at each corner, tangent to the two legs.
+ * - `smooth`: a cubic spiral, an arc and a second cubic spiral at each corner, as the corner smoothing of Figma.
+ * - `clothoid`: a clothoid, an arc and a second clothoid at each corner, as a transition curve of a road.
  */
-export type CurveType = "straight" | "rounded" | "spline" | "arc";
+export type CurveType = "straight" | "rounded" | "spline" | "arc" | "smooth" | "clothoid";
 /** The curve types, in the order of the benchmark. */
 export declare const CURVE_TYPES: readonly CurveType[];
 /** The start of a curve: the pen goes to `to` and draws nothing. */
@@ -367,6 +391,12 @@ interface CurveSpace {
    * A polyline goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
    */
   addsHit(q: readonly Point[], p: readonly Point[]): boolean;
+  /**
+   * This method tells if the triangle `(a, v, b)` overlaps a box that the polyline `(a, v, b)` does not go through.
+   * A convex corner from `a` to `b` stays in this triangle, so a clear triangle proves a clear corner with no samples.
+   * The method is optional. Without it, a corner samples its curve.
+   */
+  addsHitTriangle?(a: Point, v: Point, b: Point): boolean;
 }
 /**
  * This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
@@ -439,13 +469,191 @@ interface ArcOptions {
  * On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
  */
 export declare function arcCurve(points: readonly Point[], options?: ArcOptions): CurveSegment[];
+/** The options of `smoothCurve`. */
+interface SmoothOptions {
+  /** The radius of the arc in the middle of each corner: the smallest radius of the corner. The default is 12. */
+  readonly radius?: number;
+  /** The share of the turn of a corner in its two spirals, from 0 (a circular arc) to 1 (no arc). The default is 0.6. */
+  readonly smoothing?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the largest radius that fits on its legs. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function rounds each inner vertex of a polyline with a cubic spiral, a circular arc and a second cubic spiral.
+ * It is the shape of the corner smoothing of Figma (F7 of the note CURVES). The curvature rises from 0 on the leg to `1 / radius` on the arc,
+ * so the curve is G2: it has no jump of the curvature. Each spiral turns by `smoothing` times half of the turn, up to `MAX_SPIRAL_TURN`.
+ * The ends of each corner stay on the first half of each leg, so the ends of the polyline stay.
+ * With `space`, the radius of a corner shrinks until its corner triangle overlaps no box that the polyline avoids.
+ */
+export declare function smoothCurve(points: readonly Point[], options?: SmoothOptions): CurveSegment[];
+/** The options of `clothoidCurve`. */
+interface ClothoidOptions {
+  /** The radius of the arc in the middle of each corner: the smallest radius of the corner. The default is 12. */
+  readonly radius?: number;
+  /** The share of the turn of a corner in its two clothoids, from 0 (a circular arc) to 1 (no arc). The default is 0.5. */
+  readonly spiral?: number;
+  /** The largest distance from the cubic pieces to the true clothoid, in units of the plane. The default is 0.25. */
+  readonly tolerance?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the largest radius that fits on its legs. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function rounds each inner vertex of a polyline with a clothoid, a circular arc and a second clothoid (F6 of the note CURVES).
+ * The curvature of a clothoid grows linearly with its length, from 0 on the leg to `1 / radius` on the arc. This is the transition curve of roads and railways.
+ * Each clothoid turns by `spiral` times half of the turn. G2 cubic pieces draw it within `tolerance` of the true clothoid.
+ *
+ * The ends of each corner stay on the first half of each leg, so the ends of the polyline stay.
+ * With `space`, the radius of a corner shrinks until its corner triangle overlaps no box that the polyline avoids.
+ */
+export declare function clothoidCurve(points: readonly Point[], options?: ClothoidOptions): CurveSegment[];
+/** A piece of drawn way. A shared segment carries several edges, in lane order. A private segment carries one edge. */
+export interface Segment {
+  readonly id: string;
+  readonly points: readonly Point[];
+  /** The edges in lane order. Lane 0 is on the left of the segment, from its first point to its last. The y axis points down. */
+  readonly edges: readonly string[];
+  /** The number of edges. A renderer shows it on a fat edge. */
+  readonly count: number;
+}
+/** One step of a path: a segment, the way through it, and the lane of the edge in it. */
+export interface SegmentRef {
+  readonly segment: string;
+  /** This value is true when the edge goes from the last point of the segment to its first point. */
+  readonly reverse: boolean;
+  readonly lane: number;
+}
+/** The route of one edge as a list of segments. */
+export interface Path {
+  readonly edge: string;
+  readonly segments: readonly SegmentRef[];
+}
+/** The routes of a result as shared geometry. A renderer can draw each segment one time, with a count. */
+export interface SegmentGraph {
+  readonly segments: readonly Segment[];
+  readonly paths: readonly Path[];
+}
+/**
+ * This function breaks each route into segments. The runs and the trunks of the bundles become shared segments.
+ * The other parts of each route become private segments. The segments of a path, in order, give the points of its route again.
+ */
+export declare function segmentsOf(result: Result): SegmentGraph;
+/** This function gives the points of a path, with the segments in the order and the way of the path. */
+export declare function pathPoints(graph: SegmentGraph, path: Path): Point[];
+/**
+ * This function moves each point of a polyline by `d` to the left, in a frame with the y axis down.
+ * At an inner point, it moves along the bisector, at most 2 × `d` far.
+ */
+export declare function offsetPolyline(p: readonly Point[], d: number): Point[];
+/** The options of `pullApart`. */
+export interface PullApartOptions {
+  /** The distance between two lanes. */
+  readonly spacing: number;
+  /** The largest width of a segment, from its outer lane on the left to its outer lane on the right. */
+  readonly maxWidth: number;
+}
+/**
+ * This function pulls the lanes of each shared segment apart, and gives a route for each edge.
+ * The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
+ */
+export declare function pullApart(graph: SegmentGraph, options: PullApartOptions): Route[];
+/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
+export declare function runKey(edges: readonly string[]): string;
+/**
+ * This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
+ * The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
+ *
+ * Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
+ * The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
+ * The key of a segment is `runKey` of its edges.
+ */
+export declare function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<string>, laneWidth: number, maxWidth?: number): Route[];
+/**
+ * The lane order of the shared ways of a router.
+ * With `bundle`, two edges keep one order on all the shared ways of their common stretch.
+ * With `run`, each shared way gets its order alone. Two edges can change sides from one shared way to the next.
+ */
+export type RunOrder = "bundle" | "run";
+/**
+ * This function gives the lane order of the edges on a shared way `run` (metro-line order).
+ * The routes are polylines that hold the points of the run in a row, in either direction. A route that does not hold the run goes last.
+ *
+ * Two routes go on together past each end of the run until they part. The route that turns more to the left there gets the lane more to the left.
+ *
+ * With the order `run`, the default, the end after the last point of the run tells the side first.
+ * With the order `bundle`, two routes that part on one side at both ends keep that side.
+ * When the two ends disagree, the two routes must cross. The end with the smaller x, then the smaller y, tells the side.
+ * Thus each shared way of a common stretch gives two routes the same order, and the crossing is where they part.
+ */
+export declare function orderLanes(run: readonly Point[], routes: readonly Route[], order?: RunOrder): string[];
+/** The options of `highwayCurves`. */
+interface HighwayOptions {
+  /** The radius at a bend of the center line of a bundle, at a lone corner, and at a merge or a split. The default is 12. */
+  readonly radius?: number;
+  /** The smallest radius of each lane at a bend, a merge or a split. A bend of a bundle grows to keep its inner lane at this radius. The default is 4. */
+  readonly minRadius?: number;
+  /** The largest width of an open segment, from its outer lane on the left to its outer lane on the right, as in `laneRoutes`. The default is `Infinity`. */
+  readonly maxWidth?: number;
+  /** The boxes that the lanes must not go through, from `curveSpace`. With it, no lane goes through a box that its lane of `laneRoutes` avoids. */
+  readonly space?: CurveSpace;
+  /** The shape of the S curve where a lane joins or leaves a bundle. The default is `biarc`. */
+  readonly jog?: JogStyle;
+  /** The number of cubic pieces of a `quintic` S curve, from 1 to 8. The default is 4. */
+  readonly jogPieces?: number;
+}
+/**
+ * The shape of the S curve where a lane changes its offset.
+ *
+ * - `biarc`: two circular arcs. The curvature jumps at each end and at the inflection.
+ * - `cubic`: one cubic Bezier curve with its handles along the leg. The curvature jumps at each end.
+ * - `quintic`: the quintic `y = d (10 t³ - 15 t⁴ + 6 t⁵)`, in G2 cubic pieces. The curvature is 0 at each end and has no jump.
+ *
+ * Each shape keeps its curvature at `1 / radius` or less. The polynomial shapes are longer than the biarc for this reason.
+ */
+type JogStyle = "biarc" | "cubic" | "quintic";
+/**
+ * The S curves of the lanes, by the order of `laneRoutes`. Each S curve has the first and the last index of its segments in the curve of its lane, and its shape.
+ * A polynomial S curve that does not fit on its leg is a biarc.
+ */
+type JogTrace = (readonly [number, number, JogStyle])[][];
+/** The curve of the lane of one edge: a list of segments for any renderer, as `curveOf` gives. */
+interface LaneCurve {
+  readonly edge: string;
+  readonly segments: CurveSegment[];
+}
+/**
+ * This function gives the curve of one polyline as a lane alone: an arc at each corner, as `arcCurve` gives.
+ * A lane alone has no merge and no split, so the curve strategy `highway` gives this curve for one polyline.
+ */
+export declare function highwayCurve(points: readonly Point[], options?: Pick<HighwayOptions, "radius" | "space">): CurveSegment[];
+/**
+ * This function gives the curve of each lane of `laneRoutes`. The lanes of one open segment bend as one highway.
+ *
+ * At each bend of an open segment, the lanes are arcs with one center. The radius of a lane is the radius of the center line,
+ * plus or minus its offset. So the lanes stay at the lane spacing through the bend. The bend grows to keep the inner lane at `minRadius`,
+ * and it shrinks to fit on the legs and in the free space.
+ *
+ * A lane joins (merges) or leaves (splits) a bundle on an S curve on the leg with fewer lanes. The option `jog` gives its shape.
+ * The smallest radius of the S curve is `radius` or less.
+ * Each curve has no break of its tangent where each radius is more than 0.
+ * A lane that is in no open segment gets the curve of `arcCurve`.
+ *
+ * The function takes the same input as `laneRoutes`, and it gives the curves in the order of `laneRoutes`.
+ * The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+ */
+export declare function highwayCurves(source: Result | SegmentGraph, open: ReadonlySet<string>, laneWidth: number, options?: HighwayOptions): LaneCurve[];
 /** The options of `curveOf`. Each type reads only the options that it uses. */
 export interface CurveOptions {
   readonly type: CurveType;
-  /** The types `rounded` and `arc` read this radius of the corners. The default is 12. */
+  /** The types `rounded`, `arc`, `smooth` and `clothoid` read this radius of the corners. The default is 12. */
   readonly radius?: number;
   /** The type `spline` reads this tension, from 0 to 1. The default is 0. */
   readonly tension?: number;
+  /** The type `smooth` reads this share of the turn of a corner in its spirals, from 0 to 1. The default is 0.6. */
+  readonly smoothing?: number;
+  /** The type `clothoid` reads this share of the turn of a corner in its clothoids, from 0 to 1. The default is 0.5. */
+  readonly spiral?: number;
+  /** The type `clothoid` reads this largest distance from its cubic pieces to the true clothoid. The default is 0.25. */
+  readonly tolerance?: number;
   /** The type `spline` leaves the first point along this outward normal of its plug. */
   readonly startNormal?: Point;
   /** The type `spline` comes into the last point against this outward normal of its plug. */
@@ -473,6 +681,12 @@ export declare class Obstacles {
   hit(a: Point, b: Point, pad: number, skip?: ReadonlySet<Node>): Node | undefined;
   /** This method tells if the polyline stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
   clearPath(p: readonly Point[], pad: number, skip?: ReadonlySet<Node>): boolean;
+  /**
+   * This method gives each node whose box the segment `ab` goes through to `visit`, one time each.
+   * The segment goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
+   * The link measures (`measureLinks`) use the same test.
+   */
+  through(a: Point, b: Point, visit: (n: Node) => void): void;
   /** This method gives each node whose bucket the box touches to `visit`. A node can be outside the box. */
   query(box: Box, visit: (n: Node) => void): void;
   /** This method tells if the point is inside a box, made larger by `pad`. The node `skip` does not count. */
@@ -539,6 +753,36 @@ export declare class CornerGraph {
   /** This method removes the vertices that a later vertex makes needless: from each vertex, it goes to the farthest vertex in view. */
   pull(p: readonly Point[], lookahead?: number): Point[];
 }
+/** The options of the soft graph. */
+export interface SoftGraphOptions {
+  /** The distance from a box to its corners. */
+  readonly margin: number;
+  /** The number of nearest neighbours of each vertex. */
+  readonly k: number;
+  /**
+   * The spacing of a lattice of points in the bounding box of the boxes, in units of the mean node size. The default is 3, and 0 turns it off.
+   * The lattice links groups of boxes across empty space.
+   */
+  readonly lattice?: number;
+}
+/**
+ * A graph whose links can go through the boxes. Its vertices are the corners of the boxes, made larger by `margin`,
+ * and a lattice of points in the bounding box of the boxes. Each vertex links to its `k` nearest vertices, in view or not.
+ * The graph keeps the boxes that each link goes through (`Obstacles.through`).
+ * A search gives each box a cost, so a path goes through few boxes, and only through boxes of a low cost.
+ */
+export declare class SoftGraph {
+  #private;
+  readonly points: Point[];
+  /** This constructor makes the graph of the nodes. */
+  constructor(nodes: readonly Node[], obstacles: Obstacles, options: SoftGraphOptions);
+  /**
+   * This method gives a path of least cost from `from` to `to` (A*), with the two points as its ends.
+   * The cost of a path is its length, plus `cost(n)` for each link of the path and each box `n` of that link.
+   * Each cost must be 0 or more. The straight line from `from` to `to` is a path too, so the method always gives a path.
+   */
+  path(from: Point, to: Point, cost: (n: Node) => number): Point[];
+}
 /** The options of a way finder. */
 export interface WayOptions {
   /** The distance from a box to the corners of the graph. The default is 5. */
@@ -568,74 +812,6 @@ export declare class WayFinder {
   /** This method gives a way from a free point to a plug, or `undefined` when the graph has none. */
   toPlug(from: Point, pt: Plug): Point[] | undefined;
 }
-/** A piece of drawn way. A shared segment carries several edges, in lane order. A private segment carries one edge. */
-export interface Segment {
-  readonly id: string;
-  readonly points: readonly Point[];
-  /** The edges in lane order. Lane 0 is on the left of the segment, from its first point to its last. The y axis points down. */
-  readonly edges: readonly string[];
-  /** The number of edges. A renderer shows it on a fat edge. */
-  readonly count: number;
-}
-/** One step of a path: a segment, the way through it, and the lane of the edge in it. */
-export interface SegmentRef {
-  readonly segment: string;
-  /** This value is true when the edge goes from the last point of the segment to its first point. */
-  readonly reverse: boolean;
-  readonly lane: number;
-}
-/** The route of one edge as a list of segments. */
-export interface Path {
-  readonly edge: string;
-  readonly segments: readonly SegmentRef[];
-}
-/** The routes of a result as shared geometry. A renderer can draw each segment one time, with a count. */
-export interface SegmentGraph {
-  readonly segments: readonly Segment[];
-  readonly paths: readonly Path[];
-}
-/**
- * This function breaks each route into segments. The runs and the trunks of the bundles become shared segments.
- * The other parts of each route become private segments. The segments of a path, in order, give the points of its route again.
- */
-export declare function segmentsOf(result: Result): SegmentGraph;
-/** This function gives the points of a path, with the segments in the order and the way of the path. */
-export declare function pathPoints(graph: SegmentGraph, path: Path): Point[];
-/**
- * This function moves each point of a polyline by `d` to the left, in a frame with the y axis down.
- * At an inner point, it moves along the bisector, at most 2 × `d` far.
- */
-export declare function offsetPolyline(p: readonly Point[], d: number): Point[];
-/** The options of `pullApart`. */
-export interface PullApartOptions {
-  /** The distance between two lanes. */
-  readonly spacing: number;
-  /** The largest width of a segment, from its outer lane on the left to its outer lane on the right. */
-  readonly maxWidth: number;
-}
-/**
- * This function pulls the lanes of each shared segment apart, and gives a route for each edge.
- * The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
- */
-export declare function pullApart(graph: SegmentGraph, options: PullApartOptions): Route[];
-/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
-export declare function runKey(edges: readonly string[]): string;
-/**
- * This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
- * The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
- *
- * Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
- * The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
- * The key of a segment is `runKey` of its edges.
- */
-export declare function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<string>, laneWidth: number, maxWidth?: number): Route[];
-/**
- * This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
- * past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
- * Two routes can part only before the first point. Then the route that comes from more to the left gets the lane more to the left.
- * A route that does not hold the run goes last.
- */
-export declare function orderLanes(run: readonly Point[], routes: readonly Route[]): string[];
 /** A section of the plane: a cell of a quadtree, with the nodes whose centers are in it. */
 export interface Section {
   /** The path from the root: "s", then one digit from 0 to 3 for each step down. */
@@ -652,7 +828,11 @@ export interface SectionOptions {
   readonly cap?: number;
   /** The tree stops at this depth. The default is 16. */
   readonly maxDepth?: number;
+  /** A cell shrinks to one quarter at most this many times without a split. Then it stops. The default is 32. */
+  readonly collapse?: number;
 }
+/** The default values of `SectionOptions`. */
+export declare const SECTION_DEFAULTS: Readonly<Required<SectionOptions>>;
 /**
  * This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
  * When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
@@ -662,6 +842,135 @@ export declare function buildSections(nodes: readonly Node[], options?: SectionO
 export declare function allSections(root: Section): Section[];
 /** This function gives the depth of the deepest section. */
 export declare function treeDepth(root: Section): number;
+/**
+ * This function examines a tree of sections from a grouping rule. It throws an error when the tree is not valid for `count` nodes.
+ * In a valid tree, each node is in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+ */
+export declare function checkSections(root: Section, count: number): void;
+/** The items of one zoom level of a tree of sections, and the item of each node. */
+export interface LevelCut {
+  /** The items of the level: a section of the depth of the level, or one node of a leaf above that depth. */
+  readonly items: LevelItem[];
+  /** The index in `items` of the item of each node, in the order of the nodes. */
+  readonly owner: readonly number[];
+}
+/**
+ * This function gives the items of the zoom level at `depth`. A section of that depth is one item, with the bounding box of its nodes.
+ * A node of a leaf above that depth is an item alone. The items come in the order of the walk of the tree, parents before children.
+ * A depth past the depth of the deepest section gives each node alone.
+ */
+export declare function levelCut(nodes: readonly Pick<Node, "id" | "box">[], root: Section, depth: number): LevelCut;
+/**
+ * This function gives the tree of sections of the grouping rule `quadtree`: the cells of a quadtree of the plane (`buildSections`).
+ * It is the default grouping rule of the router `sections`.
+ */
+export declare function quadtreeGroups(graph: Graph, options?: SectionOptions): Section;
+/** A key rule gives the key of the group of a node. A node without a key is a group alone. */
+type NodeKey = (node: Node, index: number) => string | undefined;
+/** The options of the grouping rule `keys`. */
+interface KeyOptions {
+  /** This function gives the key of the group of each node. The default is `byDataGroup`. */
+  readonly key?: NodeKey;
+  /**
+   * With this value, a group with more nodes than its `cap` splits into the cells of a quadtree, as `buildSections` does.
+   * Without it, each group is one leaf. The default is no split.
+   */
+  readonly split?: SectionOptions;
+}
+/** This key rule gives the string `data.group` of the node, or `undefined` when the node has no such string. */
+export declare const byDataGroup: NodeKey;
+/**
+ * This function gives the tree of sections of the grouping rule `keys`. The root holds each node. Each child of the root holds the nodes of one key,
+ * in the order of their first node. The id of a group is `s:` and its key. A node without a key is a group alone, with the id `s#` and its index.
+ * Thus the far view of the router `sections` shows one item for each group.
+ */
+export declare function keyedSections(nodes: readonly Node[], options?: KeyOptions): Section;
+/** This function gives the tree of sections of the grouping rule `keys` for a graph. */
+export declare function keyGroups(graph: Graph, options?: KeyOptions): Section;
+/** The cost of a line of the rule `cut`, from the cut `c` and the parts `A` and `B` of the split. */
+type CutObjective = "ratio" | "normalized" | "sparsest";
+/** The options of the grouping rule `cut` (M1 of GRP-R, the guillotine cut). */
+interface CutOptions {
+  /** A section with more nodes splits. The default is 8, as for the quadtree. */
+  readonly cap?: number;
+  /** The tree stops at this depth. The default is 16. */
+  readonly maxDepth?: number;
+  /** The number of children of a section: 2 or 4. With 4, a section splits two times on one level. The default is 4. */
+  readonly fanout?: number;
+  /** The smallest share of the nodes in each part of a split (`β`), from 0.05 to 0.5. The default is 0.25. */
+  readonly balance?: number;
+  /**
+   * The cost of a line. The value `ratio` is `c / min(|A|, |B|)`. The value `normalized` is `c / vol(A) + c / vol(B)`, with `vol` the sum of the degrees
+   * inside the section. The value `sparsest` is `c / (|A| · |B|)`. The default is `ratio`.
+   */
+  readonly objective?: CutObjective;
+  /**
+   * The cost of a line grows by the factor `1 + pull · d`. The value `d` is the distance of the line from the middle of the cell, as a share of the side.
+   * A large value prefers the middle line, as the quadtree does. The default is 0.5.
+   */
+  readonly pull?: number;
+  /**
+   * With `true`, each section also tests the split of the quadtree, and keeps the split that cuts fewer edges.
+   * Thus no section cuts more edges than the quadtree split of its cell. With the fan-out 2, the test uses each midline of the cell. The default is `true`.
+   */
+  readonly guard?: boolean;
+}
+/** The default values of `CutOptions`. */
+export declare const CUT_DEFAULTS: Readonly<Required<CutOptions>>;
+/**
+ * This function gives the tree of sections of the grouping rule `cut`: a guillotine cut that reads the edges (M1 of GRP-R).
+ * A section with more than `cap` nodes splits in two along the line with the lowest cost, on either axis. A line goes between two centers.
+ * Each part of a split holds at least the share `balance` of the nodes. With the fan-out 4, each half splits again on the same level.
+ *
+ * The cells nest and do not overlap. The option `guard` keeps the split of the quadtree when that split cuts fewer edges.
+ */
+export declare function cutGroups(graph: Graph, options?: CutOptions): Section;
+/** The place of the line of a split of the rule `kd`. */
+type KdLine = "median" | "middle" | "slide";
+/** The axis of each split of the rule `kd`. */
+type KdAxis = "longer" | "alternate";
+/** The options of the grouping rule `kd` (S3 of GRP-R). */
+interface KdOptions {
+  /** A section with more nodes splits. The default is 8, as for the quadtree. */
+  readonly cap?: number;
+  /** The tree stops at this depth. The default is 16. */
+  readonly maxDepth?: number;
+  /**
+   * This value sets the place of the line in the cell. The value `median` puts half of the nodes on each side. The value `middle` cuts the cell in half,
+   * and an empty half makes the cell shrink to the other half. The value `slide` cuts the cell in half, and a line with an empty side slides to the nearest node.
+   * The default is `slide`.
+   */
+  readonly line?: KdLine;
+  /** The number of children of a section: 2 or 4. With 4, a section splits two times on one level. The default is 4. */
+  readonly fanout?: number;
+  /** The value `longer` cuts across the longer side of the cell. The value `alternate` cuts across x, then y, then x again. The default is `longer`. */
+  readonly axis?: KdAxis;
+}
+/** The default values of `KdOptions`. */
+export declare const KD_DEFAULTS: Readonly<Required<KdOptions>>;
+/**
+ * This function gives the tree of sections of the grouping rule `kd`: a k-d tree of the plane (S3 of GRP-R).
+ * A section with more than `cap` nodes splits in two with a line across one axis. With the fan-out 4, each half splits again on the same level.
+ * The cells nest and do not overlap. The line `median` gives halves of equal size.
+ */
+export declare function kdGroups(graph: Graph, options?: KdOptions): Section;
+/** This function gives the median width of the shown items of each level, in units of the plane. */
+export declare function itemSizes(levels: readonly Level[]): number[];
+/** The far-view thresholds of `pickLevel`, in pixels on the screen. */
+export interface PickOptions {
+  /** When a node is at least this wide on the screen, the view shows each route. */
+  readonly routesAt: number;
+  /** A level is fine enough when its median item is at least this wide on the screen. */
+  readonly itemAt: number;
+}
+/** The default thresholds: a node of 22 pixels shows its routes, and a group of 120 pixels shows its parts. */
+export declare const PICK: PickOptions;
+/**
+ * This function picks the level that a camera shows at a scale, in pixels for each unit of the plane. The sizes come from `itemSizes`.
+ * The value `sizes.length` stands for the routes of each edge. The last level holds the nodes alone.
+ * Each threshold that `options` does not give gets its value from `PICK`.
+ */
+export declare function pickLevel(sizes: readonly number[], scale: number, options?: Partial<PickOptions>): number;
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export declare function boxExit(box: Box, toward: Point): Point;
 /**
@@ -695,6 +1004,8 @@ interface SharedOptions extends WayOptions {
   readonly rule?: GroupRule;
   /** The cost of a link that an edge with the same key uses already, as a share of its length. The default is 0.5. */
   readonly discount?: number;
+  /** The lane order of the runs. With `bundle`, the default, two edges keep one order on each run of their common stretch. With `run`, each run gets its order alone. */
+  readonly laneOrder?: RunOrder;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -705,73 +1016,46 @@ interface SharedOptions extends WayOptions {
  * The result gives each stretch as a run, with the order of its lanes.
  */
 export declare function sharedRouter(options: SharedOptions): Router;
-/** The options of the router with sections. */
-interface SectionsOptions extends WayOptions, SectionOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
+/** Two items of a level that a link joins, and the count of the edges between them. */
+interface ItemPair {
+  readonly source: string;
+  readonly target: string;
+  readonly count: number;
+}
+/** The options of the links of a level: the options of the ways, and two limits of the level links. */
+interface LevelLinkOptions extends WayOptions {
   /**
-   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
-   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
+   * The second graph uses the smaller of this value and `margin`. The default is 1.
    */
-  readonly hubs?: number;
-  /** A way through the hubs can be at most this many times as long as the line between its plugs. Else the edge goes directly. The default is 2. */
-  readonly stretch?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
+  readonly tightMargin?: number;
+  /** A plug stays at least this far from the corners of its side. The level links use the smaller of this value and `margin`. The default is 6. */
+  readonly plugInset?: number;
+  /**
+   * The cost of a level link through a far box, in units of the mean box size. A far box overlaps neither end of the link.
+   * A link through a far box gets a second way that can go through boxes (`SoftGraph`). The link keeps the way with fewer far boxes.
+   * The value 0 turns the second way off and gives the links of version 0.1.5. The default is 8.
+   */
+  readonly throughCost?: number;
 }
 /**
- * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
- * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
- * Each way from hub to hub is found one time, so all the edges on it share its points.
- * The edges in one section of the lowest level go straight around the nodes.
- *
- * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
- *
- * The result gives one zoom level for each depth of the tree.
- * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ * The options of the room for the bends of the bundles (HWC-D). With them, `roomDemand` also opens the gaps where a bundle bends.
+ * The values agree with the options of `highwayCurves` that draw the bundles.
  */
-export declare function sectionsRouter(options: SectionsOptions): Router;
-/** The options of the trunk router. */
-interface TrunksOptions extends WayOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
-  /** The grouping rule. The edges from one plug with one key share a trunk. */
-  readonly rule: GroupRule;
-  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
-  readonly split?: number;
-  /** A group with fewer edges stays unbundled. The default is 2. */
-  readonly minSize?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
+interface RoomBends {
+  /** The router that bundles the edges. Each segment of its routes with two or more edges is a bundle. */
+  readonly router: Router;
+  /** The edges that the router routes. Without them, each link gives `count` edges, with no data. */
+  readonly edges?: readonly Edge[];
+  /** The distance between two lanes of a bundle, as `laneWidth` of `highwayCurves`. The default is 4. */
+  readonly spacing?: number;
+  /** The largest width of a bundle, from its outer lane to its outer lane, as `maxWidth` of `highwayCurves`. The default is `Infinity`. */
+  readonly maxWidth?: number;
+  /** The smallest radius of each lane, as `minRadius` of `highwayCurves`. The default is 4. */
+  readonly minRadius?: number;
+  /** The number of passes of the demand of the bends. Each pass routes the board that the passes before it opened. The default is 1. */
+  readonly passes?: number;
 }
-/** The rule that groups the edges by the collection of their target, in `data.collection`. */
-export declare const byCollection: GroupRule;
-/**
- * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
- * A group with fewer than `minSize` edges does not appear.
- */
-export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
-/**
- * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
- * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
- */
-export declare function laneOrder(dir: Point, from: Point, branches: readonly {
-  readonly edge: string;
-  readonly next: Point;
-}[]): string[];
-/**
- * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
- * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
- */
-export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
-/**
- * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
- * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
- * The edges outside the groups go as in the corner router.
- */
-export declare function trunksRouter(options: TrunksOptions): Router;
-/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
-export declare const ROUTERS: readonly Router[];
 /** An item with a box: a node of a graph, an item of a level or a box of a host layout. */
 export interface Boxed {
   readonly id: string;
@@ -836,6 +1120,12 @@ export interface RoomOptions {
    * The limit `maxGrowth` applies to the sum of the passes.
    */
   readonly passes?: number;
+  /**
+   * The room for the bends of the bundles (HWC-D). Without it, the default, the demand counts only the lanes of the links.
+   * With it, the router of `bends` routes the open board. Each leg of a bundle that is too short for its arcs grows by a gap.
+   * The limit `maxGrowth` applies to the sum of the growth of the links and of the bends.
+   */
+  readonly bends?: RoomBends;
 }
 /** The demand of a board and the board with its gaps open. */
 export interface Room<T extends Boxed> {
@@ -858,10 +1148,365 @@ export declare function openGaps<T extends Boxed>(items: readonly T[], gaps: rea
  * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
  */
 export declare function roomDemand(items: readonly Boxed[], links: readonly RoomLink[], options?: RoomOptions): Gap[];
+/**
+ * This function adds the growth for the bends of the bundles to the need of each gap. Each pass routes the board with each gap open to its need.
+ * The open board has the same gaps in the same order. So the growth of each gap adds to the need of that gap.
+ */
+export declare function withBends(items: readonly Boxed[], links: readonly RoomLink[], gaps: readonly Gap[], bends: RoomBends, snap?: number): Gap[];
 /** This function gives the demand of the board and the board with each gap open to its need. */
 export declare function makeRoom<T extends Boxed>(items: readonly T[], links: readonly RoomLink[], options?: RoomOptions): Room<T>;
 /** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
 export declare function roomLinks(graph: Graph): RoomLink[];
+/** The scale of a number option. A sweep on the scale `log` gives values with equal ratios, not with equal differences. */
+export type OptionScale = "linear" | "log";
+/** The fields of each option declaration. */
+interface OptionBase {
+  /** One short sentence that tells what the option sets. The site and the documents show it. */
+  readonly describe: string;
+}
+/**
+ * The declaration of a number option. The range from `min` to `max` is the range of a control and of a sweep.
+ * The strategy can take a value outside the range. `checkOptions` reports such a value, and `clampOptions` moves it into the range.
+ */
+export interface NumberOption extends OptionBase {
+  /** The type `integer` takes only whole numbers. */
+  readonly type: "number" | "integer";
+  readonly min: number;
+  readonly max: number;
+  /** The grain of a control and of a sweep. A value off the step is valid. Without it, the grain is free (or 1 for an integer). */
+  readonly step?: number;
+  /** The scale of a control and of a sweep. The default is `linear`. The scale `log` needs a `min` above 0. */
+  readonly scale?: OptionScale;
+  /** These values are valid outside the range. For example, `Infinity` sets no limit. */
+  readonly special?: readonly number[];
+  /** These values are the notable values of the option: the default and the values of the sweeps of the benchmark. */
+  readonly marks?: readonly number[];
+  /** The strategy uses this value when the caller and `defaults` give no value. */
+  readonly default?: number;
+}
+/** The declaration of a boolean option. */
+export interface BooleanOption extends OptionBase {
+  readonly type: "boolean";
+  /** The strategy uses this value when the caller and `defaults` give no value. */
+  readonly default?: boolean;
+}
+/** The declaration of an option with a fixed list of string values. */
+export interface EnumOption<V extends string = string> extends OptionBase {
+  readonly type: "enum";
+  /** The values of the option, in the order of a control. */
+  readonly values: readonly V[];
+  /** The strategy uses this value when the caller and `defaults` give no value. */
+  readonly default?: V;
+}
+/**
+ * The declaration of an option that a control or a sweep cannot set from a range.
+ * The type `function` is a rule, `strategy` is a strategy of the step `step`, `list` is an array and `object` is any other object.
+ */
+export interface ValueOption<V = unknown> extends OptionBase {
+  readonly type: "function" | "strategy" | "list" | "object";
+  /** The step of the strategy, for the type `strategy`. A control lists the strategies of this step of a registry. */
+  readonly step?: Step;
+  /** The strategy uses this value when the caller and `defaults` give no value. */
+  readonly default?: V;
+}
+/** The declaration of one option of any type. */
+export type AnyOption = NumberOption | BooleanOption | EnumOption | ValueOption;
+/** The declaration that fits the type of an option value: numbers, booleans, string unions or other values. */
+export type OptionDeclaration<V> = [V] extends [number] ? NumberOption : [V] extends [boolean] ? BooleanOption : [V] extends [string] ? EnumOption<V> : ValueOption<V>;
+/** The declarations of the options of a strategy. The schema has one declaration for each key of the options type, and no other key. */
+export type OptionSchema<O> = { readonly [K in keyof O]-?: OptionDeclaration<NonNullable<O[K]>>; };
+/** One problem of an option value against its declaration. */
+export interface OptionIssue {
+  /** The key of the option. */
+  readonly key: string;
+  readonly value: unknown;
+  /** The kind of the problem: no declaration, the wrong type, out of the range, not a whole number or not one of the values. */
+  readonly problem: "unknown" | "type" | "range" | "integer" | "value";
+  /** One sentence that tells the problem. */
+  readonly message: string;
+}
+/** One setting of a sweep: a name for the rows of a table, and the options of the strategy. */
+export interface OptionSetting<O extends object> {
+  /** The key and the value of each option of the setting, for example `stretch 1.5`. */
+  readonly name: string;
+  readonly options: Partial<O>;
+}
+/** The options of `sweepValues`, `sweepOf` and `sweepGrid`. */
+export interface SweepOptions {
+  /**
+   * The number of values on the range of a number option. Without it, the sweep gives the `marks` of the declaration.
+   * A declaration without `marks` gets 5 values.
+   */
+  readonly count?: number;
+  /** With `true`, a sweep of a number option on the range also gives the `special` values. The default is `false`. */
+  readonly special?: boolean;
+}
+/** This function gives the declared options of a strategy, in the order of its schema, with the effective default of each one. */
+export declare function listOptions<S extends Step, O extends object>(strategy: Strategy<S, O>): {
+  readonly key: keyof O & string;
+  readonly declaration: AnyOption;
+  readonly value: unknown;
+}[];
+/**
+ * This function gives the effective default of each declared option: the value of `defaults`, else the `default` of the declaration.
+ * An option without either value stays out. The strategy gives the same output with this object as with no options.
+ */
+export declare function optionDefaults<S extends Step, O extends object>(strategy: Strategy<S, O>): Partial<O>;
+/**
+ * This function examines option values against the schema of a strategy. It gives one issue for each key without a declaration.
+ * It also gives one issue for each value of the wrong type, out of the range, not whole or not one of the values.
+ * It changes no value.
+ * A strategy without a schema gives no issue.
+ */
+export declare function checkOptions<S extends Step, O extends object>(strategy: Strategy<S, O>, options: Partial<O>): OptionIssue[];
+/**
+ * This function moves each number option into the range of its declaration, for a control. An integer option gets the nearest whole number.
+ * A special value stays. The function keeps each other value as it is. `checkOptions` reports the values that this function cannot correct.
+ */
+export declare function clampOptions<S extends Step, O extends object>(strategy: Strategy<S, O>, options: Partial<O>): Partial<O>;
+/**
+ * This function gives the values of a sweep of one option declaration.
+ * A number option gives its `marks`, or `count` values on its range and its scale. A boolean gives `false` and `true`. An enum gives its values.
+ * An option of another type has no sweep, so the function throws an error.
+ */
+export declare function sweepValues(declaration: AnyOption, options?: SweepOptions): unknown[];
+/**
+ * This function gives the settings of a sweep of one option of a strategy, from its declaration only.
+ * The name of each setting is the key and the value, for example `stretch 1.5`.
+ */
+export declare function sweepOf<S extends Step, O extends object>(strategy: Strategy<S, O>, key: keyof O & string, options?: SweepOptions): OptionSetting<O>[];
+/**
+ * This function gives the settings of a grid of options: each combination of the values of the sweeps of the keys.
+ * The name of a setting joins the names of its values with commas, in the order of the keys.
+ */
+export declare function sweepGrid<S extends Step, O extends object>(strategy: Strategy<S, O>, keys: readonly (keyof O & string)[], options?: SweepOptions): OptionSetting<O>[];
+/**
+ * This function examines the schema of a strategy. It gives one message for each option of `defaults` without a declaration.
+ * It also gives one message for each bad declaration, and for each value of `defaults` that does not fit its declaration.
+ * A good schema gives an empty list.
+ */
+export declare function checkSchema(strategy: Strategy<Step, object>): string[];
+/** The input of a curve strategy: one polyline and the context of its route. */
+export interface CurveInput {
+  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
+  readonly points: readonly Point[];
+  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
+  readonly startNormal?: Point;
+  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. */
+  readonly space?: CurveSpace;
+}
+/** The input of a room strategy: the boxes of a board and the links between them. */
+export interface RoomInput {
+  readonly items: readonly Boxed[];
+  readonly links: readonly RoomLink[];
+  /**
+   * The tree of sections of the items, for a strategy that gives room to each zoom level. The indices of its nodes are the indices of `items`.
+   * Without it, such a strategy makes the quadtree of `buildSections`. The other strategies do not read it.
+   */
+  readonly sections?: Section;
+}
+/**
+ * The steps that have strategies, with the fixed input and output type of each step.
+ *
+ * - `group`: a graph in, the tree of sections out. The router `sections` makes its hubs and its zoom levels from this tree.
+ * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
+ * - `curve`: a polyline in, the segments of a curve out.
+ * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ */
+export interface StepTypes {
+  readonly group: {
+    readonly input: Graph;
+    readonly output: Section;
+  };
+  readonly router: {
+    readonly input: Graph;
+    readonly output: Result;
+  };
+  readonly curve: {
+    readonly input: CurveInput;
+    readonly output: CurveSegment[];
+  };
+  readonly room: {
+    readonly input: RoomInput;
+    readonly output: Gap[];
+  };
+}
+/** The name of a step that has strategies. */
+export type Step = keyof StepTypes;
+/** The input type of a step. */
+export type StepInput<S extends Step> = StepTypes[S]["input"];
+/** The output type of a step. */
+export type StepOutput<S extends Step> = StepTypes[S]["output"];
+/** The steps that have strategies, in the order of the pipeline. */
+export declare const STEPS: readonly Step[];
+/**
+ * A strategy: one way to do one step, with a name and a description.
+ * The same input and the same options must give the same output.
+ */
+export interface Strategy<S extends Step = Step, O extends object = object> {
+  /** The step of the strategy. It fixes the input and the output type. */
+  readonly step: S;
+  /** The name of the strategy. Each name is unique in its step of a registry. */
+  readonly name: string;
+  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
+  readonly describe: string;
+  /** The values of the options when the caller gives no value. */
+  readonly defaults: Readonly<O>;
+  /** The declarations of the options: the type, the range, the step and the meaning of each one. A strategy without it declares nothing. */
+  readonly schema?: OptionSchema<O>;
+  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
+  readonly maxNodes?: number;
+  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
+  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
+}
+/** A strategy of any step. A registry holds a list of these. */
+export type AnyStrategy = { [S in Step]: Strategy<S>; }[Step];
+/** The definition of a strategy, for `defineStrategy`. */
+export interface StrategyDefinition<S extends Step, O extends object> {
+  readonly step: S;
+  readonly name: string;
+  readonly describe: string;
+  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
+  readonly defaults: O;
+  /** These declarations tell the type, the range, the step and the meaning of each option. `checkSchema` examines them. */
+  readonly schema?: NoInfer<OptionSchema<O>>;
+  readonly maxNodes?: number;
+  /** This function does the step. It gets each option, from the caller or from `defaults`. */
+  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
+}
+/**
+ * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+ * When the caller gives no option, the definition gets the `defaults` object itself.
+ */
+export declare function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O>;
+/**
+ * A registry: the strategies of each step, in order. A registry is data. No import changes it.
+ * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
+ * The list `group` is optional in the type, so a registry from version 0.1.5 stays a registry. `createRegistry` always gives it.
+ */
+export type Registry = { readonly [S in Exclude<Step, "group">]: readonly Strategy<S>[]; } & {
+  readonly group?: readonly Strategy<"group">[];
+};
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+export declare function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry;
+/** This function gives the strategies of one step of a registry, in order. */
+export declare function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[];
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+export declare function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined;
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+export declare function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S>;
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+export declare function routersOf(registry: Registry): Router[];
+/**
+ * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
+ * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
+ * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
+ */
+interface SectionsOptions extends LevelLinkOptions, SectionOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
+   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   */
+  readonly hubs?: number;
+  /**
+   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
+   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
+   */
+  readonly stretch?: number;
+  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
+  readonly stretchPad?: number;
+  /**
+   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
+   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   */
+  readonly hubSlack?: number;
+  /**
+   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
+   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   */
+  readonly group?: Strategy<"group">;
+  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly groupOptions?: object;
+  /**
+   * 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[];
+  /** 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. */
+  readonly maxNodes?: number;
+}
+/**
+ * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+ * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+ * Each way from hub to hub is found one time, so all the edges on it share its points.
+ * The edges in one section of the lowest level go straight around the nodes.
+ *
+ * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ *
+ * The result gives one zoom level for each depth of the tree.
+ * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ */
+export declare function sectionsRouter(options: SectionsOptions): Router;
+/** The options of the trunk router. */
+interface TrunksOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The grouping rule. The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule;
+  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
+  readonly split?: number;
+  /** A group with fewer edges stays unbundled. The default is 2. */
+  readonly minSize?: number;
+  /** The lane order of a trunk. With `bundle`, the default, the branches part in lane order. With `run`, the first leg of each branch tells the order. */
+  readonly laneOrder?: RunOrder;
+  /**
+   * The place where each lane leaves the trunk. With `part`, the default, a lane leaves where its way parts from the ways of the other lanes.
+   * A lane that turns back over the trunk leaves at an earlier point of the trunk. With `split`, each lane leaves at the split point, as in version 0.2.0.
+   */
+  readonly leave?: TrunkLeave;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/** The place where the lanes of a trunk leave it: where their ways part, or at the split point. */
+type TrunkLeave = "part" | "split";
+/** The rule that groups the edges by the collection of their target, in `data.collection`. */
+export declare const byCollection: GroupRule;
+/**
+ * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
+ * A group with fewer than `minSize` edges does not appear.
+ */
+export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
+/**
+ * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
+ * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
+ */
+export declare function laneOrder(dir: Point, from: Point, branches: readonly {
+  readonly edge: string;
+  readonly next: Point;
+}[]): string[];
+/**
+ * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
+ * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
+ */
+export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
+/**
+ * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
+ * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
+ * The edges outside the groups go as in the corner router.
+ */
+export declare function trunksRouter(options: TrunksOptions): Router;
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
+export declare const ROUTERS: readonly Router[];
 /**
  * The lane order of the pieces of the links in one gap.
  *
@@ -887,6 +1532,58 @@ export interface GapLaneOptions {
  * When a move puts a link through more boxes than before, the link keeps its points.
  */
 export declare function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options?: GapLaneOptions): LevelLink[];
+/**
+ * The boards of the zoom levels of `levelRoom`.
+ *
+ * - `shared`: each level uses the board of the nearest level. No box moves between two levels. A far level gets the area of the nearest level.
+ * - `each`: each level has its own board. A far level opens only the gaps of its own links, and a nearer level adds to them.
+ *   Thus the items of a far level are nearer together, but a box moves in its parent when the level changes.
+ */
+export type LevelBoard = "each" | "shared";
+/** The options of `levelRoom`: the options of `roomDemand` for each level, and the levels that get room. */
+export interface LevelRoomOptions extends RoomOptions {
+  /** The depths of the tree that get room for their links. The default is each depth from 1 to the depth of the deepest section. */
+  readonly depths?: readonly number[];
+  /** With `true`, the last level, with each node alone, also gets room for the links between the nodes. The default is `false`. */
+  readonly nodes?: boolean;
+  /** The board of each level. The default is `shared`. */
+  readonly board?: LevelBoard;
+}
+/** One zoom level of `levelRoom`: its items at their open places, its links and its demand. */
+export interface RoomLevel<T extends Boxed> {
+  readonly depth: number;
+  /** The items of the level, with the bounding box of their nodes at the places of this level. */
+  readonly items: LevelItem[];
+  /** The links between the items of the level. A link counts the links of the nodes between its two items. */
+  readonly pairs: ItemPair[];
+  /** The demand of the level on the board that it gets from the level before it. A level without room has no gaps. */
+  readonly gaps: Gap[];
+  /** The nodes at the places of this level. */
+  readonly nodes: T[];
+}
+/** The room of each zoom level, and the board of the nearest level. */
+export interface LevelRoom<T extends Boxed> {
+  /** The levels from depth 0 to the level with each node alone, in order. */
+  readonly levels: RoomLevel<T>[];
+  /** The gaps of the board of the nodes. `openGaps(nodes, gaps)` gives the nodes of the nearest level. */
+  readonly gaps: Gap[];
+  /** The nodes of the nearest level. */
+  readonly items: T[];
+}
+/**
+ * This function gives the links between the items of a level. Each pair of items gets one link, in the order of the first link of the pair.
+ * The count of a link is the sum of the counts of its node links. A link inside one item does not count.
+ */
+export declare function levelPairs(items: readonly LevelItem[], owner: readonly number[], indexOf: ReadonlyMap<string, number>, links: readonly RoomLink[]): ItemPair[];
+/**
+ * This function gives the room of each zoom level of a tree of sections. The indices of the nodes of the tree are the indices of `nodes`.
+ * The far levels open first, and each nearer level keeps their growth.
+ *
+ * At each level, `roomDemand` measures the links of that level on the board of the level before it. Then the nodes move with `openGaps`.
+ * The nodes move by one monotone shift on each axis, so each level keeps the order and the alignment of the boxes.
+ * A nearer level only adds growth, so no gap of a far level gets narrower, and a box moves with its parent.
+ */
+export declare function levelRoom<T extends Boxed>(nodes: readonly T[], links: readonly RoomLink[], root: Section, options?: LevelRoomOptions): LevelRoom<T>;
 /** A broken hard rule. A correct router has none. */
 export interface Violation {
   readonly rule: "complete" | "ends-at-plugs" | "fixed-plugs" | "no-pass-through" | "counts-sum" | "link-ends" | "bundle-trunk" | "run-shared";
@@ -905,6 +1602,12 @@ export declare const TOLERANCE = .5;
  * The function gives at most `limit` violations.
  */
 export declare function checkProperties(graph: Graph, result: Result, limit?: number): Violation[];
+/**
+ * This function checks the hard rules of the zoom levels. The counts of each level add up (`counts-sum`).
+ * Each link of a level starts on the box of its source and ends on the box of its target (`link-ends`).
+ * The function gives at most `limit` violations.
+ */
+export declare function checkLevels(graph: Graph, levels: readonly Level[], limit?: number): Violation[];
 /** The quality of a result. Lower is better for each value except `clearance`. */
 export interface Quality {
   /** The length of all drawn lines. A segment that several routes share counts one time. */
@@ -961,6 +1664,13 @@ export interface LinkFaults {
    * A segment goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
    */
   readonly through: number;
+  /**
+   * The number of links of `through` that no route can keep out of the other boxes.
+   * Each box that such a link goes through overlaps the box of its source or of its target, as `countOverlaps` sees it.
+   */
+  readonly unavoidable: number;
+  /** The number of links of `through` that go through at least one box that overlaps neither end. `through` is `unavoidable` plus `avoidable`. */
+  readonly avoidable: number;
   /**
    * The number of links that go out and back. The distance from a point of the link to its last point grows after the nearest approach.
    * A link goes out and back when this growth is more than `BACKTRACK_SHARE` of the distance between its ends, and more than `BACKTRACK_MIN` units.
@@ -1013,6 +1723,8 @@ export declare function goesOutAndBack(p: readonly Point[]): boolean;
  * The bounding box of `outside` is the bounding box of all the boxes of the map.
  */
 export declare function measureLinks(boxes: ReadonlyMap<string, Box>, links: readonly MeasuredLink[], options?: LinkFaultOptions): LinkFaults;
+/** This function tells if two boxes overlap by more than `TOLERANCE` on each axis, as `countOverlaps` counts them. */
+export declare function boxesOverlap(a: Box, b: Box): boolean;
 /** This function measures the faults of the routes of a result. The ends of a route are the nodes of its edge. */
 export declare function measureRouteFaults(graph: Graph, result: Result, options?: LinkFaultOptions): LinkFaults;
 /** This function counts the pairs of boxes that overlap by more than `TOLERANCE` on each axis. */
@@ -1044,11 +1756,26 @@ export interface BenchRow {
   readonly faults: LinkFaults;
   /** The faults of each zoom level with groups (`measureLevelFaults`). The list is empty for a router without levels. */
   readonly levelFaults: readonly LevelFaults[];
+  /** The routes of this cell took longer than the cell limit. The cell did not start more routes. A row within the limit has no such field. */
+  readonly overLimit?: OverLimit;
+}
+/** The record of a cell over its time limit. */
+export interface OverLimit {
+  /** The cell limit, in milliseconds. */
+  readonly limit: number;
+  /** The number of routes that the cell finished. With one route, the cell did not check "same twice". */
+  readonly runs: number;
 }
 /** The options of a benchmark run. */
 export interface BenchOptions {
   /** The number of timed routes of each fixture by each router. The default is 3. */
   readonly repeat?: number;
+  /**
+   * The time limit of one cell (one router on one fixture), in milliseconds. The default is no limit.
+   * After the routes of a cell pass the limit, the cell starts no more routes, and its row gets `overLimit`.
+   * A route that runs does not stop.
+   */
+  readonly cellLimit?: number;
 }
 /** This function routes each fixture with each router, checks the hard rules and measures the quality. */
 export declare function runBenchmark(routers: readonly Router[], fixtures: readonly FixtureSpec[], options?: BenchOptions): BenchRow[];
@@ -1057,115 +1784,39 @@ export declare function runBenchmark(routers: readonly Router[], fixtures: reado
  * because the result of a large graph can be longer than the longest string.
  */
 export declare function sameData(a: unknown, b: unknown): boolean;
-/** This function routes one graph with one router and measures the result. */
-export declare function benchOne(router: Router, fixture: string, graph: Graph, repeat?: number): BenchRow;
-/** This function writes the rows as a Markdown table. */
-export declare function formatTable(rows: readonly BenchRow[]): string;
 /**
- * This function writes the faults of the rows as a Markdown table: the routes first, then the sum of the levels with groups.
- * A router without such levels gets a dash in the columns of the levels.
+ * This function routes one graph with one router and measures the result. It routes at least two times, for the rule "same twice".
+ * After the routes pass `cellLimit` milliseconds, it starts no more routes and marks the row with `overLimit`.
  */
-export declare function formatFaults(rows: readonly BenchRow[]): string;
-/** The input of a curve strategy: one polyline and the context of its route. */
-export interface CurveInput {
-  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
-  readonly points: readonly Point[];
-  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
-  readonly startNormal?: Point;
-  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
-  readonly endNormal?: Point;
-  /** The boxes that the curve must not go through, from `curveSpace`. */
-  readonly space?: CurveSpace;
-}
-/** The input of a room strategy: the boxes of a board and the links between them. */
-export interface RoomInput {
-  readonly items: readonly Boxed[];
-  readonly links: readonly RoomLink[];
+export declare function benchOne(router: Router, fixture: string, graph: Graph, repeat?: number, cellLimit?: number): BenchRow;
+/** One run of `benchRun`: the row of the benchmark and the result that the row measures. */
+export interface BenchRun {
+  readonly row: BenchRow;
+  readonly result: Result;
 }
+/** This function does the work of `benchOne` and also gives the result, so more measures can read it without a second route. */
+export declare function benchRun(router: Router, fixture: string, graph: Graph, repeat?: number, cellLimit?: number): BenchRun;
 /**
- * The steps that have strategies, with the fixed input and output type of each step.
- *
- * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
- * - `curve`: a polyline in, the segments of a curve out.
- * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ * This function puts rows in the order of one benchmark run: by fixture, then by router, each in the order of its list.
+ * A name that is not in its list goes after the names of the list. Rows with the same place keep their order.
+ * The workflow `Bench` uses it to join the rows of its parts.
  */
-export interface StepTypes {
-  readonly router: {
-    readonly input: Graph;
-    readonly output: Result;
-  };
-  readonly curve: {
-    readonly input: CurveInput;
-    readonly output: CurveSegment[];
-  };
-  readonly room: {
-    readonly input: RoomInput;
-    readonly output: Gap[];
-  };
-}
-/** The name of a step that has strategies. */
-export type Step = keyof StepTypes;
-/** The input type of a step. */
-export type StepInput<S extends Step> = StepTypes[S]["input"];
-/** The output type of a step. */
-export type StepOutput<S extends Step> = StepTypes[S]["output"];
-/** The steps that have strategies, in the order of the pipeline. */
-export declare const STEPS: readonly Step[];
+export declare function orderRows(rows: readonly BenchRow[], routers: readonly string[], fixtures: readonly string[]): BenchRow[];
+/** This function writes the rows as a Markdown table. A cell over its limit shows "over the limit" after its time, and a dash for "same twice" when it did not check it. */
+export declare function formatTable(rows: readonly BenchRow[]): string;
 /**
- * A strategy: one way to do one step, with a name and a description.
- * The same input and the same options must give the same output.
+ * This function writes the faults of the rows as a Markdown table: the routes first, then the sum of the levels with groups.
+ * A router without such levels gets a dash in the columns of the levels.
  */
-export interface Strategy<S extends Step = Step, O extends object = object> {
-  /** The step of the strategy. It fixes the input and the output type. */
-  readonly step: S;
-  /** The name of the strategy. Each name is unique in its step of a registry. */
-  readonly name: string;
-  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
-  readonly describe: string;
-  /** The values of the options when the caller gives no value. */
-  readonly defaults: Readonly<O>;
-  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
-  readonly maxNodes?: number;
-  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
-  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
-}
-/** A strategy of any step. A registry holds a list of these. */
-export type AnyStrategy = { [S in Step]: Strategy<S>; }[Step];
-/** The definition of a strategy, for `defineStrategy`. */
-export interface StrategyDefinition<S extends Step, O extends object> {
-  readonly step: S;
-  readonly name: string;
-  readonly describe: string;
-  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
-  readonly defaults: O;
-  readonly maxNodes?: number;
-  /** This function does the step. It gets each option, from the caller or from `defaults`. */
-  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
+export declare function formatFaults(rows: readonly BenchRow[]): string;
+/** A row with the faults of each zoom level, as `formatLevels` reads it: a router or a setting on one fixture. */
+export interface LevelRow {
+  readonly router: string;
+  readonly fixture: string;
+  readonly levelFaults: readonly LevelFaults[];
 }
-/**
- * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
- * When the caller gives no option, the definition gets the `defaults` object itself.
- */
-export declare function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O>;
-/**
- * A registry: the strategies of each step, in order. A registry is data. No import changes it.
- * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
- */
-export type Registry = { readonly [S in Step]: readonly Strategy<S>[]; };
-/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
-export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
-/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
-export declare function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry;
-/** This function gives the strategies of one step of a registry, in order. */
-export declare function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[];
-/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
-export declare function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined;
-/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
-export declare function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S>;
-/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
-export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
-/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
-export declare function routersOf(registry: Registry): Router[];
+/** This function writes the faults of each zoom level with groups as a Markdown table, one line for each level. */
+export declare function formatLevels(rows: readonly LevelRow[]): string;
 /**
  * One row of the benchmark of the curves: one curve type on the routes of one router on one fixture.
  * The type `T` of the name of the curve is `CurveType` for `benchCurves`, and `string` for `benchCurveStrategies`.
@@ -1207,6 +1858,127 @@ export declare function benchCurves(router: Router, fixture: string, graph: Grap
 export declare function benchCurveStrategies(router: Router, fixture: string, graph: Graph, curves: readonly Strategy<"curve">[], options?: CurveBenchOptions): CurveBenchRow<string>[];
 /** This function writes the rows of `benchCurves` as a Markdown table. */
 export declare function formatCurves(rows: readonly CurveBenchRow<string>[]): string;
+/** The options of `measureHighways`. */
+export interface HighwayMeasureOptions {
+  /** The largest width of an open segment, as in `laneRoutes`. The default is 16. */
+  readonly maxWidth?: number;
+  /** A piece of a curve with a radius under this value counts in `underMin`. The default is 4. */
+  readonly minRadius?: number;
+  /** The length at each end of a segment that the spacing does not sample, for the merges and the splits. The default is 12. */
+  readonly ends?: number;
+  /** The free space of the board. With it, the measure counts the lanes that go through a box that their polyline avoids. */
+  readonly space?: CurveSpace;
+}
+/**
+ * The measures of the lanes of the open segments of a board, after a curve.
+ * The spacing errors are shares of the spacing of the segment: 0.05 is 5% of the spacing.
+ */
+export interface HighwayMeasures {
+  /** The number of open segments with two lanes or more. */
+  readonly bundles: number;
+  /** The number of curves of edges in an open segment. */
+  readonly lanes: number;
+  /** The number of sample points of the spacing. */
+  readonly samples: number;
+  /** The largest spacing error at a sample point. */
+  readonly worstSpacing: number;
+  /** The mean spacing error of the sample points. */
+  readonly meanSpacing: number;
+  /** The share of the sample points with a spacing error over `SPACING_LIMIT`. */
+  readonly overLimit: number;
+  /** The number of points where two lanes of one open segment cross, in the body of the segment: its bends and its straight parts. */
+  readonly crossings: number;
+  /** The number of points where two lanes of one open segment cross near an end of the segment, in the option `ends`. These are the merges and splits. */
+  readonly endCrossings: number;
+  /** The number of breaks of the tangent (G1 faults) near the open segments, by more than `BREAK` radians. */
+  readonly breaks: number;
+  /** The smallest radius of an arc or a cubic piece near the open segments. It is `Infinity` when there is no such piece. */
+  readonly minRadius: number;
+  /** The number of arcs and cubic pieces near the open segments with a radius under the option `minRadius`. */
+  readonly underMin: number;
+  /** The number of lanes that go through a box that their polyline of `laneRoutes` avoids. */
+  readonly through: number;
+}
+/** A break of the tangent larger than this angle, in radians, counts in `breaks`. */
+export declare const BREAK = .01;
+/** A spacing error over this share of the spacing counts in `overLimit`. */
+export declare const SPACING_LIMIT = .05;
+/**
+ * This function measures the lanes of the open segments of a board after a curve. It measures the spacing, the crossings,
+ * the breaks of the tangent, the radii and the lanes that go through a box.
+ *
+ * A lane is in a segment where it goes near the center line of the segment, in its direction along the segment.
+ * The spacing samples each lane `spacing / 4` apart, from the middle of the first leg to the middle of the last leg.
+ * It does not sample the lane in the option `ends`. The ends of a segment are for the merges and the splits.
+ *
+ * A sample compares the distance to the next lane with the spacing. It counts when the next lane is in the band of the segment.
+ * The crossings, the breaks and the radii count along the full segment, and `ends` past each end of it.
+ */
+export declare function measureHighways(graph: SegmentGraph, open: ReadonlySet<string>, laneWidth: number, curves: readonly LaneCurve[], options?: HighwayMeasureOptions): HighwayMeasures;
+/** One row of `benchHighways`: the measures of the lanes of one router on one board, after one way to curve them. */
+export interface HighwayBenchRow extends HighwayMeasures {
+  readonly router: string;
+  readonly fixture: string;
+  /** The way to curve the lanes: `rounded` curves each lane alone, and `highway` curves the lanes of a bundle together. */
+  readonly curve: "rounded" | "highway";
+  /** The shape of the S curves of a row `highway`. */
+  readonly jog?: JogStyle;
+  /** The measures of the S curves of a row `highway`. */
+  readonly jogs?: JogMeasures;
+  /** The time to make all curves, in milliseconds. */
+  readonly ms: number;
+}
+/** The measures of the S curves where the lanes join or leave a bundle. Each curvature is in 1 / units. */
+export interface JogMeasures {
+  /** The number of S curves. */
+  readonly count: number;
+  /** The number of S curves that are a biarc. A polynomial S curve that does not fit on its leg is a biarc. */
+  readonly biarcs: number;
+  /** The median and the largest of the peak curvature of each S curve with the shape of the row. */
+  readonly peakMedian: number;
+  readonly peakMax: number;
+  /** The median ratio of the peak curvature of each S curve of the row to the peak curvature of the same biarc S curve. */
+  readonly peakRatio?: number;
+  /** The largest curvature at an end of an S curve with the shape of the row. The straight leg next to it has the curvature 0, so it is the jump at the end. */
+  readonly endJump: number;
+  /** The largest jump of the curvature at a joint inside an S curve with the shape of the row. */
+  readonly innerJump: number;
+}
+/** This function gives the peak curvature of each S curve, by lane. `jogs` has the first and the last index of each S curve in the segments of its lane. */
+export declare function jogPeaks(curves: readonly LaneCurve[], jogs: JogTrace): number[][];
+/**
+ * This function gives the peak curvature of one curve, in 1 / units: the largest curvature of its lines, cubic pieces and arcs (C5 of MEAS0 as `1 / rmin`).
+ * A joint with a tangent break of more than 0.5 degrees is a sharp corner, so such a curve gets `Infinity`. A curve of lines only gives 0.
+ */
+export declare function peakCurvature(segments: readonly CurveSegment[]): number;
+/**
+ * This function measures the S curves of the lanes that have the shape `style`. `jogs` has the first and the last index of each S curve in the segments of its lane.
+ * With `biarcPeaks`, the peak curvatures of the same S curves as biarcs, it also gives the median ratio of the peaks.
+ */
+export declare function measureJogs(curves: readonly LaneCurve[], jogs: JogTrace, style?: JogStyle, biarcPeaks?: readonly (readonly number[])[]): JogMeasures;
+/** The options of `benchHighways`. */
+export interface HighwayBenchOptions {
+  /** The spacing of the lanes. The default is 4. */
+  readonly spacing?: number;
+  /** The largest width of an open segment. The default is 16. */
+  readonly maxWidth?: number;
+  /** The radius of each curve. The default is 12. */
+  readonly radius?: number;
+  /** The smallest radius of `highwayCurves`, and the limit of `underMin`. The default is 4. */
+  readonly minRadius?: number;
+  /** The shapes of the S curves. Each shape gives one row `highway`. The default is `["biarc"]`. */
+  readonly jogs?: readonly JogStyle[];
+  /** The number of cubic pieces of a `quintic` S curve. The default is 4. */
+  readonly jogPieces?: number;
+}
+/**
+ * This function routes a graph, opens each shared segment, and curves the lanes in two ways.
+ * The row `rounded` curves each lane of `laneRoutes` alone with the curve `rounded`. Each row `highway` curves them with `highwayCurves` and one shape of S curve.
+ * Both ways get the free space of the nodes.
+ */
+export declare function benchHighways(router: Router, fixture: string, graph: Graph, options?: HighwayBenchOptions): HighwayBenchRow[];
+/** This function writes the rows of `benchHighways` as a Markdown table. The spacing errors are percents of the spacing. */
+export declare function formatHighways(rows: readonly HighwayBenchRow[]): string;
 /** One row of the benchmark of the room: one state of a board, packed or open, and the measures of its links. */
 export interface RoomBenchRow {
   readonly fixture: string;
@@ -1268,6 +2040,669 @@ export declare function laneSettings(spacings?: readonly number[], orders?: read
 export declare function passSettings(gutters?: readonly number[], passes?: readonly number[]): RoomSetting[];
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 export declare function formatRoom(rows: readonly RoomBenchRow[]): string;
+/** One row of the benchmark of the room of the zoom levels: one level with groups of one board. */
+export interface LevelRoomRow {
+  readonly fixture: string;
+  /** The board: `packed`, `gutter` (each level open to the gutter only), `routes` (the room of the nodes alone), `levels` or `levels each`. */
+  readonly board: string;
+  readonly depth: number;
+  /** The number of items of the level. */
+  readonly items: number;
+  /** The number of links of the level. */
+  readonly links: number;
+  /** The area of the bounding box of the items of the level, as a share of the area of the packed board. */
+  readonly area: number;
+  /** The number of level links that go through a box that is not one of their ends. */
+  readonly through: number;
+  /** The crossings of the level links, with a lane for each link in each gap (`gapLanes` with the order `crossings`). */
+  readonly crossings: number;
+  /** The crossings of the level links without lanes. The links of a gap share one line, so this count hides crossings. */
+  readonly sharedCrossings: number;
+  /** The mean detour of the level links. */
+  readonly detour: number;
+  /** The worst detour of the level links. */
+  readonly worstDetour: number;
+  /** The number of pairs of items of the level whose order or alignment on an axis is not the order of the packed board. */
+  readonly order: number;
+  /** The number of pairs of items of the level before whose order or alignment on an axis changes at this level. */
+  readonly levelOrder: number;
+  /**
+   * The mean shift of an item against its parent from the level before, in gutters. The shift compares the place of the item in its parent
+   * at this level with its place in its parent at the level before. The value 0 means that the item moves with its parent.
+   */
+  readonly shift: number;
+  /** The largest shift of an item against its parent, in gutters. */
+  readonly worstShift: number;
+  /** The time to open the board of all levels, in milliseconds. It is 0 for the packed board. */
+  readonly ms: number;
+}
+/**
+ * This function counts the pairs of boxes whose order or alignment on an axis is not the same in `a` and in `b`.
+ * The order of two boxes is the order of their left (or top) edges. The cost is quadratic in the number of boxes.
+ */
+export declare function orderChanges(a: readonly Box[], b: readonly Box[], snap?: number): number;
+/**
+ * This function measures the room of the zoom levels of a board. The rows of each board give each level with groups, from depth 1.
+ * The boards are the packed board, the fair baseline with each level open to the gutter only, and the room of the nodes alone (`makeRoom`).
+ * Then come two boards of `levelRoom` with the options. The board `levels` uses the board of the nearest level for each level.
+ * The board `levels each` has a board for each level.
+ *
+ * The links of each level are `levelLinks` with their defaults. Each link gets a lane of `spacing` in each gap.
+ */
+export declare function benchLevelRoom(fixture: string, graph: Graph, options?: LevelRoomOptions, sections?: SectionOptions): LevelRoomRow[];
+/** This function writes the rows of `benchLevelRoom` as a Markdown table. */
+export declare function formatLevelRoom(rows: readonly LevelRoomRow[]): string;
+/** One row of `benchBendRoom`: the lanes of the bundles of one router on one open board, after `highwayCurves`. */
+export interface BendRoomRow extends HighwayMeasures {
+  readonly router: string;
+  readonly fixture: string;
+  /** The board: `room` opens the gaps for the links only, and `room + bends` also opens them for the bends of the bundles. */
+  readonly board: "room" | "room + bends";
+  /** The area of the bounding box of the boxes, as a share of the area of the board before the room. */
+  readonly area: number;
+}
+/**
+ * This function measures the room for the bends of the bundles (HWC-D). It opens the board two times with `makeRoom`, without and with the option `bends`.
+ * The option `bends` gets the router and the lane options of the curves. Then the router routes each open board, and `benchHighways` curves its bundles with `highway`.
+ */
+export declare function benchBendRoom(router: Router, fixture: string, graph: Graph, options?: RoomOptions): BendRoomRow[];
+/** This function writes the rows of `benchBendRoom` as a Markdown table. The spacing error is a percent of the spacing. */
+export declare function formatBendRoom(rows: readonly BendRoomRow[]): string;
+/** The options of one setting of the router `sections`, without the name. */
+export type SectionsSettingOptions = Omit<SectionsOptions, "name" | "maxNodes">;
+/** One setting of a sweep of the router `sections`. */
+export interface SectionsSetting {
+  /** The name of the setting in the column `setting`. */
+  readonly name: string;
+  readonly options: SectionsSettingOptions;
+}
+/** One row of a sweep of the router `sections`: one setting on one board, and the measures of its routes and of its zoom levels. */
+export interface SectionsBenchRow {
+  readonly fixture: string;
+  readonly setting: string;
+  /** The faults of the routes of the edges (`measureRouteFaults`). */
+  readonly faults: LinkFaults;
+  /** The sum of the faults of the levels with groups (`measureLevelFaults` and `sumFaults`). */
+  readonly levelFaults: LinkFaults;
+  /** The sum of the overlaps of the levels with groups. */
+  readonly overlaps: number;
+  /** The number of routes that go through hubs: the routes that are not the same as the direct route of their edge. */
+  readonly hubRoutes: number;
+  /** The number of shared stretches of way of the result (`runs`). */
+  readonly runs: number;
+  /** The number of zoom levels, with the last level of single nodes. */
+  readonly levels: number;
+  /** The number of items of the far view: the first level with more than one item. */
+  readonly farItems: number;
+  /** The time of one route, in milliseconds. */
+  readonly ms: number;
+}
+/**
+ * This function measures the router `sections` on one board with each setting. The first row is the fair baseline: the defaults, with no option.
+ * The direct routes come from the hub limit 0, so `hubRoutes` counts the routes that use the hubs.
+ */
+export declare function sweepSections(fixture: string, graph: Graph, settings: readonly SectionsSetting[]): SectionsBenchRow[];
+/** The values of the hub limit (`stretch`) of the sweep of CUSTOM. The default is 2. */
+export declare const STRETCH_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the hub limit: one setting for each value of `stretch`. */
+export declare function stretchSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of `hubSlack` of the sweep of CUSTOM. The default is 80. */
+export declare const SLACK_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the slack of the hubs: one setting for each value of `hubSlack`. */
+export declare function slackSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of the section limit (`cap`) of the sweep of CUSTOM. The default is 8. */
+export declare const CAP_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the section limit: one setting for each value of `cap`. */
+export declare function capSettings(values?: readonly number[]): SectionsSetting[];
+/**
+ * This function gives one setting for each grouping rule: the router `sections` with the strategy as its option `group`.
+ * The map `options` gives the options of a strategy by its name.
+ */
+export declare function groupSettings(strategies?: readonly Strategy<"group">[], options?: Readonly<Record<string, object>>): SectionsSetting[];
+/** This function writes the rows of `sweepSections` as a Markdown table. */
+export declare function formatSections(rows: readonly SectionsBenchRow[]): string;
+/**
+ * This function gives the `p` quantile of the values, with a linear step between two ranks (type 7 of Hyndman and Fan).
+ * The result is `NaN` for an empty list.
+ */
+export declare function quantile(values: readonly number[], p: number): number;
+/** The spread of a measure over the seeds of a fixture family. */
+export interface Spread {
+  /** The number of values. */
+  readonly n: number;
+  readonly median: number;
+  /** The `0.25` quantile. */
+  readonly q1: number;
+  /** The `0.75` quantile. */
+  readonly q3: number;
+  /** The interquartile range: `q3 - q1`. */
+  readonly iqr: number;
+  readonly min: number;
+  readonly max: number;
+}
+/** This function gives the median, the quartiles, the interquartile range, the smallest and the largest value of a list. */
+export declare function summarize(values: readonly number[]): Spread;
+/** The largest number of values for which `kendallTau` examines each pair. Above it, the function examines a seeded sample of pairs. */
+export declare const KENDALL_EXACT = 1500;
+/**
+ * This function gives the Kendall tau-b of two lists of the same length (Kendall, 1938).
+ * The value is from -1 to 1. A value of 1 means the same order. A pair with a tie in both lists does not count.
+ * When one list has only ties, the value is 1. Above `KENDALL_EXACT` values, a seeded sample of 200 000 pairs gives an estimate.
+ */
+export declare function kendallTau(a: readonly number[], b: readonly number[], seed?: number): number;
+/**
+ * This function gives the adjusted Rand index of two groupings of the same items (Hubert and Arabie, 1985).
+ * The item `i` is in the group `a[i]` of the first grouping and in the group `b[i]` of the second grouping.
+ * The value is 1 for the same grouping, and near 0 for a random grouping. Two groupings with one group each give 1.
+ */
+export declare function adjustedRandIndex(a: readonly (string | number)[], b: readonly (string | number)[]): number;
+/** A drawn segment: a pair of points. */
+export type DrawnSegment = readonly [Point, Point];
+/**
+ * This function gives the drawn segments of the routes: one segment for each distinct pair of ends.
+ * A segment that several routes share is one drawn segment, as in `measureQuality`.
+ */
+export declare function drawnSegments(routes: readonly Route[]): DrawnSegment[];
+/** This function gives the key of the drawn segment between two points. Two routes share a segment when they give the same key. */
+export declare function segmentKey(a: Point, b: Point): string | undefined;
+/**
+ * This function gives the unit of length of a board: the median of the short sides of the boxes of the nodes.
+ * A length divided by the unit has no unit, so boards of different sizes compare. The unit of a board without nodes is 1.
+ */
+export declare function boardUnit(graph: Graph): number;
+/** The crossings of a set of drawn segments and their angles (R1 and R2 of MEAS0). */
+export interface CrossingAngles {
+  /** The number of crossings (R1). It is the same value as `crossings` of `measureQuality`. */
+  readonly crossings: number;
+  /** This value is true when the values come from a sample of the segments. */
+  readonly estimated: boolean;
+  /** The mean angle of a crossing, divided by 90 degrees (R2). The scale is 0 to 1, and higher is better. A set without crossings gives 1. */
+  readonly mean: number;
+  /** The smallest angle of a crossing, in degrees from 0 to 90 (R2). Higher is better. A set without crossings gives 90. */
+  readonly min: number;
+}
+/** This function gives the angle between two segments, in degrees from 0 to 90. */
+export declare function crossingAngle(a: Point, b: Point, c: Point, d: Point): number;
+/**
+ * This function measures the crossings of a set of segments and their angles (R1 and R2 of MEAS0).
+ * It uses the grid and the sample of `countCrossings`. Above 20 000 segments, a seeded sample of 2 000 segments gives an estimate.
+ * The cost is `n log n`.
+ */
+export declare function crossingAngles(segs: readonly DrawnSegment[]): CrossingAngles;
+/** The total turn of the routes (R4 of MEAS0). */
+export interface TotalTurn {
+  /** The mean over the routes of `T(r) = Σ abs(φ_i) / π`, in half turns. Lower is better. */
+  readonly mean: number;
+  /** The largest turn at one vertex of a route, in degrees from 0 to 180. Lower is better. */
+  readonly max: number;
+}
+/** This function measures the total turn of the routes (R4 of MEAS0). A path that goes straight on has 0. The cost is linear. */
+export declare function totalTurn(routes: readonly Route[]): TotalTurn;
+/** The spread of the detour of the routes (R5 of MEAS0). */
+export interface DetourSpread {
+  /** The median of `δ(e) = L(r_e) / span(e)`. */
+  readonly median: number;
+  /** The `0.95` quantile of `δ(e)`: the tail of bad routes. */
+  readonly q95: number;
+  readonly mean: number;
+}
+/**
+ * This function measures the spread of the detour `δ(e) = L(r_e) / span(e)` of the routes (R5 of MEAS0).
+ * A route with ends nearer than 1 unit does not count. Each value is 1 or more, and lower is better. The cost is linear.
+ */
+export declare function detourSpread(routes: readonly Route[]): DetourSpread;
+/** The spacing of the plugs on the sides of the boxes (R11 of MEAS0). */
+export interface PlugSpacing {
+  /** The smallest spacing of a side. The scale is 0 to 1, and higher is better. A value of 1 is even spacing. */
+  readonly min: number;
+  /** The `0.05` quantile of the spacing of the sides. */
+  readonly q05: number;
+  /** The number of sides with two plugs or more. */
+  readonly sides: number;
+}
+/**
+ * This function measures the spacing of the plugs on each side of each box (R11 of MEAS0), the angular resolution of a box.
+ * For a side with `k` distinct plugs, `ps = min gap / (side / (k + 1))`, with a limit of 1.
+ * Two ends nearer than `TOLERANCE` are one plug, because a bundle shares its plug. An end farther than 1 unit from the side does not count.
+ * Without a side with two plugs, each value is 1. The cost is `n log n`.
+ */
+export declare function plugSpacing(graph: Graph, routes: readonly Route[]): PlugSpacing;
+/**
+ * This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
+ * `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
+ */
+export declare function inkSaved(routes: readonly Route[]): number;
+/** The ambiguity of a result (B4 of MEAS0). */
+export interface Ambiguity {
+  /** The share of false neighbours, from 0 to 1. Lower is better. */
+  readonly value: number;
+  /** This value is true when the value comes from a sample of the nodes. */
+  readonly estimated: boolean;
+}
+/** The options of `ambiguity`. */
+export interface AmbiguityOptions {
+  /** Up to this number of nodes, the function examines each node. The default is 1000. */
+  readonly exact?: number;
+  /** Above `exact` nodes, the function examines this number of nodes from a seeded sample. The default is 2000. */
+  readonly sample?: number;
+  /** The seed of the sample. The default is 1. */
+  readonly seed?: number;
+}
+/**
+ * This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
+ * `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
+ * `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
+ */
+export declare function ambiguity(graph: Graph, routes: readonly Route[], options?: AmbiguityOptions): Ambiguity;
+/** A joint of a curve: the end of one drawn segment and the start of the next drawn segment. */
+export interface CurveJoint {
+  readonly at: Point;
+  /** The angle between the tangent at the end of the first segment and the tangent at the start of the second segment, in degrees. */
+  readonly angle: number;
+  /** The jump of the curvature at the joint, `abs(κ^- - κ^+)`, in 1 / units. */
+  readonly jump: number;
+  /** The unit tangent at the end of the first segment. */
+  readonly before: Point;
+  /** The unit tangent at the start of the second segment. */
+  readonly after: Point;
+}
+/**
+ * This function gives the joints of a curve: each point where one drawn segment ends and the next one starts.
+ * A segment of length 0 has no tangent, so the joint skips it. The analytic tangents and curvatures of lines, cubic curves and arcs give the values.
+ */
+export declare function curveJoints(segments: readonly CurveSegment[]): CurveJoint[];
+/**
+ * This function gives the G1 defect of a curve (C1 of MEAS0): `g1 = max_j angle(T_j^-, T_j^+)` over the joints, in degrees.
+ * Lower is better. A curve is G1 when `g1` is 0.5 degrees or less. The cost is linear.
+ */
+export declare function g1Defect(segments: readonly CurveSegment[]): number;
+/**
+ * This function gives the G2 defect of a curve (C2 of MEAS0): `g2 = max_j abs(κ_j^- - κ_j^+) · u` over the joints.
+ * The value has no unit, and lower is better. `u` is the unit of the board (`boardUnit`). The cost is linear.
+ */
+export declare function g2Defect(segments: readonly CurveSegment[], u: number): number;
+/**
+ * This function gives the bending energy of a sampled curve (C3 of MEAS0): `E = L · ∫ κ(s)^2 ds`.
+ * At each inner sample, `κ = φ / l`, so `E = L · Σ φ_i^2 / l_i`. The length `l_i` is the mean of the two legs, with a limit of `8τ / φ_i`.
+ * Thus a sharp corner counts as an arc with a sagitta of `τ`, the tolerance of the samples.
+ *
+ * The value has no unit, and lower is better. A full circle gives `4π^2`. The cost is linear.
+ */
+export declare function bendingEnergy(points: readonly Point[], tolerance?: number): number;
+/** This function tells if a polyline crosses itself. Two legs next to each other do not count. The cost is `n log n`. */
+export declare function crossesItself(p: readonly Point[]): boolean;
+/** This function tells if a polyline turns back on itself at a vertex: a turn of more than 179 degrees, as at a cusp. */
+export declare function hasCusp(p: readonly Point[]): boolean;
+/** The input of `curveFaults`: one curve and the polyline that it draws. */
+export interface CurveCheck {
+  /** The polyline of the route. */
+  readonly polyline: readonly Point[];
+  /** The segments of the curve. */
+  readonly segments: readonly CurveSegment[];
+  /** The samples of the curve (`sampleCurve`). */
+  readonly samples: readonly Point[];
+  /** The free space of the board. Without it, the check `clear` gives false. */
+  readonly space?: CurveSpace;
+  /** With these normals, the check `ends` also examines the direction of the curve at its two ends. */
+  readonly startNormal?: Point;
+  readonly endNormal?: Point;
+  /** With this value, the check `g1` examines the joints. Give it for a curve type that is G1 by its design. */
+  readonly smooth?: boolean;
+}
+/** The faults of one curve: one value for each proposed hard rule of the curves in MEAS0. */
+export interface CurveFaults {
+  /** `curve-clear`: the curve goes through a box that its polyline avoids (C7). */
+  readonly clear: boolean;
+  /** `curve-ends`: the curve misses an end of its polyline, or an end tangent is more than 1 degree off its normal (C10). */
+  readonly ends: boolean;
+  /** `curve-g1`: a joint has a G1 defect of more than 0.5 degrees, and it is not a corner that the free space keeps sharp (C1). */
+  readonly g1: boolean;
+  /** `curve-simple`: the curve crosses itself or turns back at a cusp, and its polyline does not (C9). */
+  readonly simple: boolean;
+}
+/** This function checks one curve against the proposed hard rules of the curves of MEAS0. The cost is `n log n` for each curve. */
+export declare function curveFaults(c: CurveCheck): CurveFaults;
+/**
+ * This function counts the faults of the nesting of the levels (Z6 of MEAS0, the proposed rule `level-nesting`).
+ * It counts the items of each level whose nodes are in more than one item of the level before it. Lower is better, and 0 is correct.
+ * The cost is linear.
+ */
+export declare function nestingFaults(levels: readonly Level[]): number;
+/**
+ * This function measures the position stability of the levels (Z7 of MEAS0).
+ * `ps = mean_(v,d) dist(center(item_d(v)), center(item_(d+1)(v))) / size(item_d(v))`, with `size` the longer side of the box.
+ * The value has no unit, and lower is better. A result with one level gives 0. The cost is linear.
+ */
+export declare function positionStability(levels: readonly Level[]): number;
+/**
+ * This function measures the order stability of the levels with groups (Z8 of MEAS0).
+ * For each level, `τ_x` and `τ_y` are the Kendall tau between the item centers and the centroids of their nodes on each axis.
+ * The value is the mean of `(τ_x + τ_y) / 2` over the levels with groups and two items or more. The scale is -1 to 1, and higher is better.
+ * A result without such a level gives 1. The cost is `n log n`, with a sample above 1500 items.
+ */
+export declare function orderStability(graph: Graph, levels: readonly Level[]): number;
+/** A grouping of the nodes: a map from the id of each node to the id of its group. */
+export type Grouping = ReadonlyMap<string, string>;
+/** This function gives the grouping of one level: each node goes to the id of its item. */
+export declare function levelGrouping(level: Level): Map<string, string>;
+/** This function gives the far view of a result: the first level with more than one item, in the order of depth. */
+export declare function farLevel(levels: readonly Level[]): Level | undefined;
+/**
+ * This function gives the modularity of a grouping (G1 of MEAS0, Newman and Girvan, 2004).
+ * `Q = Σ_c (e_c / m - (d_c / (2m))^2)`, with `e_c` the edges inside `c` and `d_c` the sum of the degrees in `c`.
+ * The scale is -0.5 to 1, and higher is better. A node without a group is a group alone. The cost is linear.
+ */
+export declare function modularity(graph: Graph, groups: Grouping): number;
+/**
+ * This function gives the cut share of a grouping (G2 of MEAS0): the share of the edges between two groups.
+ * For the grouping of a level, it is the sum of the counts of the links of the level, divided by `m`. The scale is 0 to 1, and lower is better.
+ */
+export declare function cutShare(graph: Graph, groups: Grouping): number;
+/**
+ * This function gives the balance of one level (G6 of MEAS0): `H(s) / log(k)`, with `s` the shares of the nodes of the `k` items and `H` the entropy.
+ * The scale is 0 to 1, and higher is better. A value of 1 is items of equal size. A level with one item gives 1.
+ */
+export declare function balance(level: Level): number;
+/**
+ * This function gives the tree cost of the levels (G8 of MEAS0, Dasgupta, 2016): `D = Σ_(u,v) leaves(lca(u, v)) / (m n)`.
+ * The levels make the tree. `leaves(lca(u, v))` is the number of nodes of the deepest item that holds both ends.
+ * Without such an item, the value is `n`. The scale is 0 to 1, and lower is better. The cost is linear times the depth.
+ */
+export declare function treeCost(graph: Graph, levels: readonly Level[]): number;
+/** This function gives the leaf of each node in a tree of sections: the id of the leaf, by the index of the node. */
+export declare function leafGroups(root: Section, count: number): string[];
+/**
+ * This function gives the group stability of two trees of the same nodes (G9 of MEAS0): the adjusted Rand index of their leaves.
+ * The second tree comes from the graph after a small change (`changeGraph`). The scale is -1 to 1, and higher is better.
+ */
+export declare function groupStability(before: Section, after: Section, count: number): number;
+/** A small change of a graph, for the stability measures Z10 and G9 of MEAS0. */
+export interface GraphChange {
+  /** The graph after the change. It keeps the order of the nodes. */
+  readonly graph: Graph;
+  /** The node that moved by one unit, if a free place was found. */
+  readonly moved?: string;
+  /** The new edge, if the graph has two nodes without an edge between them. */
+  readonly added?: string;
+  /** The edge that the change removed. */
+  readonly removed?: string;
+}
+/**
+ * This function makes a seeded small change of a graph: one node moves by `boardUnit`, one edge goes and one new edge comes.
+ * The moved box keeps a gap of 4 units to the other boxes. The same graph and the same seed give the same change.
+ */
+export declare function changeGraph(graph: Graph, seed: number): GraphChange;
+/** The route stability of a router (Z10 of MEAS0). */
+export interface RouteStability {
+  /** The mean Fréchet distance between the two routes of an edge, divided by the unit of the board. */
+  readonly mean: number;
+  /** The largest Fréchet distance, divided by the unit of the board. */
+  readonly max: number;
+  /** The share of the routes that moved more than 1 unit of length. */
+  readonly moved: number;
+}
+/** The options of `routeStability`. */
+export interface RouteStabilityOptions {
+  /** Above this number of routes, a seeded sample of this size serves. The default is 2000. */
+  readonly sample?: number;
+  readonly seed?: number;
+}
+/**
+ * This function measures the route stability of a router (Z10 of MEAS0) with `measureStability`.
+ * It compares the routes of the edges that both results have. Each distance is divided by the unit of the board.
+ * The cost is quadratic for each route, so a seeded sample serves above `sample` routes.
+ */
+export declare function routeStability(graph: Graph, before: Result, after: Result, options?: RouteStabilityOptions): RouteStability;
+/**
+ * This function counts the pairs of boxes whose order or alignment changes on an axis (M2 of MEAS0, the proposed rule `room-order`).
+ * On each axis, it compares the order of the low edges, the order of the high edges, and the relation "a ends before b starts".
+ * Two values nearer than `snap` are equal. Lower is better, and 0 is correct. Above 2000 boxes, a seeded sample of pairs gives an estimate.
+ */
+export declare function roomOrderFaults(before: readonly Boxed[], after: readonly Boxed[], snap?: number): number;
+/** One axis of a Pareto front: the key of a measure and the direction that is better. */
+export interface Objective {
+  readonly key: string;
+  /** `min`: lower is better. `max`: higher is better. */
+  readonly better: "min" | "max";
+}
+/**
+ * This function tells if the values `a` dominate the values `b`: `a` is no worse on each objective and better on one objective.
+ * A missing value or `NaN` is the worst value.
+ */
+export declare function dominates(a: Readonly<Record<string, number>>, b: Readonly<Record<string, number>>, objectives: readonly Objective[]): boolean;
+/**
+ * This function gives the Pareto front of a list: the items that no other item dominates (MEAS0, "Pareto fronts").
+ * The function `values` gives the measures of an item. The front keeps the order of the list. The cost is quadratic in the items.
+ */
+export declare function paretoFront<T>(items: readonly T[], values: (item: T) => Readonly<Record<string, number>>, objectives: readonly Objective[]): T[];
+/** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
+export declare const PROPOSED_RULES: readonly string[];
+/** The options of `runSuite`. */
+export interface SuiteOptions {
+  /** The largest fixture, in nodes. The default is 1000. */
+  readonly max?: number;
+  /** The number of seeds of each fixture family. The default is 5. The first seed is the seed of the fixture. */
+  readonly seeds?: number;
+  /** A fixture family or a room family with more nodes than this number gets one seed only. The default is 1000. */
+  readonly seedsMaxNodes?: number;
+  /** The number of timed routes of the first seed. The other seeds route two times, for the rule "same twice". The default is 3. */
+  readonly repeat?: number;
+  /** The route stability (Z10) routes a changed graph again, so the suite measures it only up to this number of nodes. The default is 1000. */
+  readonly stabilityMax?: number;
+  /** The step `curve` draws the routes of the fixtures up to this number of nodes. The default is 1000. */
+  readonly curveMax?: number;
+  /** The router whose routes the step `curve` draws. The default is `corners`. */
+  readonly curveRouter?: string;
+  /** The curve strategies that are G1 by their design. The rule `curve-g1` examines them. The default is `rounded`, `arc`, `spline`, `smooth`, `clothoid` and `highway`. */
+  readonly smoothCurves?: readonly string[];
+  /** The curve strategies that read the normals of the plugs. The rule `curve-ends` examines their end tangents. The default is `spline`. */
+  readonly normalCurves?: readonly string[];
+  /** The strategies of each step. The default is the registry of the built-in strategies. */
+  readonly registry?: Registry;
+  /** The fixtures of the families of the steps `router`, `curve` and `group`. The default is `FIXTURES`. */
+  readonly fixtures?: readonly FixtureSpec[];
+  /** The families of the step `room`. The default is `ROOM_FAMILIES`. */
+  readonly roomFamilies?: readonly RoomFamily[];
+  /** The names of the routers of the step `router`. The default is each router of the registry. */
+  readonly routers?: readonly string[];
+  /** The steps that the suite runs. The default is each step. Each part of the workflow `Bench` runs some steps only. The step `curve` needs the step `router`. */
+  readonly steps?: readonly Step[];
+  /** The time limit of one cell of the step `router`, in milliseconds, as `BenchOptions.cellLimit` gives it. The default is no limit. */
+  readonly cellLimit?: number;
+  /** This function gets one line of progress for each fixture and seed. */
+  readonly log?: (line: string) => void;
+}
+/** A family of packed boards for the step `room`: `packedGridBoard` with a seed for each member. */
+export interface RoomFamily {
+  readonly name: string;
+  readonly cols: number;
+  readonly rows: number;
+  /** The number of long links. */
+  readonly long: number;
+}
+/** The families of the step `room`: the board of ROOM, and a board of 1000 boxes. */
+export declare const ROOM_FAMILIES: readonly RoomFamily[];
+/** One row of the suite: one strategy of one step on one member of a fixture family. */
+export interface SuiteRow {
+  readonly step: Step;
+  /** The name of the fixture family. */
+  readonly fixture: string;
+  /** The index of the seed in the family, from 0. */
+  readonly seed: number;
+  readonly strategy: string;
+  readonly nodes: number;
+  readonly edges: number;
+  /**
+   * The violations of the hard rules of today. The step `router` checks `checkProperties` and "same twice".
+   * The step `group` checks `checkSections` and the rules of the levels (`checkLevels`).
+   */
+  readonly violations: number;
+  /** The time of the step and of the measures of today, in milliseconds. */
+  readonly ms: number;
+  /** The time of the new measures of MEAS1, without the extra runs, in milliseconds. */
+  readonly measureMs: number;
+  /** The time of the extra routes of the stability measures (Z10 and G9), in milliseconds. */
+  readonly extraMs: number;
+  /** The time of the grouping rule alone, without the router, in milliseconds. Only the rows of the step `group` have it. */
+  readonly treeMs?: number;
+  /** The measures, by a key that starts with the id of MEAS0, or the name of a proposed rule. */
+  readonly values: Readonly<Record<string, number>>;
+}
+/** The spread of each measure of one strategy on one fixture family, over the seeds. */
+export interface SuiteSummary {
+  readonly step: Step;
+  readonly fixture: string;
+  readonly strategy: string;
+  readonly nodes: number;
+  readonly seeds: number;
+  /** The sum of the violations over the seeds. */
+  readonly violations: number;
+  readonly measures: Readonly<Record<string, Spread>>;
+}
+/** The Pareto front of one step on one fixture family, over the medians of the seeds. */
+export interface SuiteFront {
+  readonly step: Step;
+  readonly fixture: string;
+  readonly nodes: number;
+  readonly objectives: readonly Objective[];
+  /** The strategies on the front, in the order of the registry. */
+  readonly front: readonly string[];
+  /** The strategies with a violation of a hard rule. They do not enter the front. */
+  readonly excluded: readonly string[];
+  /** Each strategy that the front compares. */
+  readonly strategies: readonly string[];
+}
+/** The count of one proposed hard rule for one strategy, over each fixture and each seed. */
+export interface RuleCount {
+  readonly step: Step;
+  readonly strategy: string;
+  readonly rule: string;
+  readonly count: number;
+}
+/** The report of the suite. The workflow `Bench` keeps it as an artifact. */
+export interface SuiteReport {
+  readonly options: {
+    readonly max: number;
+    readonly seeds: number;
+    readonly seedsMaxNodes: number;
+    readonly repeat: number;
+    readonly stabilityMax: number;
+    readonly curveMax: number;
+    readonly curveRouter: string;
+  };
+  readonly rows: readonly SuiteRow[];
+  readonly summaries: readonly SuiteSummary[];
+  readonly fronts: readonly SuiteFront[];
+  readonly rules: readonly RuleCount[];
+}
+/** The axes of the Pareto front of each step. The note MEAS0 asks for two to four scores. */
+export declare const FRONT_OBJECTIVES: Readonly<Record<Step, readonly Objective[]>>;
+/** This function gives the seed of the member `k` of the family of a fixture. The member 0 is the fixture itself. */
+export declare function familySeed(spec: FixtureSpec, k: number): number;
+/** This function gives the measures of the levels of a result: Z6, Z7, Z8, and G1, G2 and G8 of the far view. A result without groups gives none. */
+export declare function levelMeasures(graph: Graph, result: Result): Record<string, number>;
+/** This function gives the new measures of the routes of a result (MEAS1). The row of `benchRun` gives the values of today. */
+export declare function routeMeasures(graph: Graph, result: Result, row: BenchRow): Record<string, number>;
+/** The options of `curveRuns`. */
+export interface CurveRunOptions {
+  /** The name of the fixture family, for the rows. */
+  readonly fixture: string;
+  /** The index of the seed in the family, for the rows. */
+  readonly seed: number;
+  /** The curve strategies that are G1 by their design. The rule `curve-g1` examines them. */
+  readonly smooth: ReadonlySet<string>;
+  /** The curve strategies that read the normals of the plugs. The rule `curve-ends` examines their end tangents. */
+  readonly normals: ReadonlySet<string>;
+  /** The options of each curve strategy, by its name. A strategy without an entry gets its defaults. */
+  readonly curveOptions?: Readonly<Record<string, object>>;
+}
+/** One curve strategy on the routes of one result: the row of the suite and the drawn curves. */
+export interface CurveRun {
+  readonly row: SuiteRow;
+  /** The segments of each curve, in the order of the routes that have two points or more. */
+  readonly drawn: readonly CurveSegment[][];
+  /** The edge of each curve of `drawn`. */
+  readonly edges: readonly string[];
+}
+/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C6 and the curve rules). */
+export declare function curveRuns(graph: Graph, result: Result, curves: readonly Strategy<"curve">[], options: CurveRunOptions): CurveRun[];
+/** One grouping rule on one graph: the row of the suite, the tree of the rule and the result of `sections` on that tree. */
+export interface GroupRun {
+  readonly row: SuiteRow;
+  readonly tree: Section;
+  /** The result of the router `sections` with the tree of the rule. A tree that `checkSections` refuses gives no result. */
+  readonly result?: Result;
+}
+/**
+ * This function groups one graph with one grouping rule, routes it with the router `sections` on that tree, and measures the levels.
+ * The grouping of the changed graph gives the group stability (G9). `options` are the options of the rule on `graph`.
+ */
+export declare function groupRun(graph: Graph, strategy: Strategy<"group">, options: object, change: {
+  readonly graph: Graph;
+  readonly options: object;
+}, at: {
+  readonly fixture: string;
+  readonly seed: number;
+}): GroupRun;
+/**
+ * This function gives the options of a grouping rule on a fixture. The rule `keys` gets a key from the data of the edges:
+ * the collection of the first edge into the node. A node without such an edge is a group alone.
+ */
+export declare function fixtureGroupOptions(strategy: string, graph: Graph): object;
+/**
+ * This function starts the measure suite of MEAS1. The suite measures each strategy of each step on each seed of each fixture family.
+ * The step `router` keeps the rows of today in `bench` for the first seed, so the tables of the benchmark stay the same.
+ */
+export declare function runSuite(options?: SuiteOptions): {
+  report: SuiteReport;
+  bench: BenchRow[];
+};
+/**
+ * This function puts the rows of the suite in the order of one run. It sorts them by fixture family, then by seed.
+ * In one seed, the routers come first, and the curves come after the router of the curves. The grouping rules and the room come last.
+ * A name that is not in its list goes after the names of the list.
+ * The workflow `Bench` uses it to join the reports of its parts.
+ */
+export declare function orderSuiteRows(rows: readonly SuiteRow[], options?: {
+  registry?: Registry;
+  fixtures?: readonly FixtureSpec[];
+  roomFamilies?: readonly RoomFamily[];
+  curveRouter?: string;
+}): SuiteRow[];
+/**
+ * This function joins the reports of the parts of one benchmark into one report. It puts the rows in the order of one run.
+ * Then it calculates the summaries, the fronts and the rule counts again from all the rows.
+ */
+export declare function joinReports(reports: readonly SuiteReport[], options?: {
+  registry?: Registry;
+  fixtures?: readonly FixtureSpec[];
+  roomFamilies?: readonly RoomFamily[];
+}): SuiteReport;
+/** This function gives the spread of each measure of each strategy on each fixture family, over the seeds. It keeps the order of the rows. */
+export declare function summarizeRows(rows: readonly SuiteRow[]): SuiteSummary[];
+/**
+ * This function gives the Pareto front of each step on each fixture family, over the medians of the seeds.
+ * A strategy with a violation of a hard rule does not enter the front, as MEAS0 asks.
+ */
+export declare function suiteFronts(summaries: readonly SuiteSummary[], objectives?: Readonly<Record<Step, readonly Objective[]>>): SuiteFront[];
+/** This function sums each proposed hard rule of MEAS0 for each strategy of each step, over each fixture and each seed. */
+export declare function ruleCounts(rows: readonly SuiteRow[]): RuleCount[];
+/** The columns of the tables of `formatSuite`: the keys of the measures of each step. */
+export declare const SUITE_COLUMNS: Readonly<Record<Step, readonly string[]>>;
+/**
+ * This function writes the summaries of one step as a Markdown table. Each cell is the median over the seeds, with the interquartile range in brackets.
+ * The column `R1 IQR/median` gives the spread of the crossings.
+ */
+export declare function formatSummaries(summaries: readonly SuiteSummary[], step: Step, columns?: readonly string[]): string;
+/** This function writes the Pareto fronts as a Markdown table. */
+export declare function formatFronts(fronts: readonly SuiteFront[]): string;
+/** This function writes the counts of the proposed hard rules as a Markdown table: one row for each step and strategy. */
+export declare function formatRules(rules: readonly RuleCount[]): string;
+/**
+ * This function compares the time of the new measures with the time of the step and the measures of today.
+ * It gives one row for each fixture family of a step. The extra routes of the stability measures have their own column.
+ */
+export declare function formatMeasureTime(rows: readonly SuiteRow[], step?: Step): string;
 /** 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">;
 /** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
@@ -1292,23 +2727,126 @@ export interface TensionOptions {
   /** The tension of the spline, from 0 (the spline) to 1 (the polyline). The default is 0. */
   readonly tension: number;
 }
-/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+/** The options of the curve strategy `highway`. */
+export interface HighwayStrategyOptions {
+  /** The radius of the center line of a bundle at a bend, and of each lone corner. The default is 12. */
+  readonly radius: number;
+  /** The smallest radius of a lane at a bend of a bundle. The default is 4. */
+  readonly minRadius: number;
+  /** The shape of the S curve where a lane changes its offset. The default is `biarc`. */
+  readonly jog: JogStyle;
+  /** The number of cubic pieces of a `quintic` S curve. The default is 4. */
+  readonly jogPieces: number;
+}
+/** The options of the curve strategy `smooth`. */
+export interface SmoothStrategyOptions {
+  /** The radius of the arc of each corner. The default is 12. */
+  readonly radius: number;
+  /** The share of the turn of a corner in its two spirals, from 0 to 1. The default is 0.6. */
+  readonly smoothing: number;
+}
+/** The options of the curve strategy `clothoid`. */
+export interface ClothoidStrategyOptions {
+  /** The radius of the arc of each corner. The default is 12. */
+  readonly radius: number;
+  /** The share of the turn of a corner in its two clothoids, from 0 to 1. The default is 0.5. */
+  readonly spiral: number;
+  /** The largest distance from the cubic pieces to the true clothoid. The default is 0.25. */
+  readonly tolerance: number;
+}
+/**
+ * The built-in curve strategies. The first six are in the order of `CURVE_TYPES`, and each one gives the same segments as `curveOf` with its type.
+ * The strategy `highway` gives the curve of `arc` for one polyline. `highwayCurves` bends the lanes of a bundle as one.
+ */
 export declare const curveStrategies: {
   readonly straight: Strategy<"curve", object>;
   readonly rounded: Strategy<"curve", RadiusOptions>;
   readonly spline: Strategy<"curve", TensionOptions>;
   readonly arc: Strategy<"curve", RadiusOptions>;
+  readonly smooth: Strategy<"curve", SmoothStrategyOptions>;
+  readonly clothoid: Strategy<"curve", ClothoidStrategyOptions>;
+  readonly highway: Strategy<"curve", HighwayStrategyOptions>;
 };
 /** The options of a room strategy: the options of `roomDemand`, without the method. */
 export type RoomPreset = Omit<RoomOptions, "method">;
-/** The built-in room strategies: the methods of `roomDemand`. */
+/** The options of the room strategy `levels`: the options of `levelRoom` without the method, and the limits of the quadtree. */
+export type LevelRoomPreset = Omit<LevelRoomOptions, "method"> & SectionOptions;
+/** The built-in room strategies: the methods of `roomDemand`, and the room of each zoom level (`levelRoom`). */
 export declare const roomStrategies: {
   readonly routes: Strategy<"room", RoomPreset>;
   readonly lines: Strategy<"room", RoomPreset>;
+  readonly levels: Strategy<"room", LevelRoomPreset>;
+};
+/** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
+export declare const groupStrategies: {
+  readonly quadtree: Strategy<"group", Required<SectionOptions>>;
+  readonly keys: Strategy<"group", KeyOptions>;
+  readonly kd: Strategy<"group", Required<KdOptions>>;
+  readonly cut: Strategy<"group", Required<CutOptions>>;
 };
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 export declare const BUILT_IN_STRATEGIES: readonly AnyStrategy[];
 /** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
 export declare const STRATEGIES: Registry;
-export type { ArcOptions, CornersOptions, CurveSpace, RoundedOptions, SectionsOptions, SharedOptions, SplineOptions, TrunksOptions };
+/** The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list. */
+export type CompareStep = Exclude<Step, "room">;
+/** The steps that `compareStep` compares, in the order of the pipeline. */
+export declare const COMPARE_STEPS: readonly CompareStep[];
+/** The options of `compareStep`. */
+export interface CompareOptions {
+  /** The strategies of each step. The default is the registry of the built-in strategies. */
+  readonly registry?: Registry;
+  /** The options of each strategy of the step, by its name. A strategy without an entry gets its defaults. */
+  readonly options?: Readonly<Record<string, object>>;
+  /** The router whose routes the step `curve` draws. The default is `corners`, as in `runSuite`. */
+  readonly curveRouter?: string;
+  /** The seed of the small change of the graph for the stability measures (Z10 and G9). The default is 1. */
+  readonly seed?: number;
+  /** The route stability (Z10) routes a changed graph again, so the function measures it only up to this number of nodes. The default is 1000. */
+  readonly stabilityMax?: number;
+  /** The name of the graph in the rows. The default is `board`. */
+  readonly name?: string;
+}
+/** One strategy of one step on one graph: its measures and its output. */
+export interface CompareRow {
+  readonly step: CompareStep;
+  readonly strategy: string;
+  /** The violations of the hard rules, as `runSuite` counts them. A strategy with a violation does not enter the front. */
+  readonly violations: number;
+  /** The time of the step, in milliseconds. For the step `router`, it is the median of two routes. */
+  readonly ms: number;
+  /** The measures, by the keys of `runSuite`, and `ms`. The step `router` adds `ink`, and the step `curve` adds `C5.peak`. */
+  readonly values: Readonly<Record<string, number>>;
+  /** The reason when the strategy did not run, for example a graph over its `maxNodes`. */
+  readonly skipped?: string;
+  /** The result of the router, for the steps `router` and `group`. The step `group` routes with `sections` on the tree of the rule. */
+  readonly result?: Result;
+  /** The tree of the grouping rule, for the step `group`. */
+  readonly tree?: Section;
+  /** The segments of each curve, for the step `curve`, in the order of `edges`. */
+  readonly curves?: readonly CurveSegment[][];
+  /** The edge of each curve of `curves`. */
+  readonly edges?: readonly string[];
+}
+/** The comparison of the strategies of one step on one graph. */
+export interface StepComparison {
+  readonly step: CompareStep;
+  /** One row for each strategy of the step, in the order of the registry. */
+  readonly rows: readonly CompareRow[];
+  /** The axes of the Pareto front: `FRONT_OBJECTIVES` of the step. */
+  readonly objectives: readonly Objective[];
+  /** The strategies on the Pareto front, in the order of the registry. */
+  readonly front: readonly string[];
+  /** The strategies with a violation of a hard rule, or that did not run. They do not enter the front. */
+  readonly excluded: readonly string[];
+}
+/**
+ * This function runs each strategy of one step on one graph and measures it with the measures of `runSuite`. Then it gives the Pareto front.
+ * The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve.
+ * The step `group` routes the graph with `sections` on the tree of each grouping rule.
+ *
+ * The same graph and the same options give the same measures. Only the times change.
+ */
+export declare function compareStep(step: CompareStep, graph: Graph, options?: CompareOptions): StepComparison;
+export type { ArcOptions, ClothoidOptions, CornersOptions, CurveSpace, CutObjective, CutOptions, HighwayOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, LaneCurve, NodeKey, RoomBends, RoundedOptions, SectionsOptions, SharedOptions, SmoothOptions, SplineOptions, TrunksOptions };
 //# sourceMappingURL=index.d.ts.map