@mark1russell7/highways 0.2.0 → 0.4.0

package/build/index.d.ts

@@ -246,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.
@@ -253,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. */
@@ -314,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. */
@@ -369,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.
@@ -441,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. */
@@ -475,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. */
@@ -541,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. */
@@ -570,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. */
@@ -673,6 +847,19 @@ export declare function treeDepth(root: Section): number;
  * 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`.
@@ -700,6 +887,73 @@ export declare const byDataGroup: NodeKey;
 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. */
@@ -750,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;
 }
@@ -760,6 +1016,12 @@ 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;
+/** 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 {
   /**
@@ -769,6 +1031,88 @@ interface LevelLinkOptions extends WayOptions {
   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;
+}
+/** The input of a highway strategy: the boxes and the edges, and optionally the first routes of a router. */
+interface HighwayInput {
+  readonly graph: Graph;
+  /**
+   * These routes are the first routes, from a router. A strategy that reads first routes makes them itself when this value is absent.
+   * The strategy `corridors` makes the ways of the corner graph, as the router `corners` finds them.
+   */
+  readonly routes?: Result;
+}
+/**
+ * One edge of a highway. The edge joins the spine at the merge point and leaves it at the split point.
+ * A place on the spine is the index of a point of the spine plus the share of the next leg. Point `i` of the spine is at `i`.
+ * When `on` is larger than `off`, the edge goes along the spine from its last point to its first point.
+ */
+interface HighwayMember {
+  readonly edge: string;
+  /** The place of the merge point on the spine. */
+  readonly on: number;
+  /** The place of the split point on the spine. */
+  readonly off: number;
+  /** The point where the edge joins the spine. */
+  readonly merge: Point;
+  /** The point where the edge leaves the spine. */
+  readonly split: Point;
+  /**
+   * The place of this highway in the trip of the edge, from 0. An edge can go along several highways, one after the other.
+   * `follow` takes the highways of an edge in the order of this value.
+   */
+  readonly seq: number;
+}
+/** A highway: a shared way that a bundle of edges follows, from their merge points to their split points. */
+interface Highway {
+  readonly id: string;
+  /** The key of the highway, for example the key of the grouping rule or the index of a cluster. */
+  readonly key: string;
+  /** The spine: the polyline that the edges follow, in free space. */
+  readonly spine: readonly Point[];
+  /** The edges in lane order. Lane 0 is on the left of the spine, from its first point to its last point. The y axis points down. */
+  readonly lanes: readonly string[];
+  /** The edges with their merge points and their split points, in the order of `lanes`. */
+  readonly members: readonly HighwayMember[];
+}
+/** The output of a highway strategy: the highways, as data. `follow` routes the edges along them. */
+interface HighwayPlan {
+  readonly highways: readonly Highway[];
+}
+/** This function gives the point at a place on a polyline. A place outside the polyline gives its nearest end. */
+export declare function pointAt(line: readonly Point[], at: number): Point;
+/** This function gives the length of a polyline from the place `from` to the place `to`, with `from` not larger than `to`. */
+export declare function lengthBetween(line: readonly Point[], from: number, to: number): number;
+/** This function gives a member of a highway with its merge point and its split point at the places `on` and `off` of the spine. */
+export declare function memberAt(spine: readonly Point[], edge: string, on: number, off: number, seq?: number): HighwayMember;
+/**
+ * This function lists the problems of a plan against its graph. A good plan gives an empty list.
+ * Each highway has a spine of two points or more, and two members or more. Each member is an edge of the graph, with `on` and `off` on the spine and apart.
+ * An edge is a member of a highway one time at most.
+ */
+export declare function checkPlan(graph: Graph, plan: HighwayPlan): string[];
+/**
+ * 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.
+ */
+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;
 }
 /** 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 {
@@ -834,6 +1178,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> {
@@ -856,33 +1206,192 @@ 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 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 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 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.
+ * 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 lane of the polyline on its board, for a strategy that bends the lanes of a bundle as one. Then `points` is the route of `laneRoutes` with the index `index`.
+   * The other strategies do not read it.
+   */
+  readonly lane?: {
+    readonly board: LaneBoard;
+    readonly index: number;
+  };
+}
+/** The lanes of the bundles of one board: the input of `laneRoutes` and `highwayCurves`. */
+export interface LaneBoard {
+  /** The shared segments and the paths of the routes, from `segmentsOf`. */
+  readonly graph: SegmentGraph;
+  /** The keys of the open segments, from `runKey`. Each edge of an open segment gets its own lane. */
+  readonly open: ReadonlySet<string>;
+  /** The distance between two lanes of an open segment. */
+  readonly width: number;
+  /** The largest width of an open segment, from its outer lane to its outer lane. The default is `Infinity`. */
+  readonly maxWidth?: number;
+}
+/** 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.
+ * - `highway`: a graph and optionally its first routes in, a highway plan out. `follow` routes the edges along the plan.
+ * - `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: {
@@ -893,6 +1402,10 @@ export interface StepTypes {
     readonly input: Graph;
     readonly output: Result;
   };
+  readonly highway: {
+    readonly input: HighwayInput;
+    readonly output: HighwayPlan;
+  };
   readonly curve: {
     readonly input: CurveInput;
     readonly output: CurveSegment[];
@@ -923,6 +1436,8 @@ export interface Strategy<S extends Step = Step, O extends object = object> {
   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`. */
@@ -937,6 +1452,8 @@ export interface StrategyDefinition<S extends Step, O extends object> {
   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>;
@@ -949,10 +1466,11 @@ export declare function defineStrategy<S extends Step, O extends object>(definit
 /**
  * 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.
+ * The lists `group` and `highway` are optional in the type, so a registry from version 0.1.5 or 0.3.0 stays a registry. `createRegistry` always gives them.
  */
-export type Registry = { readonly [S in Exclude<Step, "group">]: readonly Strategy<S>[]; } & {
+export type Registry = { readonly [S in Exclude<Step, "group" | "highway">]: readonly Strategy<S>[]; } & {
   readonly group?: readonly Strategy<"group">[];
+  readonly highway?: readonly Strategy<"highway">[];
 };
 /** 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;
@@ -971,7 +1489,7 @@ 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` and `plugInset` are the limits of the level links (`levelLinks`).
+ * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
  */
 interface SectionsOptions extends LevelLinkOptions, SectionOptions {
   /** The name in the benchmark. */
@@ -1005,6 +1523,8 @@ interface SectionsOptions extends LevelLinkOptions, SectionOptions {
    * 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;
 }
@@ -1030,9 +1550,18 @@ interface TrunksOptions extends WayOptions {
   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;
 /**
@@ -1086,6 +1615,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";
@@ -1104,6 +1685,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. */
@@ -1160,6 +1747,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.
@@ -1212,6 +1806,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. */
@@ -1243,11 +1839,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[];
@@ -1256,15 +1867,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. */
+/**
+ * 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 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;
+/**
+ * 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 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;
 /**
  * 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 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 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`.
@@ -1306,6 +1941,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;
@@ -1367,6 +2123,74 @@ 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`. */
@@ -1420,6 +2244,605 @@ export declare function capSettings(values?: readonly number[]): SectionsSetting
 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>>;
+  /**
+   * With this board, each curve draws the lanes of `laneRoutes` in place of the routes of the result, and each input has its `lane`.
+   * So the curve `highway` bends the lanes of a bundle as one. Without it, each curve draws the routes of the result.
+   */
+  readonly lanes?: LaneBoard;
+}
+/** 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 the string `data.group` of the node.
+ * A node without it 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. Then the highway strategies come, and 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 the highway strategy `corridors` (HWY-031 of the note on highways).
+ * The options `margin` and `k` set the corner graph of the first ways, when the input has no first routes.
+ */
+interface CorridorOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two edges join when their common links are this share of the shorter way, or longer. The default is 0.3. */
+  readonly rho: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+  /** The number of hash functions of the MinHash signature of a way. The default is 64. */
+  readonly hashes: number;
+  /** The number of bands of the signature. Two ways with one equal band are a candidate pair. The default is 32. */
+  readonly bands: number;
+  /** Two link ends nearer than this grid size are one point. With 0, the default, only equal points are one point. */
+  readonly near: number;
+  /** The gap between two lanes. Two edges join only when their common links are longer than the break-even overlap for this gap. The default is 4. */
+  readonly lane: number;
+}
+/** The default options of the strategy `corridors`. */
+export declare const CORRIDOR_DEFAULTS: Readonly<Required<Omit<CorridorOptions, "margin" | "k">>>;
+/**
+ * The break-even overlap of two parallel edges for each unit of the lane gap, with the cost exponent 0.5 of the note.
+ * A shared stretch shorter than this times the gap adds ink.
+ */
+export declare const BREAK_EVEN: number;
+/** This function gives the MinHash signature of a set of keys with `count` hash functions. */
+export declare function minHash(keys: Iterable<string>, count: number): number[];
+/**
+ * This function gives the highways of corridor signatures (HWY-031). Each edge gets a first way: the route of `input.routes`, or its way through the corner graph.
+ * The signature of a way is the set of its links. Two edges join when their common links are at least `rho` times the shorter way, and longer than the break-even overlap.
+ * MinHash with `hashes` hash functions in `bands` bands finds the candidate pairs fast. Union-find gives the clusters.
+ *
+ * In each cluster, the spine is the longest common run of links of the way with the most shared length. Each edge on the spine joins it at its first common link and leaves it at its last one.
+ * The edges of the cluster that are not on the spine make the next highway, while `minSize` of them remain.
+ */
+export declare function corridorPlan(input: HighwayInput, o: Readonly<CorridorOptions>): HighwayPlan;
+/** The options of the highway strategy `keys`: the options of the router `trunks`, without the name and the limit of the benchmark. */
+type KeysOptions = Omit<TrunksOptions, "name" | "maxNodes">;
+/**
+ * This function gives the highways that the router `trunks` decides. A rule gives each edge a key.
+ * The edges from one plug with one key share a trunk to a split point. The edges that go on together share a run past it.
+ * Each trunk and each run becomes one highway. The function does not change the router: it reads its bundles and its runs.
+ */
+export declare function keysPlan(input: HighwayInput, options: KeysOptions): HighwayPlan;
+/** The options of the highway strategy `shared-ways`: the options of the router `shared`, without the name and the limit of the benchmark. */
+type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
+/**
+ * This function gives the highways that the router `shared` decides. The edges of one key go one by one through the corner graph.
+ * A link that the key uses already costs less, so the ways of a key come together. Each stretch that two edges or more share becomes one highway.
+ * The function does not change the router: it reads its runs.
+ */
+export declare function sharedWaysPlan(input: HighwayInput, options: SharedWaysOptions): HighwayPlan;
 /** 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`. */
@@ -1444,28 +2867,672 @@ 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`. The options `minRadius`, `jog` and `jogPieces` change only the lanes of a bundle.
+ * So they change the curve only when the input has a `lane` on a board with open segments.
+ */
+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. For a polyline with a `lane`, it bends the lanes of each bundle as one with `highwayCurves`.
+ */
 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 highway strategies: the decisions of the routers `trunks` and `shared` as plans, and corridor signatures (HWY-031).
+ * `follow` routes the edges along a plan, and `highwayRouter` gives a router that does both.
+ */
+export declare const highwayStrategies: {
+  readonly keys: Strategy<"highway", KeysOptions>;
+  readonly "shared-ways": Strategy<"highway", SharedWaysOptions>;
+  readonly corridors: Strategy<"highway", CorridorOptions>;
 };
 /** 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, KeyOptions, NodeKey, 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.
+ * The step `highway` gives a plan, not routes. The screen routes each plan with `follow` and compares it as a router.
+ */
+export type CompareStep = Exclude<Step, "room" | "highway">;
+/** 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;
+  /**
+   * With this value, the step `curve` opens each shared segment of the routes of `curveRouter`, and each curve draws the lanes of `laneRoutes`.
+   * So the curve `highway` bends the lanes of a bundle as one. Without it, each curve draws the routes. A router without shared segments gives the routes in both cases.
+   */
+  readonly lanes?: {
+    readonly width: number;
+    readonly maxWidth?: number;
+  };
+  /** 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`.
+   * A router with zoom levels also gets `Z3.through` and `Z3.length`, the measures of its level links.
+   */
+  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, or their lanes with the option `lanes`.
+ * 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;
+/** This function gives the bytes of a string in UTF-8. */
+export declare function utf8(text: string): Uint8Array;
+/** This function gives the SHA-256 digest of a string, as 64 lowercase hex characters. It encodes the string in UTF-8. */
+export declare function sha256Hex(text: string): string;
+/**
+ * This function writes a value as canonical JSON: the keys of each object in sorted order, and no whitespace.
+ * It drops a key whose value is `undefined`, as `JSON.stringify` does.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * This function gives the hash of a JSON document: the first 16 hex characters of the SHA-256 of its canonical JSON.
+ * The document does not include its own field `hash`. The function removes that field before it calculates the hash.
+ */
+export declare function documentHash(value: object): string;
+/** This function gives the 32-bit FNV-1a hash of the UTF-8 bytes of a text, as an unsigned integer. */
+export declare function fnv1a32(text: string): number;
+/** This function gives the seed of one step of a generator: `fnv1a32("<seed>:<step>")`. */
+export declare function stepSeed(seed: number, step: string): number;
+/** This function gives the generator `mulberry32` for a seed. Each call gives the next number from 0 to below 1. */
+export declare function mulberry32(seed: number): () => number;
+/** This function rounds a number to 3 decimals, as the files of a corpus keep it. The value `-0` becomes `0`. */
+export declare function round3(value: number): number;
+/** The side of a port in an input file. The router calls the same sides `north`, `east`, `south` and `west`. */
+export type LayoutSide = "top" | "right" | "bottom" | "left";
+/** A port of a box in an input file. */
+export interface LayoutPort {
+  readonly id: string;
+  /** The side of the box. Without it and without `x` and `y`, the router picks the side. */
+  readonly side?: LayoutSide;
+  /** The fixed place of the port, from the top-left corner of the box. The router does not move a port with `x` and `y`. */
+  readonly x?: number;
+  readonly y?: number;
+}
+/** A point of a region: `[x, y]`. The y axis points down. */
+export type RegionPoint = readonly [number, number];
+/**
+ * An area of the plane. The y axis points down. A ring of a polygon closes itself: its last point joins its first point.
+ * A hole of a polygon does not touch the outer ring. The router reads only the bounding box of a region.
+ */
+export type Region = {
+  readonly kind: "rect";
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+} | {
+  readonly kind: "polygon";
+  readonly points: readonly RegionPoint[];
+  readonly holes?: readonly (readonly RegionPoint[])[];
+} | {
+  readonly kind: "circle";
+  readonly cx: number;
+  readonly cy: number;
+  readonly r: number;
+} | {
+  readonly kind: "ellipse";
+  readonly cx: number;
+  readonly cy: number;
+  readonly rx: number;
+  readonly ry: number;
+};
+/** An area that the boxes and the routes must not use. The router uses the bounding box of its region as a box without edges. */
+export interface LayoutObstacle {
+  readonly id: string;
+  readonly region: Region;
+  /** The cost to move the obstacle. Only the packer reads it. */
+  readonly move?: {
+    readonly cost: number;
+  };
+}
+/** A box of an input file. */
+export interface LayoutBox {
+  readonly id: string;
+  readonly w: number;
+  readonly h: number;
+  /** The position of the top-left corner. The packer writes it. The router reads it. */
+  readonly x?: number;
+  readonly y?: number;
+  /** The id of the box that holds this box. */
+  readonly parent?: string;
+  /** The group of the box. */
+  readonly group?: string;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
+  readonly locked?: true;
+  /** The reading order that the caller wants. The router ignores it. */
+  readonly rank?: number;
+  readonly ports?: readonly LayoutPort[];
+  /** The shape of the box, relative to the top-left corner of the box. The router ignores it and uses `w` and `h` as the bounding box. */
+  readonly shape?: Region;
+  /** The free data of the node. The grouping rule `keys` reads `data.group`. */
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+/** An edge of an input file. `sourcePort` and `targetPort` name a port of the box at that end. */
+export interface LayoutEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+  readonly sourcePort?: string;
+  readonly targetPort?: string;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+/** The change of a variant against its base input. */
+export type LayoutChange = "add" | "remove" | "resize" | "reorder" | "packed";
+/** The origin of an input: `made-up`, `published:<set>` or `known-best:<construction>`. */
+export type LayoutSource = "made-up" | `published:${string}` | `known-best:${string}`;
+/** The generator of an input. The same name, version, parameters and seed give the same file, byte for byte. */
+export interface LayoutGenerator {
+  readonly name: string;
+  readonly version: number;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly seed: number;
+}
+/**
+ * The cell of an input in the taxonomy of the corpus, with one value for each dimension.
+ * The packer reads the first six dimensions. The router reads the last four.
+ */
+export interface LayoutCell {
+  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
+  readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
+  readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
+  readonly count?: "1" | "10" | "100" | "1k" | "10k";
+  readonly mode?: "offline" | "online" | "incremental";
+  readonly edgeDensity?: "sparse" | "medium" | "dense";
+  readonly edgeShape?: "random" | "clustered" | "hubChain" | "longRange" | "tree" | "bundled";
+  readonly groups?: "none" | "flat" | "nested";
+  readonly ports?: "free" | "sides" | "fixed";
+}
+/** The outer rectangle of a packing. The router ignores it. */
+export interface LayoutContainer {
+  readonly w?: number;
+  readonly h?: number;
+  /** `none`: the packer picks the size. `width`: the width stays. `height`: the height stays. `size`: the width and the height stay. */
+  readonly fixed: "none" | "width" | "height" | "size";
+  /** The ratio `w / h` that the packer aims for. */
+  readonly aspect?: number;
+  /** The shape of the container. */
+  readonly shape?: Region;
+}
+/** The identity of an input in a set: the set, the family, the seed, and the base of a variant. */
+export interface LayoutInputHead {
+  /** The id: `<set>/<family>/s<seed>`. */
+  readonly id: string;
+  readonly set: string;
+  readonly family: string;
+  readonly seed: number;
+  /** The id of the base input of a variant. The stability measures compare the run on the variant with the run on its base. */
+  readonly base?: string;
+  readonly change?: LayoutChange;
+  /** The place of the input in a change sequence. */
+  readonly step?: number;
+  /** The generator of the input. The default is `null`: a hand-made input. */
+  readonly generator?: LayoutGenerator | null;
+  /** The origin of the input. The default is `made-up`. */
+  readonly source?: LayoutSource;
+  readonly cell?: LayoutCell;
+}
+/**
+ * An input file of the form `layout-input/1`. The packer and the router read the same files.
+ * The file `docs/LAYOUT-RECORDS.md` gives the form. The repository `packing` keeps a twin of that document.
+ */
+export interface LayoutInput extends LayoutInputHead {
+  readonly schema: "layout-input/1";
+  /** The origin of the input. The data of this repository is made-up, because the repository is public. */
+  readonly source: LayoutSource;
+  /** The generator of the input, or `null` for a hand-made input. */
+  readonly generator: LayoutGenerator | null;
+  /** The first 16 hex characters of the SHA-256 of the canonical file without this field. `documentHash` calculates it. */
+  readonly hash: string;
+  readonly container?: LayoutContainer;
+  /** The space between two boxes. The router ignores it. */
+  readonly gap?: number;
+  /** The areas that the boxes and the routes must not use. */
+  readonly obstacles?: readonly LayoutObstacle[];
+  readonly boxes: readonly LayoutBox[];
+  readonly edges: readonly LayoutEdge[];
+}
+/** One run of one strategy on one input and one seed: a line of the form `layout-record/1`. */
+export interface LayoutRecord {
+  readonly schema: "layout-record/1";
+  /** `pack`, `route` or `joint`. The screen of this package writes `route`. */
+  readonly stage: "pack" | "route" | "joint";
+  readonly step: string;
+  readonly strategy: string;
+  /** The options of the run: the defaults of the strategy with the options of the caller. A function is the text `function:<name>`. */
+  readonly options: Readonly<Record<string, unknown>>;
+  /** The corpus version, for example `screen-v1`. */
+  readonly corpus: string;
+  /** The id of the input. */
+  readonly input: string;
+  /** The `hash` of the input file. */
+  readonly inputHash: string;
+  readonly set: string;
+  readonly seed: number;
+  readonly nodes: number;
+  readonly edges: number;
+  /** The measures, by the names of `MEASURES`. A measure without a finite value is not in the record. */
+  readonly measures: Readonly<Record<string, number>>;
+  /** The count of the breaks of each hard rule. A good run has 0 for each rule. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The tolerance of each hard rule of the run, for example `{ through: 0.5 }`. */
+  readonly tolerance?: Readonly<Record<string, number>>;
+  /** This value is `true` when two runs on the same input give the same output. */
+  readonly deterministic: boolean;
+  /** The id of the prediction of this run, from the predictions file. */
+  readonly prediction?: string;
+  /** The time of the run, in milliseconds. Only the times of CI compare. */
+  readonly ms: number;
+  /** The commit of the code that made the record. */
+  readonly commit?: string;
+  /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */
+  readonly skipped?: string;
+}
+/** The comparison of a prediction. Without it, `<=` applies to a measure where lower is better, and `>=` to the other measures. */
+export type PredictionOp = "<" | "<=" | "=" | ">=" | ">";
+/** A prediction about a run: one line of a predictions file. A commit adds the file before the run starts. */
+export interface LayoutPrediction {
+  readonly schema?: "layout-prediction/1";
+  readonly id: string;
+  readonly strategy: string;
+  readonly set: string;
+  /** The id of one input. Without it, the prediction is about the median of the measure over the set. */
+  readonly input?: string;
+  /** The name of the measure, from `MEASURES`. */
+  readonly measure: string;
+  readonly expected: number;
+  readonly op?: PredictionOp;
+  readonly reason: string;
+}
+/**
+ * This function writes a graph as an input file of the form `layout-input/1`, with its hash.
+ * A fixed plug gets `x`, `y` and the side that holds it. `inputGraph` reads the file back.
+ */
+export declare function graphInput(graph: Graph, head: LayoutInputHead): LayoutInput;
+/**
+ * This function gives the bounding box of a region: the smallest box that holds it.
+ */
+export declare function regionBounds(region: Region): {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+};
+/**
+ * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
+ * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
+ * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
+ * A box without `x` and `y` is an error.
+ */
+export declare function inputGraph(input: LayoutInput): Graph;
+/**
+ * This function writes an input file as text: the keys in sorted order, and one box or one edge on each line.
+ * `JSON.parse` of the text gives the input again.
+ */
+export declare function formatInput(input: LayoutInput): string;
+/** This function writes records as JSON Lines: one record on each line. */
+export declare function recordLines(records: readonly LayoutRecord[]): string;
+/** This function reads JSON Lines. It ignores an empty line. */
+export declare function parseLines<T>(text: string): T[];
+/**
+ * This function gives a copy of a value that JSON keeps.
+ * A function becomes the text `function:<name>`, and a number that is not finite becomes its text.
+ */
+export declare function jsonSafe(value: unknown): unknown;
+/**
+ * One measure of a record. `key` is the key of the measure in the values of `runSuite` and `compareStep`.
+ * `name` is the name of the measure in a record of the form `layout-record/1`.
+ */
+export interface MeasureInfo {
+  /** The key in the values of `runSuite` and `compareStep`, for example `R5.median`. */
+  readonly key: string;
+  /** The id of the measure in `docs/research/MEASURES.md` (MEAS0), for example `R5`. */
+  readonly id: string;
+  /** The name in a record: lowercase, with a dot after the stage, for example `route.detour.median`. */
+  readonly name: string;
+  readonly unit: string;
+  readonly better: "lower" | "higher";
+  /**
+   * This value is `true` when the positions of the boxes alone can move the value, with the same router.
+   * Then two values compare only on the same input. The value is `false` when the measure scores the routes or the curves for a fixed placement.
+   */
+  readonly placementDependent: boolean;
+}
+/**
+ * The measures of the records of the stage `route`, with the placement dependence of each one.
+ * A joint harness that moves the boxes and routes the edges reads `placementDependent`.
+ * It compares a measure with the value `true` only between runs on the same input.
+ */
+export declare const MEASURES: readonly MeasureInfo[];
+/** This function gives the measure of a key of `runSuite` or `compareStep`, or `undefined` for a key that is not in `MEASURES`. */
+export declare function measureByKey(key: string): MeasureInfo | undefined;
+/** This function gives the measure of a name of a record, or `undefined` for a name that is not in `MEASURES`. */
+export declare function measureByName(name: string): MeasureInfo | undefined;
+/** This function gives the name of a key in a record. A key that is not in `MEASURES` gets the name `route.other.<key>`. */
+export declare function measureName(key: string): string;
+/** This function gives the objectives of a Pareto front by the names of a record, from objectives by the keys of `runSuite`. */
+export declare function namedObjectives(objectives: readonly Objective[]): Objective[];
+/** A family of boards of a screen set. The member `k` of the family has the seed `k`. */
+export interface ScreenFamily {
+  readonly name: string;
+  /** The known hard case that the family shows, in a few words. */
+  readonly shows: string;
+  /** The number of members. */
+  readonly seeds: number;
+  /** This function makes the member `k`. The same `k` always gives the same graph. */
+  readonly make: (k: number) => Graph;
+  /** This function gives the generator of the member `k`: its name, version, parameters and seed. */
+  readonly generator: (k: number) => LayoutGenerator;
+  /** The cell of each member in the taxonomy of the corpus. */
+  readonly cell: LayoutCell;
+}
+/** A screen set: a fixed list of small boards with an id. A new board or a changed board gets a new id. */
+export interface ScreenSet {
+  /** The id of the set, for example `screen-v1`. The records name it in `set` and `corpus`. */
+  readonly id: string;
+  readonly families: readonly ScreenFamily[];
+}
+/**
+ * The screen set `screen-v1`: 14 boards of made-up data from 10 to 150 nodes. Each family shows a known hard case.
+ * The seed 0 of each family is the fixture or the case board of the benchmark. The seed `k` of a fixture family is `familySeed(spec, k)`, as in `runSuite`.
+ * The generators wrap the fixtures and the case boards without a change to their output.
+ * This set does not change. The tests compare it with the files in `corpus/screen-v1`.
+ */
+export declare const SCREEN_V1: ScreenSet;
+/** The screen sets by id. */
+export declare const SCREEN_SETS: Readonly<Record<string, ScreenSet>>;
+/** This function gives the id of the member `seed` of a family of a set: `<set>/<family>/s<seed>`. */
+export declare function inputId(set: string, family: string, seed: number): string;
+/** This function gives the input files of a screen set, in the order of its families and seeds. Each file has its hash. */
+export declare function screenInputs(set?: ScreenSet): LayoutInput[];
+/** A spec of a manifest: one generator with its version and parameters, and the seeds that the corpus uses. */
+export interface CorpusSpec {
+  readonly generator: string;
+  readonly version: number;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly seeds: readonly number[];
+}
+/** The manifest `corpus.json` of a corpus, of the form `layout-corpus/1`. */
+export interface LayoutCorpus {
+  readonly schema: "layout-corpus/1";
+  readonly corpus: string;
+  readonly specs: readonly CorpusSpec[];
+  readonly inputs: readonly {
+    readonly id: string;
+    readonly hash: string;
+    readonly cell: LayoutCell;
+  }[];
+}
+/** This function gives the manifest of a list of inputs. The inputs of one generator, version and parameters share one spec. */
+export declare function corpusManifest(corpus: string, inputs: readonly LayoutInput[]): LayoutCorpus;
+/**
+ * The steps of the screen: the steps of `compareStep` and the step `highway`.
+ * The screen of the step `highway` routes the plan of each strategy with `follow`, and measures the routes as the routes of a router.
+ */
+export type ScreenStep = CompareStep | "highway";
+/** The steps of the screen, in the order of the pipeline. */
+export declare const SCREEN_STEPS: readonly ScreenStep[];
+/** The routers that the screen of the step `highway` also runs by default. They are the baselines of the note on highways. */
+export declare const HIGHWAY_BASE_ROUTERS: readonly string[];
+/** The hard rules of each step of the screen, in the order of the records. A good run has 0 for each rule. */
+export declare const SCREEN_RULES: Readonly<Record<ScreenStep, readonly string[]>>;
+/** The options of `screen`. */
+export interface ScreenOptions {
+  /** The screen set. The default is `SCREEN_V1`. */
+  readonly set?: ScreenSet;
+  /** The input files. The default is the files of `set`. */
+  readonly inputs?: readonly LayoutInput[];
+  /** The families of the inputs that the screen runs. The default is each family. */
+  readonly families?: readonly string[];
+  /**
+   * With `true`, the screen also runs each built-in strategy of the step, and the front compares the new strategies with them.
+   * With `false`, it runs only the strategies of the call. The default is `true`.
+   */
+  readonly baseline?: boolean;
+  /** The options of each strategy, 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`. */
+  readonly curveRouter?: string;
+  /**
+   * The routers that the screen of the step `highway` also runs. Their records have the step `router`.
+   * The default is `HIGHWAY_BASE_ROUTERS`. The other steps do not read it.
+   */
+  readonly baseRouters?: readonly string[];
+  /** The seed of the small change of the stability measures. The default is 1. */
+  readonly seed?: number;
+  /** The commit of the code, for the records. */
+  readonly commit?: string;
+  /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
+  readonly predictions?: readonly LayoutPrediction[];
+  /** This function gets one line of progress for each input. */
+  readonly log?: (line: string) => void;
+}
+/** The summary of one strategy over the inputs of a screen. */
+export interface ScreenStrategySummary {
+  readonly strategy: string;
+  /** This value is `true` for a strategy of the call, and `false` for a built-in strategy of the baseline. */
+  readonly candidate: boolean;
+  /** The number of inputs where the strategy ran. */
+  readonly runs: number;
+  /** The number of inputs that the strategy skipped. */
+  readonly skipped: number;
+  /** This value is `true` when each run gave the same output two times. */
+  readonly deterministic: boolean;
+  /** The sum of the breaks of each hard rule over the runs. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The sum of `hard`. */
+  readonly hardTotal: number;
+  /**
+   * The breaks over the floor of each input. The floor is the counts of the built-in strategy with the fewest breaks on that input.
+   * Each built-in breaks a rule on some boards, for example on a board where the boxes touch. Without built-ins, the floor is 0.
+   */
+  readonly hardOverFloor: number;
+  /** The median of each measure over the runs, by the names of a record. */
+  readonly medians: Readonly<Record<string, number>>;
+  /** The median time of a run, in milliseconds. */
+  readonly ms: number;
+  /** The number of inputs where the strategy is on the Pareto front of its input. */
+  readonly onFront: number;
+}
+/** A prediction with the measured value. */
+export interface PredictionCheck extends LayoutPrediction {
+  readonly op: PredictionOp;
+  /** The measured value: the value of the record of the input, or the median over the set. It is absent when no record has the measure. */
+  readonly measured?: number;
+  /** This value is `true` when the measured value meets the prediction. It is absent when there is no measured value. */
+  readonly met?: boolean;
+}
+/** The summary of a screen. */
+export interface ScreenSummary {
+  readonly set: string;
+  readonly step: ScreenStep;
+  /** The number of inputs. */
+  readonly inputs: number;
+  /** The axes of the Pareto front, by the names of a record. */
+  readonly objectives: readonly Objective[];
+  /** One summary for each strategy, in the order of the registry. */
+  readonly strategies: readonly ScreenStrategySummary[];
+  /** The strategies on the Pareto front of the medians over the set. */
+  readonly front: readonly string[];
+  /** The strategies with a break over the floor, without a run or with two different outputs of one input. They do not enter the front. */
+  readonly excluded: readonly string[];
+  readonly predictions: readonly PredictionCheck[];
+}
+/** The result of `screen`: one record for each strategy and input, and the summary. */
+export interface ScreenReport {
+  readonly records: readonly LayoutRecord[];
+  readonly summary: ScreenSummary;
+}
+/**
+ * This function screens strategies of one step on the inputs of a screen set. It is the cheap test of a new idea before a full build.
+ * Each strategy runs on each input with `compareStep`, and each run gives one record of the form `layout-record/1`.
+ * A strategy can be a name of the registry or a strategy object, for example from a prototype file. The registry does not change.
+ *
+ * The step `router` routes each input two times for the rule "same twice". The steps `group` and `curve` run each input two times for the same rule.
+ *
+ * The step `highway` makes the plan of each strategy and routes it with `follow`, two times. It also runs the routers of `baseRouters`.
+ * An input with a `base` in the inputs also gets the measures `route.stability.base.*`: the routes on the variant against the routes on its base.
+ * The same inputs and the same options give the same records. Only the times change.
+ */
+export declare function screen(step: ScreenStep, strategies?: readonly (Strategy<ScreenStep> | string)[], options?: ScreenOptions): ScreenReport;
+/** This function writes the summary of a screen as Markdown: one row for each strategy, the front and the predictions. */
+export declare function formatScreen(summary: ScreenSummary): string;
+/** This function gives a whole number from `lo` to `hi`, both included, from a generator of random numbers. */
+export declare function randomInt(r: () => number, lo: number, hi: number): number;
+/** The parameters of the generator `rect-scattered`. */
+export interface RectScatteredParams {
+  /** The number of boxes. */
+  readonly count: number;
+}
+/**
+ * This function makes the input of the shared generator `rect-scattered`, version 1: a fixed rectangle container, scattered obstacles and boxes without positions.
+ * The repository `packing` makes the same file, byte for byte. A test in each repository pins the hashes of the seeds 1, 2 and 3.
+ * The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
+ */
+export declare function rectScattered(seed: number, params: RectScatteredParams, set?: string): LayoutInput;
+/** The options of `follow`. */
+interface FollowOptions extends WayOptions {
+  /**
+   * These routes are the routes of the base router. Each edge outside the plan keeps its route from them.
+   * Without them, or for an edge without a route in them, `follow` routes the edge as the router `corners` does.
+   */
+  readonly routes?: Result;
+  /** The lane order of the shared runs. The default is `bundle`. */
+  readonly laneOrder?: RunOrder;
+}
+/**
+ * This function routes the edges along a highway plan.
+ *
+ * An edge of a highway goes from its source plug to its merge point. Then it goes along the spine to its split point, and to its target plug.
+ * The ramps go around the boxes through the corner graph (`WayFinder.fromPlug` and `WayFinder.toPlug`).
+ * A spine point on the box of the node is the plug itself. When the end has a fixed plug, the point is at that plug.
+ *
+ * An edge on several highways takes them in the order of `seq`.
+ * A way through the corner graph goes from each split point to the next merge point.
+ * An edge outside the plan keeps its route from `options.routes`, or goes as in the router `corners`.
+ *
+ * The result has a shared run for each stretch of a spine where the same two edges or more go. Each run holds the points of its routes in a row.
+ * The same graph, plan and options give the same result.
+ */
+export declare function follow(graph: Graph, plan: HighwayPlan, options?: FollowOptions): Result;
+/**
+ * This function gives the highways of a result of a router: one highway for each shared run and for each trunk of a bundle.
+ * The spine is the points of the run or of the trunk. Each edge of the run is a member, from one end of the spine to the other end, in the way of its route.
+ * The member `seq` is the place of the shared stretch in the route of the edge. The lanes keep the lane order of the router.
+ *
+ * Thus `follow` routes each edge along the shared stretches of the router. A route that does not hold its run is not a member.
+ */
+export declare function planOfResult(result: Result): HighwayPlan;
+/**
+ * This function gives a router that runs a highway strategy and then `follow`. The strategy gets the graph without first routes.
+ * The way finder of `follow` takes `margin` and `k` from the options of the strategy, and then from `followOptions`.
+ * The router keeps the name and the `maxNodes` of the strategy.
+ */
+export declare function highwayRouter<O extends object>(strategy: Strategy<"highway", O>, options?: Partial<O>, followOptions?: FollowOptions): Router;
+/**
+ * This function gives a router strategy that runs a highway strategy and then `follow`.
+ * The router strategy has the name, the options and the schema of the highway strategy.
+ * The benchmark and the screen race such a router with the other routers.
+ */
+export declare function highwayRouterStrategy<O extends object>(strategy: Strategy<"highway", O>): Strategy<"router", O>;
+export type { ArcOptions, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, FollowOptions, Highway, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeysOptions, LaneCurve, NodeKey, RoomBends, RoundedOptions, SectionsOptions, SharedOptions, SharedWaysOptions, SmoothOptions, SplineOptions, TrunksOptions };
 //# sourceMappingURL=index.d.ts.map