@mark1russell7/highways 0.8.1 → 0.9.1

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { ExerciseEvidence, HashOptions, MeasureSpec, Member, MemberStatus, MemberTrace, OutputGroup, PickSpec, Portfolio, PortfolioKey, PortfolioLevel, PortfolioOptions, PortfolioPick, PortfolioTrace, RECORD_EPS, SelectCandidate, SelectLevel, Selection, Verdict, canonicalJson, compareMeasure, exercised, minEffectOf, outputGroups, outputHash, pickMoves, portfolio, selectBest, sha256Hex } from "@mark1russell7/layout-contract";
+import { ClaimBreak, CorpusDimension, CorpusDimension as CorpusDimension$1, CorpusFamily, CorpusFamily as CorpusFamily$1, CorpusSplit, DEFAULT_RNG, DeclaredClaim, DimensionValues, DimensionValues as DimensionValues$1, ExerciseEvidence, FamilyBy, FamilyCell, FamilyRegistry, FamilyRegistry as FamilyRegistry$1, GenerateContext, HashOptions, MeasureSpec, Member, MemberStatus, MemberTrace, OutputGroup, ParamValue, ParamValue as ParamValue$1, PickSpec, Portfolio, PortfolioKey, PortfolioLevel, PortfolioOptions, PortfolioPick, PortfolioTrace, RECORD_EPS, SelectCandidate, SelectLevel, Selection, Verdict, canonicalJson, compareMeasure, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex } from "@mark1russell7/layout-contract";
 /** A point in the plane. */
 export interface Point {
   readonly x: number;
@@ -83,7 +83,8 @@ export declare function segmentBounds(a: Point, b: Point): Box;
 export type Side = "north" | "east" | "south" | "west";
 /**
  * A plug of a node: a place where edges go into the node.
- * A plug with `at` is fixed. The router does not move it. A plug without `at` is free: the router places it.
+ * A plug with `at` is fixed. The router does not move it. A plug with `side` and `along` is fixed too.
+ * Another plug is free: the router places it.
  */
 export interface Port {
   readonly id: string;
@@ -91,6 +92,12 @@ export interface Port {
   readonly at?: Point;
   /** This side is where a free plug goes. Without it, the router picks the side. */
   readonly side?: Side;
+  /**
+   * This fraction from 0 to 1 fixes the plug on its `side`. The plug is at the side start plus `along` times the side length.
+   * The start of `north` and `south` is the left end. The start of `east` and `west` is the top end.
+   * A plug with `along` needs a `side` and has no `at`. `resolvePorts` throws a `RangeError` for a bad value.
+   */
+  readonly along?: number;
 }
 /** A node: a box that routes must not go through. */
 export interface Node {
@@ -190,7 +197,20 @@ export interface Router {
 }
 /** This function gives a map from the id of each node to the node. */
 export declare function nodeIndex(g: Graph): Map<string, Node>;
-/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+/**
+ * This function gives the place of a fixed plug, relative to the top-left corner of the node box, or `undefined` for a free plug.
+ * A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
+ */
+export declare function portOffset(box: Box, port: Port): Point | undefined;
+/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+export declare function checkPort(node: Node, port: Port): void;
+/**
+ * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
+ * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
+ * It throws a `RangeError` for a bad `along` (`checkPort`).
+ */
+export declare function resolvePorts(graph: Graph): Graph;
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
 export declare function fixedPortPoint(node: Node, end: End): Point | undefined;
 /** This function gives a seeded random source with values in [0, 1) (mulberry32). */
 export declare function rng(seed: number): () => number;
@@ -214,11 +234,14 @@ export interface FixtureSpec {
 }
 /** The fixtures of the benchmark, from 10 to 100 000 nodes. */
 export declare const FIXTURES: readonly FixtureSpec[];
+/** This function gives the seed of the random numbers of a fixture: `(seed × 2654435761 + nodes) >>> 0`. */
+export declare function fixtureRngSeed(seed: number, nodes: number): number;
 /**
  * This function makes the graph of a fixture. The same spec always gives the same graph.
  * Node boxes do not overlap, and a gap of 12 units stays between them.
+ * The default source of random numbers is `rng(fixtureRngSeed(spec.seed, spec.nodes))`. A corpus family gives the same stream from its registry.
  */
-export declare function makeFixture(spec: FixtureSpec): Graph;
+export declare function makeFixture(spec: FixtureSpec, random?: () => number): Graph;
 /**
  * A board of made-up data that shows one known defect of the routes or of the zoom levels.
  * The benchmark races the routers on each case, and the measures of `measureLinks` give a number for the defect.
@@ -230,23 +253,60 @@ export interface CaseBoard {
   /** This function makes the graph. The same function always gives the same graph. */
   readonly make: () => Graph;
 }
+/** The options of a case board with a seed: `hubChainBoard` and `manyGroupsBoard`. */
+export interface CaseSeedOptions {
+  /** The seed of the random links of the board. Each board has its own default. */
+  readonly seed?: number;
+}
 /**
  * This function makes a dense board: 150 nodes in tight clusters. At the far view, the boxes of the groups overlap.
  * Then a level link starts or ends in a group that another group covers.
  */
 export declare function denseGroupsBoard(): Graph;
+/** The options of `hubChainBoard`. Each option at its default keeps the board of today. */
+export interface HubChainOptions extends CaseSeedOptions {
+  /** The number of rows of cards. The default is 3. */
+  readonly rows?: number;
+  /** The number of cards in each row. The default is 32. */
+  readonly cols?: number;
+  /** The number of tries for a long link. The default is 40. */
+  readonly long?: number;
+  /** The free space between two cards, in units. The default is 48. */
+  readonly gap?: number;
+}
 /**
  * This function makes a board of three rows of 32 cards. Each card links to the next card of its row.
  * Forty long links join cards far apart. The hub of a section is near the middle of its cards.
  * So a long link climbs to hubs behind its source or past its target, and comes back.
- */
-export declare function hubChainBoard(): Graph;
+ *
+ * The seed changes only the long links. The rows of cards, and thus the chain of hubs, do not change.
+ * The default seed is 3. Without options, the board does not change.
+ * The default source of random numbers is `rng(seed)`. A corpus family gives the same stream from its registry.
+ */
+export declare function hubChainBoard(options?: HubChainOptions, random?: () => number): Graph;
+/** The options of `manyGroupsBoard`. Each option at its default keeps the board of today. */
+export interface ManyGroupsOptions extends CaseSeedOptions {
+  /** The number of columns of groups. The default is 8. */
+  readonly groupCols?: number;
+  /** The number of rows of groups. The default is 4. */
+  readonly groupRows?: number;
+  /** The number of cards in each group. The default is 4. */
+  readonly perGroup?: number;
+  /** The number of random links between groups, for each group. The default is 3. */
+  readonly crossLinksPerGroup?: number;
+  /** The free space between two groups, in units. The default is 60. */
+  readonly groupGap?: number;
+}
 /**
  * This function makes a board of 32 groups in 8 columns and 4 rows. Each group has 4 cards in a square.
  * The cards of a group link in a chain, and 96 random links join cards of two groups.
  * On a level with many groups, some level links go around the outer edge of the board.
+ *
+ * The seed changes only the 96 links between groups. The 32 groups and their chains do not change.
+ * The default seed is 7. Without options, the board does not change.
+ * The default source of random numbers is `rng(seed)`. A corpus family gives the same stream from its registry.
  */
-export declare function manyGroupsBoard(): Graph;
+export declare function manyGroupsBoard(options?: ManyGroupsOptions, random?: () => number): Graph;
 /** The options of `packedGridBoard`. */
 export interface PackedGridOptions {
   /** The seed of the links. The default is 11. */
@@ -257,6 +317,8 @@ export interface PackedGridOptions {
   readonly rows?: number;
   /** The number of long links between boxes far apart. The default is 48. */
   readonly long?: number;
+  /** The largest step, in rows and in columns, of the link of a box to a box near it. The default is 2. */
+  readonly reach?: number;
 }
 /**
  * This function makes the far view of a board after a host layout packs it.
@@ -266,8 +328,9 @@ export interface PackedGridOptions {
  *
  * 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.
+ * The default source of random numbers is `rng(seed)`. A corpus family gives the same stream from its registry.
  */
-export declare function packedGridBoard(options?: PackedGridOptions): Graph;
+export declare function packedGridBoard(options?: PackedGridOptions, random?: () => number): 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.
@@ -1004,112 +1067,6 @@ export declare const straightRouter: Router;
  * It goes to the target plug on the curve of the rule. This router measures the rule alone.
  */
 export declare const plugsRouter: Router;
-/** The ways to place a free plug of the corner router. */
-type PlugPlace = "facing" | "side";
-/** The options of the corner router. */
-interface CornersOptions extends WayOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
-  /**
-   * The place of a free plug. The default is `facing`: the plug faces the other end (`placePlug`).
-   * With `side`, the search starts from the whole free side, and the plug goes where the way leaves the side (`sidePlugs`, WILD-001).
-   */
-  readonly plugs?: PlugPlace;
-  /**
-   * The least gap between two free plugs of one side. The default is 0: each plug stays where it is.
-   * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
-   */
-  readonly plugGap?: number;
-}
-/**
- * This function makes a router that goes around the nodes.
- * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
- * of the box corners, without the needless corners. It enters the target plug along its normal.
- */
-export declare function cornersRouter(options: CornersOptions): Router;
-/** The cost of a link that edges of one key share: a fixed discount, or the flow cost `len * f^alpha` (EDA-029). */
-type ShareCost = "fixed" | "flow";
-/** The order of the edges of one key: the longest first, the shortest first, the most load first, or the order of the input (NAT-024). */
-type ShareOrder = "span" | "shortest" | "load" | "input";
-/** The place where a route joins or leaves a run: at a corner of the graph, or at the Snell angle (NAT-035). */
-type ShareMerge = "corner" | "snell";
-/** The options of the router with shared ways. */
-interface SharedOptions extends WayOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
-  /** The edges with one key share their ways. Without a rule, all edges share. An edge without a key shares with no edge. */
-  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 cost of a shared link. With `fixed`, the default, a link that the key uses already costs `discount` times its length.
-   * With `flow`, one more edge on a link with `f` edges costs `len * ((f + 1)^alpha - f^alpha)` (EDA-029).
-   */
-  readonly cost?: ShareCost;
-  /** The exponent of the flow cost, from 0.1 to 1. A smaller value gives more sharing. The default is 0.6. Only the cost `flow` uses it. */
-  readonly alpha?: number;
-  /** The number of passes. In each pass after the first, each edge leaves its links and finds its way again with the others fixed (HWY-039). The default is 1. */
-  readonly passes?: number;
-  /**
-   * The order of the edges of one key. With `span`, the default, the longest edge goes first. With `shortest`, the shortest edge goes first.
-   * With `load`, the edge with the most edges between its two sections goes first. With `input`, the edges keep the order of the graph (NAT-024).
-   */
-  readonly order?: ShareOrder;
-  /**
-   * The place where a route joins or leaves a run. With `corner`, the default, it is a corner of the graph.
-   * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
-   */
-  readonly merge?: ShareMerge;
-  /**
-   * The pull of the busy links of the pass before (HWY-005, Winding Roads). With a value above 0 and two passes or more, each later pass routes each edge again from no ways.
-   * A link then costs `len / (1 + reuse * u)^reuseExponent`, with `u` the edges of the key on it in the pass before. The default is 0: the later passes are rip-up passes.
-   */
-  readonly reuse?: number;
-  /** The exponent of the pull of `reuse`. The default is 1. */
-  readonly reuseExponent?: number;
-  /**
-   * The cost of a lane that does not fit in its channel (HWY-016). One more edge on a link with `f` edges of the key costs `capacity * max(0, (f + 1) * laneWidth - width)` more.
-   * `width` is the free space across the link (`channelWidth`). The default is 0: the router does not read the channels.
-   */
-  readonly capacity?: number;
-  /** The width of one lane, for `capacity`. The default is 4. */
-  readonly laneWidth?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
-}
-/**
- * This function makes a router where edges share their ways (after Pupyrev, Nachmanson, Bereg and Holroyd, "Edge routing with ordered bundles").
- * The edges go one by one through the corner graph. A link that an edge with the same key uses already costs less.
- * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
- * The result gives each stretch as a run, with the order of its lanes.
- */
-export 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 {
-  /**
-   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
-   * The second graph uses the smaller of this value and `margin`. The default is 1.
-   */
-  readonly 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;
@@ -1319,6 +1276,11 @@ export interface NumberOption extends OptionBase {
   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[];
+  /**
+   * These values are the only valid values of the option, in the order of a control. A control shows them as a list, and a sweep gives them.
+   * Without them, each value on the range is valid.
+   */
+  readonly values?: readonly number[];
   /** The strategy uses this value when the caller and `defaults` give no value. */
   readonly default?: number;
 }
@@ -1333,6 +1295,11 @@ 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[];
+  /**
+   * With `function`, the option also takes a rule of the caller in place of a name. A control sets only the names.
+   * Each name is a known rule of the strategy.
+   */
+  readonly custom?: "function";
   /** The strategy uses this value when the caller and `defaults` give no value. */
   readonly default?: V;
 }
@@ -1349,8 +1316,11 @@ export interface ValueOption<V = unknown> extends OptionBase {
 }
 /** 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 declaration that fits the type of an option value: numbers, booleans, string unions or other values.
+ * A union of strings and other values takes an enum of the strings or a value declaration. An example is a rule or the name of a rule.
+ */
+export type OptionDeclaration<V> = [V] extends [number] ? NumberOption : [V] extends [boolean] ? BooleanOption : [V] extends [string] ? EnumOption<V> : [Extract<V, string>] extends [never] ? ValueOption<V> : EnumOption<Extract<V, string>> | 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. */
@@ -1399,12 +1369,12 @@ export declare function optionDefaults<S extends Step, O extends object>(strateg
 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.
+ * An option with a list of `values` gets the nearest value of the list. 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.
+ * A number option gives its `marks`, or its list of `values`, 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[];
@@ -1464,20 +1434,53 @@ export interface RoomInput {
    */
   readonly sections?: Section;
 }
+/** The input of a plug strategy: the graph, and optionally the way finder of the router that reads the plugs. */
+export interface PlugInput {
+  readonly graph: Graph;
+  /** The ways around the nodes of the graph, for a strategy that reads the free space. The default strategy `facing` does not read it. */
+  readonly ways?: WayFinder;
+}
+/** The plugs of the two ends of one edge: the output of a plug strategy for that edge. */
+export interface PlugPair {
+  readonly edge: string;
+  readonly source: Plug;
+  readonly target: Plug;
+}
+/** The input of a level strategy: the graph, the tree of sections of its grouping rule and the routes of the router. */
+export interface LevelInput {
+  readonly graph: Graph;
+  /** The tree of sections. The indices of its nodes are the indices of `graph.nodes`. */
+  readonly root: Section;
+  /** The routes of the router. The default strategy `depths` gives the links of the last level the points of these routes. */
+  readonly routes: readonly Route[];
+}
+/** The output of a strategy of the step `whole`: the board that the routes go on, and the routes. */
+export interface WholeOutput {
+  /** The board: the graph, or the graph with the gaps that a room strategy opened. It has the edges of the input. */
+  readonly graph: Graph;
+  readonly result: Result;
+}
 /**
  * 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.
+ * - `plugs`: a graph in, the plugs of the two ends of each edge out. The router `corners` routes between these plugs.
  * - `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.
+ * - `levels`: a graph, its tree of sections and its routes in, the zoom levels out. The router `sections` gives them in its result.
  * - `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.
+ * - `whole`: a graph in, the board and its routes out. A strategy of this step runs the other steps.
  */
 export interface StepTypes {
   readonly group: {
     readonly input: Graph;
     readonly output: Section;
   };
+  readonly plugs: {
+    readonly input: PlugInput;
+    readonly output: PlugPair[];
+  };
   readonly router: {
     readonly input: Graph;
     readonly output: Result;
@@ -1486,6 +1489,10 @@ export interface StepTypes {
     readonly input: HighwayInput;
     readonly output: HighwayPlan;
   };
+  readonly levels: {
+    readonly input: LevelInput;
+    readonly output: Level[];
+  };
   readonly curve: {
     readonly input: CurveInput;
     readonly output: CurveSegment[];
@@ -1494,6 +1501,10 @@ export interface StepTypes {
     readonly input: RoomInput;
     readonly output: Gap[];
   };
+  readonly whole: {
+    readonly input: Graph;
+    readonly output: WholeOutput;
+  };
 }
 /** The name of a step that has strategies. */
 export type Step = keyof StepTypes;
@@ -1501,7 +1512,11 @@ export type Step = keyof StepTypes;
 export type StepInput<S extends Step> = StepTypes[S]["input"];
 /** The output type of a step. */
 export type StepOutput<S extends Step> = StepTypes[S]["output"];
-/** The steps that have strategies, in the order of the pipeline. */
+/**
+ * The steps that have strategies, in the order of the pipeline.
+ * The plugs come before the router, because the router searches its ways between them. The levels come after the routes, because the last level reads them.
+ * The step `whole` runs the other steps, so it comes last.
+ */
 export declare const STEPS: readonly Step[];
 /**
  * A strategy: one way to do one step, with a name and a description.
@@ -1546,12 +1561,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 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.
+ * The lists `group`, `highway`, `plugs`, `levels` and `whole` are optional in the type, so a registry of an older version stays a registry. `createRegistry` always gives them.
  */
-export type Registry = { readonly [S in Exclude<Step, "group" | "highway">]: readonly Strategy<S>[]; } & {
-  readonly group?: readonly Strategy<"group">[];
-  readonly highway?: readonly Strategy<"highway">[];
-};
+export type Registry = { readonly [S in Exclude<Step, OptionalStep>]: readonly Strategy<S>[]; } & { readonly [S in OptionalStep]?: readonly Strategy<S>[]; };
+/** The steps whose lists are optional in a `Registry`: the steps that came after version 0.1.5. */
+type OptionalStep = "group" | "highway" | "plugs" | "levels" | "whole";
 /** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
 export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
 /** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
@@ -1566,66 +1580,93 @@ export declare function getStrategy<S extends Step>(registry: Registry, step: S,
 export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
 /** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
 export declare function routersOf(registry: Registry): Router[];
-/**
- * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
- * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
- * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
- */
-interface SectionsOptions extends LevelLinkOptions, SectionOptions {
+/** The ways to place a free plug of the corner router. */
+type PlugPlace = "facing" | "side";
+/** The options of the corner router. */
+interface CornersOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
   /**
-   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
-   * and fewer shared ways. Without it, a way passes each hub from its node up.
-   */
-  readonly hubs?: number;
-  /**
-   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
-   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
-   */
-  readonly stretch?: number;
-  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
-  readonly stretchPad?: number;
-  /**
-   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
-   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   * The place of a free plug. The default is `facing`: the plug faces the other end (`placePlug`).
+   * With `side`, the search starts from the whole free side, and the plug goes where the way leaves the side (`sidePlugs`, WILD-001).
    */
-  readonly hubSlack?: number;
+  readonly plugs?: PlugPlace;
   /**
-   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
-   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   * The least gap between two free plugs of one side. The default is 0: each plug stays where it is.
+   * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
    */
-  readonly group?: Strategy<"group">;
-  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
-  readonly groupOptions?: object;
+  readonly plugGap?: number;
   /**
-   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
-   * The default is each depth, from 0 to the depth of the deepest section.
+   * The plug rule: a strategy of the step `plugs` that places the plugs of each edge. It takes the place of the option `plugs`.
+   * Without it, the router places the plugs with the option `plugs`. An edge without plugs from the strategy gets the plugs of `facing`.
    */
-  readonly 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;
+  readonly plug?: Strategy<"plugs">;
+  /** The options of the strategy `plug`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly plugOptions?: object;
 }
 /**
- * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
- * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
- * Each way from hub to hub is found one time, so all the edges on it share its points.
- * The edges in one section of the lowest level go straight around the nodes.
+ * This function makes a router that goes around the nodes.
+ * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
+ * of the box corners, without the needless corners. It enters the target plug along its normal.
+ */
+export declare function cornersRouter(options: CornersOptions): Router;
+/**
+ * The lane order of the stretches (LANE-STRETCH).
  *
- * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ * - `none`: each run gets its own order, as the order `bundle` of `orderLanes` gives it.
+ * - `consensus`: one order of the pair relation of the stretch, from the heuristic of Eades, Lin and Smyth for the feedback arc set.
+ * - `periphery`: the largest run gives its order. Each next run keeps that order and puts each new edge at the place with the fewest broken pairs.
+ * - `sifting`: the order of `consensus`. Then each edge moves to the place with the fewest broken pairs, for `passes` passes.
+ */
+export type LaneStretchOrder = "none" | "consensus" | "periphery" | "sifting";
+/** The values of `LaneStretchOrder`, in the order of a control. */
+export declare const LANE_STRETCH_ORDERS: readonly LaneStretchOrder[];
+/** The options of `stretchLaneOrders`. */
+export interface LaneStretchOptions {
+  /** The lane order of the stretches. The default is `sifting`. */
+  readonly method: LaneStretchOrder;
+  /** The number of passes of the method `sifting`, from 1 to 4. The default is 2. The other methods do not read it. */
+  readonly passes: number;
+}
+/** The default options of `stretchLaneOrders`. */
+export declare const LANE_STRETCH_DEFAULTS: Readonly<LaneStretchOptions>;
+/** One run: its points and the routes on it. Each route holds the points of the run in a row, in either direction. */
+export interface LaneRun {
+  readonly points: readonly Point[];
+  readonly routes: readonly Route[];
+}
+/** One stretch: the runs that follow each other on the routes, and the order of the edges of the stretch. */
+export interface LaneStretch {
+  /** The indexes of the runs in the list of the input. The first run is the root: the run with the most lanes. The others follow in the order of a breadth-first walk. */
+  readonly runs: readonly number[];
+  /** The way of each run of `runs` against the root. The value -1 tells that the left of the root is the right of the run. */
+  readonly turns: readonly (1 | -1)[];
+  /** The edges of the stretch from left to right, in the way of the root. A stretch of one run has the order `bundle` of the run. */
+  readonly order: readonly string[];
+}
+/**
+ * This function gives the stretches of the runs (LANE-STRETCH). Two runs are in one stretch when a chain of links joins them.
+ * A link joins two runs when a route goes through one and then the other, and they share two edges or more.
+ * The result does not depend on the order of the runs or of the routes of each run.
+ */
+export declare function laneStretches(runs: readonly LaneRun[], options?: Partial<LaneStretchOptions>): LaneStretch[];
+/**
+ * This function gives the lane order of each run (LANE-STRETCH). The orders are in the order of `runs`.
+ * Each order holds the edges of the run from left to right. The way goes from the first point of the run to its last point, with the y axis down.
+ * A route that does not hold its run goes last, as in `orderLanes`.
  *
- * The result gives one zoom level for each depth of the tree.
- * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ * With the method `none`, each run gets the order `bundle` of `orderLanes`. With the other methods, each run of a stretch gets the order of the stretch.
+ * Thus two runs of one stretch give two edges the same side. The result does not depend on the order of the runs or of the routes of each run.
  */
-export declare function sectionsRouter(options: SectionsOptions): Router;
+export declare function stretchLaneOrders(runs: readonly LaneRun[], options?: Partial<LaneStretchOptions>): string[][];
 /** The options of the trunk router. */
 interface TrunksOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
-  /** The grouping rule. The edges from one plug with one key share a trunk. */
-  readonly rule: GroupRule;
+  /** The grouping rule, or the name of a built-in rule (`GROUP_RULE_NAMES`). The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule | GroupRuleName;
   /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
   readonly split?: number;
   /** A group with fewer edges stays unbundled. The default is 2. */
@@ -1662,6 +1703,8 @@ type TrunkSplit = "share" | "gilbert";
 type TrunkFan = "split" | "tree";
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 export declare const byCollection: GroupRule;
+/** The names of the built-in grouping rules of the edges. With `collection`, the rule is `byCollection`. With `all`, each edge has one key. */
+type GroupRuleName = "collection" | "all";
 /**
  * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
  * A group with fewer than `minSize` edges does not appear.
@@ -1686,6 +1729,204 @@ export declare function splitPoint(start: Point, targets: readonly Point[], spli
  * The edges outside the groups go as in the corner router.
  */
 export declare function trunksRouter(options: TrunksOptions): Router;
+/** The cost of a link that edges of one key share: a fixed discount, or the flow cost `len * f^alpha` (EDA-029). */
+type ShareCost = "fixed" | "flow";
+/** The order of the edges of one key: the longest first, the shortest first, the most load first, or the order of the input (NAT-024). */
+type ShareOrder = "span" | "shortest" | "load" | "input";
+/** The place where a route joins or leaves a run: at a corner of the graph, or at the Snell angle (NAT-035). */
+type ShareMerge = "corner" | "snell";
+/** The options of the router with shared ways. */
+interface SharedOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The edges with one key share their ways. The option takes a rule or the name of a built-in rule (`GROUP_RULE_NAMES`).
+   * Without a rule, or with `all`, all edges share. An edge without a key shares with no edge.
+   */
+  readonly rule?: GroupRule | GroupRuleName;
+  /** 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 lane order of each stretch of runs (LANE-STRETCH). With `none`, the default, each run gets its order alone.
+   * With `consensus`, `periphery` or `sifting`, the runs that follow each other on the routes share one order. Only the lane order `bundle` reads it.
+   */
+  readonly stretchOrder?: LaneStretchOrder;
+  /** The number of passes of the stretch order `sifting`, from 1 to 4. The default is 2. */
+  readonly siftPasses?: number;
+  /**
+   * The cost of a shared link. With `fixed`, the default, a link that the key uses already costs `discount` times its length.
+   * With `flow`, one more edge on a link with `f` edges costs `len * ((f + 1)^alpha - f^alpha)` (EDA-029).
+   */
+  readonly cost?: ShareCost;
+  /** The exponent of the flow cost, from 0.1 to 1. A smaller value gives more sharing. The default is 0.6. Only the cost `flow` uses it. */
+  readonly alpha?: number;
+  /** The number of passes. In each pass after the first, each edge leaves its links and finds its way again with the others fixed (HWY-039). The default is 1. */
+  readonly passes?: number;
+  /**
+   * The order of the edges of one key. With `span`, the default, the longest edge goes first. With `shortest`, the shortest edge goes first.
+   * With `load`, the edge with the most edges between its two sections goes first. With `input`, the edges keep the order of the graph (NAT-024).
+   */
+  readonly order?: ShareOrder;
+  /**
+   * The place where a route joins or leaves a run. With `corner`, the default, it is a corner of the graph.
+   * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
+   */
+  readonly merge?: ShareMerge;
+  /**
+   * The pull of the busy links of the pass before (HWY-005, Winding Roads). With a value above 0 and two passes or more, each later pass routes each edge again from no ways.
+   * A link then costs `len / (1 + reuse * u)^reuseExponent`, with `u` the edges of the key on it in the pass before. The default is 0: the later passes are rip-up passes.
+   */
+  readonly reuse?: number;
+  /** The exponent of the pull of `reuse`. The default is 1. */
+  readonly reuseExponent?: number;
+  /**
+   * The cost of a lane that does not fit in its channel (HWY-016). One more edge on a link with `f` edges of the key costs `capacity * max(0, (f + 1) * laneWidth - width)` more.
+   * `width` is the free space across the link (`channelWidth`). The default is 0: the router does not read the channels.
+   */
+  readonly capacity?: number;
+  /** The width of one lane, for `capacity`. The default is 4. */
+  readonly laneWidth?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/**
+ * The negotiation of the router `attraction` (HWY-044, PathFinder turned around). Each pass routes each edge again from no ways.
+ * A link costs `len (1 - attraction h) (1 + weight max(0, use - cap))` more than in `shared`, with `h` the history of the link.
+ */
+interface SharedNegotiation {
+  /** The number of passes, 1 or more. */
+  readonly passes: number;
+  /** The pull of the history of a link, from 0 to 1. */
+  readonly attraction: number;
+  /** The cost weight of each edge over the capacity of a link, 0 or more. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width, and 1 or more. */
+  readonly laneWidth: number;
+}
+/**
+ * This function makes a router where edges share their ways (after Pupyrev, Nachmanson, Bereg and Holroyd, "Edge routing with ordered bundles").
+ * The edges go one by one through the corner graph. A link that an edge with the same key uses already costs less.
+ * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
+ * The result gives each stretch as a run, with the order of its lanes.
+ */
+export declare function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation): Router;
+/** The options of the router `attraction` (HWY-044 of the note on highways: negotiated attraction, PathFinder turned around). */
+interface AttractionOptions {
+  /** The number of passes, from 1 to 10. Each pass after the first routes each edge again from no ways. The default is 3. */
+  readonly passes: number;
+  /** The pull `a` of the history of a link, from 0 to 1. A link then costs `1 - a h` times more. The default is 0.5. */
+  readonly attraction: number;
+  /** The cost weight `b` of each edge over the capacity of a link, from 0 to 10. The default is 1. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width. The default is 4. */
+  readonly laneWidth: number;
+}
+/** The default options of the router `attraction`. */
+export declare const ATTRACTION_DEFAULTS: Readonly<AttractionOptions>;
+/** The declarations of the options of the router `attraction` (HWY-044). */
+export declare const ATTRACTION_SCHEMA: OptionSchema<AttractionOptions>;
+/**
+ * This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+ * After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+ * In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+ * The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+ */
+export declare function attractionRouter(options: Partial<AttractionOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `attraction` (HWY-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export declare const attractionStrategy: Strategy<"router", AttractionOptions>;
+/** Two items of a level that a link joins, and the count of the edges between them. */
+interface ItemPair {
+  readonly source: string;
+  readonly target: string;
+  readonly count: number;
+}
+/** The options of the links of a level: the options of the ways, and two limits of the level links. */
+interface LevelLinkOptions extends WayOptions {
+  /**
+   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
+   * The second graph uses the smaller of this value and `margin`. The default is 1.
+   */
+  readonly 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 options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
+ * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
+ * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
+ */
+interface SectionsOptions extends LevelLinkOptions, SectionOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
+   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   */
+  readonly hubs?: number;
+  /**
+   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
+   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
+   */
+  readonly stretch?: number;
+  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
+  readonly stretchPad?: number;
+  /**
+   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
+   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   */
+  readonly hubSlack?: number;
+  /**
+   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
+   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   */
+  readonly group?: Strategy<"group">;
+  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly groupOptions?: object;
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+  /**
+   * The level rule: a strategy of the step `levels` that makes the zoom levels from the tree and the routes.
+   * Without it, the router uses the strategy `depths` (`depthLevels`). The strategy gets the options `levels`, `margin`, `k`, `tightMargin`, `plugInset` and `throughCost` of the router,
+   * and then `levelOptions`.
+   */
+  readonly level?: Strategy<"levels">;
+  /** The options of the strategy `level`. They go over the level options of the router. */
+  readonly levelOptions?: object;
+  /** The lane order of the runs. With `run`, the default, each run gets its order alone. With `bundle`, two edges keep one order on each run of their common stretch. */
+  readonly laneOrder?: RunOrder;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/**
+ * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+ * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+ * Each way from hub to hub is found one time, so all the edges on it share its points.
+ * The edges in one section of the lowest level go straight around the nodes.
+ *
+ * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ *
+ * The result gives one zoom level for each depth of the tree.
+ * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ */
+export declare function sectionsRouter(options: SectionsOptions): Router;
 /** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 export declare const ROUTERS: readonly Router[];
 /**
@@ -1793,6 +2034,71 @@ export declare function levelPairs(items: readonly LevelItem[], owner: readonly
  * 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>;
+/**
+ * This function gives the plugs of the plug strategy `facing`: each free plug faces the other end of its edge (`placePlug`).
+ * A fixed plug stays at its point, and a plug with a side stays on that side. It is the default of the router `corners`.
+ * The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export declare function facingEnds(input: PlugInput): PlugPair[];
+/** The options of the level strategy `depths`: the limits of the level links, and the depths that get a level with groups. */
+export interface DepthLevelOptions extends Omit<LevelLinkOptions, "smooth"> {
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+}
+/**
+ * This function gives the zoom levels of the level strategy `depths`.
+ * It gives one level for each depth of the tree, and a last level with each node alone.
+ * It is the default of the router `sections`. With the option `levels`, only those depths get a level with groups.
+ * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
+ * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
+ * In the last level, the points of a link are the route of its first edge.
+ */
+export declare function depthLevels(input: LevelInput, options?: DepthLevelOptions): Level[];
+/**
+ * The options of the whole strategy `pipeline`: one strategy of each step, and the options of each one.
+ * A rule of the steps `group`, `plugs` and `levels` acts only on a router that reads a rule of that step (`strategyKey`).
+ */
+export interface PipelineOptions {
+  /** The router. A highway plan takes its place. */
+  readonly router: Strategy<"router">;
+  /** The options of the router. */
+  readonly routerOptions?: object;
+  /** The highway strategy. With it, the plan of the strategy and `follow` give the routes, not the router. */
+  readonly highway?: Strategy<"highway">;
+  /** The options of the highway strategy. */
+  readonly highwayOptions?: object;
+  /** The grouping rule of a router that reads one, for example `sections`. */
+  readonly group?: Strategy<"group">;
+  /** The options of the grouping rule. */
+  readonly groupOptions?: object;
+  /** The plug rule of a router that reads one, for example `corners`. */
+  readonly plugs?: Strategy<"plugs">;
+  /** The options of the plug rule. */
+  readonly plugOptions?: object;
+  /** The level rule of a router that reads one, for example `sections`. */
+  readonly levels?: Strategy<"levels">;
+  /** The options of the level rule. */
+  readonly levelOptions?: object;
+  /** The room strategy. With it, the pipeline opens the gaps of the board before the routes (`openGaps`). */
+  readonly room?: Strategy<"room">;
+  /** The options of the room strategy. */
+  readonly roomOptions?: object;
+}
+/**
+ * This function gives the key of the option of a router that takes a strategy of one step.
+ * It gives `undefined` when the router has no such option.
+ * The schema of the router declares the option with the type `strategy` and the step. The options of that strategy have the key `<key>Options`.
+ */
+export declare function strategyKey(router: Strategy<"router">, step: Step): string | undefined;
+/**
+ * This function runs the whole strategy `pipeline` on one graph. The room strategy opens the gaps of the board first.
+ * A highway strategy makes its plan, and `follow` routes the plan. Otherwise the router routes, with each rule of the steps `group`, `plugs` and `levels` that it reads.
+ * The output has the board and the routes. The function does not examine the `maxNodes` of the router.
+ */
+export declare function runPipeline(graph: Graph, options: PipelineOptions): WholeOutput;
 /** 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";
@@ -1967,6 +2273,22 @@ export interface BenchRow {
   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 time of the paired baseline arm (BENCH-GREEN). Only a cell with a baseline router has it. */
+  readonly paired?: Paired;
+}
+/**
+ * The paired baseline arm of a cell. The baseline router routes the same graph in turn with the router, on the same CPU.
+ * The ratio does not change with the speed of the runner, so the ratios of two runs compare better than their times.
+ */
+export interface Paired {
+  /** The name of the baseline router. */
+  readonly base: string;
+  /** The median time of one route of the router in the paired routes, in milliseconds. */
+  readonly ms: number;
+  /** The median time of one route of the baseline router, in milliseconds. */
+  readonly baseMs: number;
+  /** The ratio `ms / baseMs`. A ratio below 1 tells that the router is faster than the baseline. */
+  readonly ratio: number;
 }
 /** The record of a cell over its time limit. */
 export interface OverLimit {
@@ -2003,8 +2325,12 @@ 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 does the work of `benchOne` and also gives the result, so more measures can read it without a second route.
+ * With a baseline router `pair`, the baseline routes the graph one time for each route of the router, in turn: first before, then after.
+ * The row then gets `paired`. The baseline routes do not count for the cell limit, and their results do not change the row.
+ */
+export declare function benchRun(router: Router, fixture: string, graph: Graph, repeat?: number, cellLimit?: number, pair?: Router): 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.
@@ -2218,6 +2544,8 @@ export interface RoomBenchRow {
  * The function also measures the lane routes of the router `sections` at the lane width `spacing`.
  */
 export declare function measureBoard(graph: Graph, spacing: number, order?: LaneOrder): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms">;
+/** This function gives the links of the far view of a board: `levelLinks` with each node as one item. */
+export declare function farLinks(graph: Graph): LevelLink[];
 /**
  * This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
  * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
@@ -2952,6 +3280,29 @@ export interface SuiteOptions {
   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;
+  /**
+   * One shard of the cells of the steps `router` and `highway` (BENCH-GREEN). The default is all the cells.
+   * The strategy at place `s` of its step, on the seed `k`, belongs to the shard `(s + k) % count`, from 0.
+   * So the seeds of one strategy go to different shards, and each shard gets a similar share of the time.
+   * A shard has only these two steps and the step `curve`, because the cells of the other steps do not divide.
+   */
+  readonly shard?: {
+    readonly index: number;
+    readonly count: number;
+  };
+  /**
+   * The largest fixture of a strategy of the steps `router` and `highway`, in nodes, by the name of the strategy. The default is no cap.
+   * A capped strategy does not route a larger fixture. The report lists each such cell in `capped`, so the row is capped, not missing.
+   */
+  readonly caps?: Readonly<Record<string, number>>;
+  /**
+   * The name of the baseline router of the paired arm, for example `shared`. The default is no paired arm.
+   * On the first seed of each fixture, the baseline routes the same graph in turn with each strategy of the steps `router` and `highway`.
+   * The row and the bench row then get `paired`.
+   */
+  readonly pair?: string;
+  /** The paired arm routes only the fixtures up to this number of nodes. The default is 1000. */
+  readonly pairMax?: number;
   /** This function gets one line of progress for each fixture and seed. */
   readonly log?: (line: string) => void;
 }
@@ -2990,6 +3341,18 @@ export interface SuiteRow {
   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 time of the paired baseline arm (`SuiteOptions.pair`). Only the first seed of a fixture has it. */
+  readonly paired?: Paired;
+}
+/** A cell that the suite did not route, because the fixture is larger than the cap of the strategy (`SuiteOptions.caps`). */
+export interface CappedCell {
+  readonly step: Step;
+  readonly strategy: string;
+  readonly fixture: string;
+  /** The nodes of the fixture. */
+  readonly nodes: number;
+  /** The cap of the strategy, in nodes. */
+  readonly cap: number;
 }
 /** The spread of each measure of one strategy on one fixture family, over the seeds. */
 export interface SuiteSummary {
@@ -3037,8 +3400,13 @@ export interface SuiteReport {
   readonly summaries: readonly SuiteSummary[];
   readonly fronts: readonly SuiteFront[];
   readonly rules: readonly RuleCount[];
+  /** The cells over the cap of their strategy, one for each strategy and fixture. A report with no cap has no such field. */
+  readonly capped?: readonly CappedCell[];
 }
-/** The axes of the Pareto front of each step. The note MEAS0 asks for two to four scores. */
+/**
+ * The axes of the Pareto front of each step. The note MEAS0 asks for two to four scores.
+ * The steps `plugs`, `levels` and `whole` run as routers (`stepRouterStrategy`), so they use the axes of the step `router`.
+ */
 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;
@@ -3151,6 +3519,13 @@ export declare function formatRules(rules: readonly RuleCount[]): string;
  * 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;
+/** This function writes the capped cells as a Markdown table. Each line is a cell that the cap of its strategy stopped, so the row is capped, not missing. */
+export declare function formatCapped(capped: readonly CappedCell[]): string;
+/**
+ * This function writes the paired arm of the rows as a Markdown table. It gives the medians of the strategy and of the baseline, and their ratio.
+ * Only the rows with `paired` count.
+ */
+export declare function formatPaired(rows: readonly SuiteRow[]): 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.
@@ -3534,6 +3909,8 @@ interface SnapLine {
 interface SnapOptions extends Pick<WayOptions, "margin" | "k"> {
   /** A highway has this number of edges or more. The value is 2 or more. */
   readonly minSize: number;
+  /** With `true`, a line in clear view is its own spine, with no path through the corner graph. The default is `false`. */
+  readonly direct?: boolean;
 }
 /** This function gives the line `u d + rho n` of the direction angle `theta`, with `d = (cos, sin)` and the normal `n = (-sin, cos)`. */
 export declare function linePoint(theta: number, rho: number, u: number): Point;
@@ -4570,6 +4947,212 @@ export declare function scaleSpaceGroups(input: HighwayInput, o: Readonly<ScaleS
  * A short-lived cluster is noise, so a zoom level shows only the stable structure.
  */
 export declare function scaleSpacePlan(input: HighwayInput, o: Readonly<ScaleSpaceOptions>): HighwayPlan;
+/** The source of the candidate streets: the middle lines of the gaps of the room step, or the lines through the corners. */
+type StreetSource = "room" | "corners";
+/** The values of `StreetSource`. */
+export declare const STREET_SOURCES: readonly StreetSource[];
+/** One axis-parallel street in the free space, from `a` to `b`. */
+interface FreeLine {
+  readonly a: Point;
+  readonly b: Point;
+}
+/** One edge for the streets: its two points out of its plugs, and the length of its first route. */
+interface StreetEdge {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+  readonly base: number;
+}
+/** The ride of one edge on one street. It has the points where the edge joins and leaves the street, and two lengths. */
+interface StreetRide {
+  readonly on: Point;
+  readonly off: Point;
+  /** The length on the street. */
+  readonly ride: number;
+  /** The length of the two ramps, to the street and from it. */
+  readonly ramps: number;
+}
+/**
+ * This function gives the candidate streets of a board. Each street is an axis-parallel piece of free space.
+ * The source `room` takes the middle line of each gap of `boardGaps` that is two margins wide or more.
+ * The source `corners` takes the lines one margin out from each side of each box.
+ * A street is two margins long or more. The list has no copies, and its order is the same each time.
+ */
+export declare function freeLines(graph: Graph, finder: WayFinder, source: StreetSource): FreeLine[];
+/** This function gives the edges of the input for the streets, with the points out of their plugs and the lengths of their first routes. */
+export declare function streetEdges(input: HighwayInput, finder: WayFinder): StreetEdge[];
+/** This function gives the point of the street nearest to `p`. */
+export declare function streetPoint(line: FreeLine, p: Point): Point;
+/** This function gives the ride of an edge on a street. The edge joins the street at the point nearest to `s`, and leaves it at the point nearest to `t`. */
+export declare function streetRide(line: FreeLine, e: StreetEdge): StreetRide;
+/** The options of the highway strategy `gaps` (HWY-057 of the note on highways). */
+interface GapOptions {
+  /** A street with fewer edges than this number (the demand `k`) is not a highway. The default is 3. */
+  readonly minSize: number;
+  /** The cost of a length on a street against a length off the streets, from 0.1 to 0.8. The default is 0.5. */
+  readonly discount: number;
+  /** An edge rides a street only when its way along the street is this many times its first route or less. The default is 1.3. */
+  readonly detour: number;
+  /** The source of the streets: the gaps of the room step, or the lines through the corners. The default is `room`. */
+  readonly source: StreetSource;
+}
+/** The default options of the strategy `gaps`. */
+export declare const GAP_DEFAULTS: Readonly<GapOptions>;
+/**
+ * This function gives the highways on the gaps of the board (HWY-057). The streets are the free middle lines of the gaps.
+ * Each edge takes the street that saves it the most cost, when a length on a street costs `discount` times its length.
+ * A street with `minSize` edges or more becomes a highway. The edges of the other streets then choose again among the highways, two times.
+ */
+export declare function gapPlan(input: HighwayInput, o: Readonly<GapOptions>): HighwayPlan;
+/** The plan that gives the highways of the network: the plan of `corridors` or of `shared-ways`, with their defaults. */
+type InterchangeBase = "corridors" | "shared-ways";
+/** The values of `InterchangeBase`. */
+export declare const INTERCHANGE_BASES: readonly InterchangeBase[];
+/** The options of the highway strategy `interchanges` (HWY-060 of the note on highways). */
+interface InterchangeOptions {
+  /** The plan that gives the highways. The default is `corridors`. */
+  readonly from: InterchangeBase;
+  /** The cost of a change between two highways, in units of the board, from 0 to 8. The default is 2. */
+  readonly changeCost: number;
+  /** The largest number of interchanges, from 1 to 32. The default is 16. */
+  readonly interchanges: number;
+  /** The largest number of highways on the way of one edge, from 1 to 3. The default is 2. */
+  readonly perEdge: number;
+  /** Two highways get an interchange where they come this near, in units of the board. The default is 2. */
+  readonly radius: number;
+  /** The cost of a length on a highway against a length off the highways, from 0.1 to 1. The default is 0.5. */
+  readonly discount: number;
+  /** An edge rides the network only when its way is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+}
+/** The default options of the strategy `interchanges`. */
+export declare const INTERCHANGE_DEFAULTS: Readonly<InterchangeOptions>;
+/** One interchange: a place on the highway `h`, a place on the highway `g`, and the length of the link between the two places. */
+interface Interchange {
+  readonly h: number;
+  readonly hAt: number;
+  readonly g: number;
+  readonly gAt: number;
+  readonly gap: number;
+}
+/** This function gives the candidate interchanges: the nearest places of each pair of spines that come within `radius`, with a link in clear view. */
+export declare function interchangeCandidates(spines: readonly (readonly Point[])[], radius: number, clear: (a: Point, b: Point) => boolean): Interchange[];
+/**
+ * This function gives the highways of a network with interchanges (HWY-060). The highways come from a plan. Two highways that come near get an interchange.
+ * Each edge takes its cheapest way: a ride on one highway, or on up to `perEdge` highways with a change at an interchange.
+ * A change costs `changeCost` units. The interchanges that the most edges use stay, up to `interchanges`.
+ */
+export declare function interchangePlan(input: HighwayInput, o: Readonly<InterchangeOptions>): HighwayPlan;
+/** The options of the highway strategy `search` (HWY-059 of the note on highways). */
+interface SearchOptions {
+  /** The plan where the search starts. The default is `corridors`. */
+  readonly from: CandidateSource;
+  /** The generators of the highways that the move `add` takes. The default is `quickbundles` and `road-classes`. */
+  readonly pool: readonly CandidateSource[];
+  /** The number of plans that the search measures, from 0 to 400. The value 0 gives the start plan. The default is 16. */
+  readonly evaluations: number;
+  /** The first temperature of the annealing, on the scale of the score. Each sweep of 4 moves multiplies it by 0.95. The default is 0.02. */
+  readonly temperature: number;
+  /** The weight of the ink that the routes save (B1). The default is 1. */
+  readonly inkWeight: number;
+  /** The weight of the 0.95 quantile of the stretch against the first routes (B3). The default is 0.5. */
+  readonly stretchWeight: number;
+  /** The weight of the ambiguity (B4). The default is 0.5. */
+  readonly ambiguityWeight: number;
+  /** The weight of the largest merge angle (B6), divided by 180 degrees. The default is 0.25. */
+  readonly angleWeight: number;
+  /** The seed of the moves. The default is 1. */
+  readonly seed: number;
+}
+/** The default options of the strategy `search`. */
+export declare const SEARCH_DEFAULTS: Readonly<SearchOptions>;
+/** The moves of the search. */
+type SearchMove = "add" | "drop" | "edge" | "point";
+/** The values of `SearchMove`, in the order of the draw. */
+export declare const SEARCH_MOVES: readonly SearchMove[];
+/**
+ * This function gives the score of the routes of a plan: `w1 B1 - w3 B3 - w4 B4 - w6 B6 / 180`. Higher is better.
+ * B3 is the 0.95 quantile of the stretch against the first routes. The score reads only the graph and the routes of the plan.
+ */
+export declare function searchScore(graph: Graph, routes: readonly Route[], first: readonly Route[], o: Readonly<SearchOptions>): number;
+/**
+ * This function gives the highways of a local search over the set of highways (HWY-059). The search starts at the plan of `from`.
+ * Each move adds a highway of the pool, drops a highway, moves one edge to another highway, or moves one point of a spine.
+ * The annealing keeps a worse plan with the chance `acceptance(-delta / T)`. The best plan that the search measures is the result.
+ *
+ * The score reads only this graph and its routes. Thus the search does not fit to the inputs of a screen.
+ */
+export declare function searchPlan(input: HighwayInput, o: Readonly<SearchOptions>): HighwayPlan;
+/** The groups of the trees: the edges from one source node, or the edges of one collection. */
+type SteinerGroup = "source" | "key";
+/** The values of `SteinerGroup`. */
+export declare const STEINER_GROUPS: readonly SteinerGroup[];
+/** The method of the tree: the iterated 1-Steiner method on the Hanan grid, or the spanning tree of the terminals alone. */
+type SteinerMethod = "one-steiner" | "spanning";
+/** The values of `SteinerMethod`. */
+export declare const STEINER_METHODS: readonly SteinerMethod[];
+/** The metric of the tree: rectilinear (two directions) or octilinear (four directions). */
+type SteinerMetric = "rectilinear" | "octilinear";
+/** The values of `SteinerMetric`. */
+export declare const STEINER_METRICS: readonly SteinerMetric[];
+/** The options of the highway strategy `steiner` (HWY-036 of the note on highways, with EDA-015). */
+interface SteinerOptions {
+  /** The groups of the trees. The default is `source`. */
+  readonly group: SteinerGroup;
+  /** The method of the tree. The default is `one-steiner`. */
+  readonly method: SteinerMethod;
+  /** A group with more terminals than this number gets the spanning tree alone. The default is 12. */
+  readonly maxGroup: number;
+  /** The metric of the tree. The default is `rectilinear`. */
+  readonly metric: SteinerMetric;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `steiner`. */
+export declare const STEINER_DEFAULTS: Readonly<SteinerOptions>;
+/** This function gives the links of the spanning tree of the points (Prim), as pairs of indices, and the sum of their lengths. */
+export declare function spanningTree(points: readonly Point[], metric: SteinerMetric): {
+  links: [number, number][];
+  cost: number;
+};
+/**
+ * This function gives a Steiner tree of the terminals by the iterated 1-Steiner method (Kahng and Robins). The candidates are the points of the Hanan grid.
+ * Each round adds the candidate that makes the spanning tree shortest, and drops each added point with two links or fewer.
+ * The test `free` removes the candidates in the boxes. The result has the terminals first, then the added points.
+ */
+export declare function oneSteiner(terminals: readonly Point[], metric: SteinerMetric, free: (p: Point) => boolean): {
+  points: Point[];
+  links: [number, number][];
+};
+/**
+ * This function gives the highways of obstacle-avoiding Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree over the points out of its plugs.
+ * The links of the tree are rectilinear or octilinear, and they go around the boxes. Each edge takes its path in the tree, when that path is short enough.
+ * The stretches of the tree that two edges or more share become highways.
+ */
+export declare function steinerPlan(input: HighwayInput, o: Readonly<SteinerOptions>): HighwayPlan;
+/** The options of the highway strategy `streets` (HWY-058 of the note on highways). */
+interface StreetOptions {
+  /** A street covers an edge when the way of the edge along the street is this many times its first route or less (the limit `s`). The default is 1.2. */
+  readonly detour: number;
+  /** The greedy cover stops when the best street gives less than this gain: the length that its edges ride over the length of the street. The default is 2. */
+  readonly minGain: number;
+  /** The largest number of streets. The default is 32. */
+  readonly maxStreets: number;
+  /** A street with fewer new edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The source of the streets: the gaps of the room step, or the lines through the corners. The default is `corners`. */
+  readonly source: StreetSource;
+}
+/** The default options of the strategy `streets`. */
+export declare const STREET_DEFAULTS: Readonly<StreetOptions>;
+/**
+ * This function gives orthogonal streets by a greedy set cover (HWY-058). A street covers each edge whose way along it is at most `detour` times its first route.
+ * Each step takes the street with the largest gain: the length that its new edges ride, over the length of the street that they use.
+ * The cover stops at `maxStreets` streets, or when the best gain is below `minGain`. Each edge rides one street at most.
+ */
+export declare function streetPlan(input: HighwayInput, o: Readonly<StreetOptions>): HighwayPlan;
 /** The lines that make the density: the straight lines of the edges, or their first routes. */
 type RidgeSource = "lines" | "routes";
 /** The options of the highway strategy `ridges` (HWY-032 of the note on highways). */
@@ -4636,8 +5219,11 @@ export declare function ridgeLines(input: HighwayInput, o: Readonly<RidgeOptions
 export declare function ridgePlan(input: HighwayInput, o: Readonly<RidgeOptions>): HighwayPlan;
 /** The options of the highway strategy `soft-keys` (HWY-019 of the note on highways). */
 interface SoftKeyOptions {
-  /** The rule that gives the key of each edge. The default is `byCollection`: the string `data.collection`. */
-  readonly rule: GroupRule;
+  /**
+   * The rule that gives the key of each edge, or the name of a built-in rule (`GROUP_RULE_NAMES`). The default is `byCollection`: the string `data.collection`.
+   * With `all`, each edge has one key, so the keys add no distance.
+   */
+  readonly rule: GroupRule | GroupRuleName;
   /** The distance that two different keys add. `Infinity` keeps the edges of two keys apart, as the hard keys do. The default is 0.25. */
   readonly lambda: number;
   /** Two clusters join while their distance is this value or less. The default is 0.5. */
@@ -5335,21 +5921,51 @@ export declare const highwayStrategies: {
   readonly consensus: Strategy<"highway", ConsensusOptions>;
   readonly "p-hub": Strategy<"highway", PHubOptions>;
   readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
+  readonly steiner: Strategy<"highway", SteinerOptions>;
+  readonly gaps: Strategy<"highway", GapOptions>;
+  readonly streets: Strategy<"highway", StreetOptions>;
+  readonly search: Strategy<"highway", SearchOptions>;
+  readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
   readonly "corridors+hysteresis": Strategy<"highway", CorridorOptions & HysteresisOptions>;
   readonly "corridors+ids": Strategy<"highway", CorridorOptions & StableIdOptions>;
 };
+/** The built-in plug rules: the strategies of the step `plugs`. The router `corners` routes between their plugs with its option `plug`. */
+export declare const plugStrategies: {
+  readonly facing: Strategy<"plugs", object>;
+};
+/** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
+export declare const levelStrategies: {
+  readonly depths: Strategy<"levels", DepthLevelOptions>;
+};
+/**
+ * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
+ * Without options, it routes the graph with the router `corners`.
+ */
+export declare const wholeStrategies: {
+  readonly pipeline: Strategy<"whole", PipelineOptions>;
+};
 /** 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;
+/**
+ * The steps whose strategies give no routes alone. `compareAnyStep` and the screen compare each strategy of these steps as a router (`stepRouterStrategy`).
+ * The step `highway` gives a plan, and the step `plugs` gives the plugs.
+ * The step `levels` gives the zoom levels, and the step `whole` gives a board with its routes.
+ */
+export type RoutedStep = "plugs" | "highway" | "levels" | "whole";
+/** The steps of `RoutedStep`, in the order of the pipeline. */
+export declare const ROUTED_STEPS: readonly RoutedStep[];
+/** This function tells if a step is a step of `RoutedStep`. */
+export declare const isRoutedStep: (step: Step) => step is RoutedStep;
 /**
  * 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.
+ * The steps of `RoutedStep` give no routes alone, so they are not in the list. `compareAnyStep` compares them as routers.
  */
-export type CompareStep = Exclude<Step, "room" | "highway">;
+export type CompareStep = Exclude<Step, "room" | RoutedStep>;
 /** The steps that `compareStep` compares, in the order of the pipeline. */
 export declare const COMPARE_STEPS: readonly CompareStep[];
 /** The options of `compareStep`. */
@@ -5419,6 +6035,60 @@ export interface StepComparison {
  * 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;
+/** The steps that `compareAnyStep` compares: each step of `STEPS`, in the order of the pipeline. */
+export declare const COMPARE_ALL_STEPS: readonly Step[];
+/**
+ * This function gives a router for each highway strategy of a registry, in the order of the registry.
+ * Each router makes the plan of its strategy and routes the plan with `follow` (`highwayRouterStrategy`).
+ * The screen and `compareAnyStep` compare the highway strategies as these routers.
+ */
+export declare function highwayRouters(registry: Registry): Strategy<"router">[];
+/**
+ * This function gives a router strategy that runs a strategy of a step of `RoutedStep`. The router has the name, the options and the schema of the strategy.
+ * - A highway strategy makes its plan, and `follow` routes the plan (`highwayRouterStrategy`).
+ * - A plug rule gives the plugs of the router `corners` (its option `plug`).
+ * - A level rule gives the zoom levels of the router `sections` (its option `level`).
+ * - A whole strategy gives the routes of its output. A room strategy in its options can change the board, but the measures read the input graph.
+ */
+export declare function stepRouterStrategy(strategy: Strategy<RoutedStep>): Strategy<"router">;
+/** This function gives a router for each strategy of one step of `RoutedStep` in a registry, in the order of the registry (`stepRouterStrategy`). */
+export declare function stepRouters(registry: Registry, step: RoutedStep): Strategy<"router">[];
+/** One strategy of any step on one graph: a row of `compareStep`, or a row of the steps `highway` and `room`. */
+export interface AnyCompareRow extends Omit<CompareRow, "step"> {
+  readonly step: Step;
+  /** The boxes of the board that the room strategy opens, in the order of the nodes, for the step `room`. */
+  readonly boxes?: readonly Box[];
+  /** The links of the far view on the board that the room strategy opens, for the step `room`. */
+  readonly links?: readonly LevelLink[];
+}
+/** The comparison of the strategies of any step on one graph. */
+export interface AnyStepComparison extends Omit<StepComparison, "step" | "rows"> {
+  readonly step: Step;
+  /** One row for each strategy of the step, in the order of the registry. */
+  readonly rows: readonly AnyCompareRow[];
+}
+/** The options of `compareAnyStep`. */
+export interface AnyCompareOptions extends CompareOptions {
+  /** This function gets each row when its strategy is done, with the number of rows that are done and the number of all rows. A host can show the progress. */
+  readonly onRow?: (row: AnyCompareRow, done: number, total: number) => void;
+}
+/**
+ * This function gives the measures of a board that a room strategy opened.
+ * It uses the keys and the lane spacing 4 of the step `room` of `runSuite`.
+ * The measures are the area against the board before (`M1.area`), the lane routes through a box (`M4.laneThrough`), the faults of the far view and `room-order`.
+ */
+export declare function roomValues(graph: Graph, open: readonly Node[]): Record<string, number>;
+/**
+ * This function runs each strategy of any step of `STEPS` on one graph and measures it. Then it gives the Pareto front of `FRONT_OBJECTIVES`.
+ * The steps `group`, `router` and `curve` give the rows of `compareStep`.
+ * The step `highway` makes the plan of each strategy and routes it with `follow`, as the screen does. It measures the routes as the step `router`.
+ * The steps `plugs`, `levels` and `whole` also run each strategy as a router (`stepRouterStrategy`), and measure the routes as the step `router`.
+ * The step `room` opens the gaps of the board with each strategy (`openGaps`). It measures the open board as the step `room` of `runSuite`.
+ * The step `room` expects a packed board, for example `packedGridBoard`. On a board with wide gaps, a gap opens only when its links need more room.
+ *
+ * The function runs one strategy at a time and gives each row to `onRow`. The same graph and the same options give the same measures. Only the times change.
+ */
+export declare function compareAnyStep(step: Step, graph: Graph, options?: AnyCompareOptions): AnyStepComparison;
 /** This function gives the bytes of a string in UTF-8. The contract does not export its own `utf8`, so the core keeps this function. */
 export declare function utf8(text: string): Uint8Array;
 /**
@@ -5445,6 +6115,8 @@ export interface LayoutPort {
   /** 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;
+  /** The fixed place of the port on its `side`: a fraction from 0 to 1. The start is the top end or the left end of the side. */
+  readonly along?: number;
 }
 /** A point of a region: `[x, y]`. The y axis points down. */
 export type RegionPoint = readonly [number, number];
@@ -5657,7 +6329,7 @@ export interface LayoutPrediction {
 }
 /**
  * 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.
+ * A fixed plug gets `x`, `y` and the side that holds it. A plug with `along` keeps its `side` and `along`. `inputGraph` reads the file back.
  */
 export declare function graphInput(graph: Graph, head: LayoutInputHead): LayoutInput;
 /**
@@ -5778,20 +6450,55 @@ export interface ScreenFamily {
   /** The cell of each member in the taxonomy of the corpus. */
   readonly cell: LayoutCell;
 }
+/**
+ * The key of the family of a screen input (SCREEN-WEIGHT). The map form gives the kind of the cell as the key, with no other dimension.
+ * The cells of a screen set have no `kind`, and `dense-groups` and `many-groups` have the same cell. Thus `familyCell` adds the family of the input as the kind.
+ */
+export declare const SCREEN_FAMILY_BY: FamilyBy;
+/** This function gives the cell of an input for the key `familyBy`: the cell of the input, with its family as `kind`. */
+export declare const familyCell: (input: {
+  readonly family: string;
+  readonly cell?: LayoutCell;
+}) => FamilyCell;
+/** The claims of a manifest. `declared` gives the count of the inputs of each family (`docs/CORPUS-CHECKS.md` of `layout-contract`). */
+export interface CorpusClaims {
+  readonly declared: DeclaredClaim;
+}
 /** 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 claims of the manifest of the set. A set without claims has no field `claims` in its manifest. */
+  readonly claims?: CorpusClaims;
+  /** The member seeds of each family that the split `default` holds out. A set without them has no split file. */
+  readonly heldOut?: readonly number[];
 }
+/** This function gives the seed of the member `k` of a case board with the base seed `base`: `base + 1009 * k`, the rule of `familySeed`. */
+export declare function caseSeed(base: number, k: number): number;
 /**
  * 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`.
+ *
+ * The manifest declares the inputs of each family, with `minCount` 3. The case boards `hub-chain` and `many-groups` have 1 input, so they are in `thin`.
+ * The boards of this set do not change. The tests compare it with the files in `corpus/screen-v1`.
  */
 export declare const SCREEN_V1: ScreenSet;
-/** The screen sets by id: `screen-v1`, the small boards with a known optimum `exact-v1` (MEAS2), and the larger boards with bounds `exact-v1-bounds` (EXACT-BOUNDS). */
+/** The member seeds of each family of `screen-v2` that the split `default` holds out. */
+export declare const SCREEN_V2_HELD_OUT: readonly number[];
+/**
+ * The screen set `screen-v2` (CORPUS-SEEDS): the 6 families of `screen-v1`, each with the 10 members 0 to 9, thus 60 boards.
+ * Each family keeps the seed rule of `screen-v1`. Thus the members 0 to 2 are the boards of `screen-v1`, and the member 0 of `hub-chain` and `many-groups` is their board.
+ *
+ * The manifest declares 10 inputs for each family, and each family key has 10 inputs or more. The split `default` holds out the members 7 to 9 of each family.
+ * This set does not change. The tests compare it with the files in `corpus/screen-v2`.
+ */
+export declare const SCREEN_V2: ScreenSet;
+/**
+ * The screen sets by id. `screen-v1` and its larger version `screen-v2` (CORPUS-SEEDS) have the boards of the screen.
+ * `exact-v1` has small boards with a known optimum (MEAS2). `exact-v1-bounds` has larger boards with bounds (EXACT-BOUNDS).
+ */
 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;
@@ -5814,9 +6521,35 @@ export interface LayoutCorpus {
     readonly hash: string;
     readonly cell: LayoutCell;
   }[];
+  readonly claims?: CorpusClaims;
 }
-/** 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;
+/**
+ * This function gives the manifest of a list of inputs. The inputs of one generator, version and parameters share one spec.
+ * With `claims`, the manifest has the field `claims`.
+ */
+export declare function corpusManifest(corpus: string, inputs: readonly LayoutInput[], claims?: CorpusClaims): LayoutCorpus;
+/** This function gives the manifest of a screen set, with the claims of the set. */
+export declare function setManifest(set: ScreenSet, inputs?: readonly LayoutInput[]): LayoutCorpus;
+/** The hook of the claim `declared` of a screen set: each input declares its family. */
+export declare const declaresFamily: (input: {
+  readonly family: string;
+}) => readonly string[];
+/**
+ * This function checks the claim `declared` of a manifest against its inputs, with the shared check of the contract. A manifest without the claim gives no break.
+ * With `familyBy`, the check reads the cell of each input with `familyCell`.
+ */
+export declare function checkFamilies(manifest: LayoutCorpus, inputs: readonly LayoutInput[]): ClaimBreak[];
+/** This function gives the hash of the corpus of a manifest with the shared function `corpusHashOf` of the contract. It reads the input ids and the input hashes. */
+export declare function manifestHash(manifest: LayoutCorpus): string;
+/**
+ * This function gives the split file `corpus-split/1` of a screen set with `heldOut`. A set without `heldOut` gives `undefined`.
+ * The seeds of a split file are the seeds of the specs of the manifest. Thus each fold lists the generator seeds of its members.
+ * - The split `default` has one fold. It holds out the members `heldOut` of each family and trains on the other members.
+ * - The split `by-member` has one fold for each member `k`. The fold holds out the member `k` of each family.
+ */
+export declare function screenSplit(set: ScreenSet, manifest?: LayoutCorpus): CorpusSplit | undefined;
+/** This function gives the path of the split file of a corpus, relative to the folder of the corpora: `splits/<corpus id>.<corpus hash>.json`. */
+export declare function splitPath(split: CorpusSplit): string;
 /**
  * This function gives the output hash of a result of a router, in the highways form.
  * The form holds the routes in the order of the edge ids, and the levels, the bundles and the runs as the router gives them.
@@ -6069,10 +6802,11 @@ export declare function gapValues(input: {
   readonly hash: string;
 }, graph: Graph, result: Result, corners: readonly Route[], baselines: Readonly<Record<GapRule, number>>, optima: ReadonlyMap<string, ExactOptimum>): Record<string, number>;
 /**
- * The steps of the screen: the steps of `compareStep` and the step `highway`.
+ * The steps of the screen: the steps of `compareStep` and the steps of `RoutedStep`.
  * The screen of the step `highway` routes the plan of each strategy with `follow`, and measures the routes as the routes of a router.
+ * The screen of the steps `plugs`, `levels` and `whole` runs each strategy as a router (`stepRouterStrategy`). It measures the routes as the routes of a router.
  */
-export type ScreenStep = CompareStep | "highway";
+export type ScreenStep = CompareStep | RoutedStep;
 /** 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. */
@@ -6217,8 +6951,6 @@ export declare function unwrappedName(name: string): string;
 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. */
@@ -6226,8 +6958,9 @@ export interface RectScatteredParams {
 }
 /**
  * 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`.
+ * It uses the shared family `RECT_SCATTERED` of `@mark1russell7/layout-contract` (CORPUS-GEN). The repository `packing` makes the same file, byte for byte.
+ *
+ * @deprecated Use `RECT_SCATTERED` on a registry of `createFamilyRegistry`. This function stays for the callers of today.
  */
 export declare function rectScattered(seed: number, params: RectScatteredParams, set?: string): LayoutInput;
 /** The board classes of the small boards with a known optimum (MEAS2). */
@@ -6272,6 +7005,70 @@ export declare function boundsFamilyName(cls: ExactClass, nodes: number): string
  * This set does not change. The tests compare it with the files in `corpus/exact-v1-bounds`.
  */
 export declare const EXACT_V1_BOUNDS: ScreenSet;
+/**
+ * The output of a family of highways: the graph of the board and its generator record.
+ * A screen set puts the board into an input file with `graphInput`. The set gives the id, the member seed and the cell.
+ */
+export interface HighwaysBoard {
+  readonly graph: Graph;
+  /** The generator of the board: its name, its version, its parameters and its input seed. */
+  readonly generator: LayoutGenerator;
+}
+/** A corpus family of highways: a family of the shared registry whose output is a `HighwaysBoard`. */
+export type HighwaysFamily = CorpusFamily$1<HighwaysBoard>;
+/** The engine of each dimension of the families of highways. */
+export declare const HIGHWAYS_ENGINE = "highways";
+/** The fields of a numeric dimension of `numberDimension`. */
+interface NumberFields {
+  readonly name: string;
+  readonly kind: "int" | "real";
+  readonly min: number;
+  readonly max: number;
+  readonly default: number;
+  readonly scale?: "linear" | "log";
+  readonly meaning: string;
+}
+/** This function gives an `int` or a `real` dimension that only highways reads. */
+export declare function numberDimension(fields: NumberFields): CorpusDimension$1;
+/** This function gives an `enum` dimension that only highways reads. */
+export declare function enumDimension(name: string, values: readonly string[], value: string, meaning: string): CorpusDimension$1;
+/** This function gives the values of the dimensions that differ from their defaults, in the order of the dimensions. */
+export declare function changedDimensions(dimensions: readonly CorpusDimension$1[], dims: DimensionValues$1): Record<string, ParamValue$1>;
+/** This function gives the value of a numeric dimension. It throws a `RangeError` when the value is not a number. */
+export declare function numberOf(dims: DimensionValues$1, name: string): number;
+/** The values of the dimension `layout`: each `FixtureKind`. */
+export declare const FIXTURE_LAYOUTS: readonly FixtureKind[];
+/** The share of the edges near the source when a spec has no `locality`: the default of `makeFixture`. */
+export declare const FIXTURE_LOCALITY = .65;
+/** This function gives the spec of a fixture board from the full dimension values. A field at the default of `makeFixture` stays out of the spec. */
+export declare function fixtureSpecOf(name: string, seed: number, dims: DimensionValues$1): FixtureSpec;
+/**
+ * This function gives the parameters of the generator record of a fixture board: the spec without its name and its seed.
+ * Thus the record of each screen board stays the record of today, for example `{ kind, nodes, edgesPerNode, fixedPorts }` of `small-clustered`.
+ */
+export declare function fixtureParams(spec: FixtureSpec): Readonly<Record<string, unknown>>;
+/** The family `tiny-uniform`: 10 nodes at random places. It is the fixture `tiny-uniform` of `FIXTURES` at its defaults. */
+export declare const TINY_UNIFORM: HighwaysFamily;
+/** The family `small-clustered`: 100 nodes in clusters, with a fixed plug on 20% of the nodes. It is the fixture `small-clustered` at its defaults. */
+export declare const SMALL_CLUSTERED: HighwaysFamily;
+/** The family `dense-groups`: 150 nodes in tight clusters. It is `denseGroupsBoard` at its defaults. */
+export declare const DENSE_GROUPS: HighwaysFamily;
+/** The family `hub-chain`: rows of cards in a chain, and long links between rows. At its defaults, it is `hubChainBoard`. */
+export declare const HUB_CHAIN: HighwaysFamily;
+/** The family `many-groups`: groups of cards in a grid, with links between groups. At its defaults, it is `manyGroupsBoard`. */
+export declare const MANY_GROUPS: HighwaysFamily;
+/**
+ * The family `packed-grid`: a grid of boxes that touch. At its defaults, it is `packedGridBoard` with 12 columns, 8 rows and 48 long links.
+ * Its generator record always has `cols`, `rows` and `long`, as the screen sets of today. It has `reach` only away from its default.
+ */
+export declare const PACKED_GRID: HighwaysFamily;
+/**
+ * The corpus families of highways, in the order of the screen sets. Each family at its defaults makes the board of its screen family.
+ * An import registers nothing. A host makes a registry with `createFamilyRegistry(HIGHWAYS_FAMILIES)`, or with the lists of other engines too.
+ */
+export declare const HIGHWAYS_FAMILIES: readonly HighwaysFamily[];
+/** This function gives a new registry of `HIGHWAYS_FAMILIES`. */
+export declare function highwaysRegistry(): FamilyRegistry$1<HighwaysBoard>;
 /**
  * This function gives the stretch of each route as the exact model counts it, by the edge id.
  * The stretch of a route is its length without its two plug ends, divided by the shortest way in the network of the model.
@@ -6310,7 +7107,7 @@ interface FollowOptions extends WayOptions {
  * 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;
+export declare function follow(input: 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.
@@ -6659,5 +7456,10 @@ export declare const portfolioStrategy: Strategy<"router", PortfolioRouterOption
  * Each set comes from the train seeds (0 to 4) of its band. The base `shared` is not in a set: the portfolio always runs it first.
  */
 export declare const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly string[]>>;
-export { type AdvectionSettings, type AmbiguityGuardOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type Biclique, type BreakEvenOptions, type BundleLine, type BundleOrder, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrechetBundle, type FrechetOptions, type Gate, type GroupScope, type GroupSpine, type GroupedOptions, type GrowthOptions, type GrowthOrder, type HashOptions, type HdbscanOptions, type HierarchyGroups, type HierarchyOptions, type Highway, type HighwayBase, type HighwayInput, type HighwayMember, type HighwayOptions, type HighwayPlan, type HoughOptions, type HoughPeak, type HubAllocation, type HubArcOptions, type HubCandidates, type HysteresisOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type MeetOptions, type Member, type MemberStatus, type MemberTrace, type MeshOptions, type MingleOptions, type MlsFit, type MlsebOptions, type ModuleRule, type NestedOptions, type NodeKey, type NodeLinks, type OdCellOptions, type OutputGroup, type PHubOptions, type PathStep, type PickSpec, type Portfolio, type PortfolioKey, type PortfolioLevel, type PortfolioOptions, type PortfolioPick, type PortfolioTrace, type PowerOptions, type QuickBundlesOptions, RECORD_EPS, type ResistanceOptions, type Ridge, type RidgeOptions, type RidgeSource, type RoadClassOptions, type RoomBends, type RoundedOptions, type RouteCrossing, type RouteSegment, type SbebOptions, type ScaleCluster, type ScaleSpaceOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedOptions, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SmoothOptions, type SnapLine, type SnapMember, type SnapOptions, type SoftKeyOptions, type SpectralOptions, type SpiralNode, type SpiralOptions, type SplineOptions, type SplitCell, type StableIdOptions, type StretchOptions, type StubEnds, type StubOptions, type TerritoryOptions, type TerritoryPoints, type TraceOptions, type TraclusOptions, type TrafficRule, type TrunkFan, type TrunkSplit, type TrunksOptions, type WeiszfeldOptions, type WspdOptions, type Zip, type ZipLimits, type ZipperOptions, canonicalJson, compareMeasure, exercised, minEffectOf, outputGroups, outputHash, pickMoves, portfolio, selectBest, sha256Hex };
+/**
+ * The router strategy `shared-stretch` (LANE-STRETCH). It routes as `shared`, and the runs of one stretch share one lane order.
+ * The default stretch order is `sifting`, the best order of the screen. The option `stretchOrder` selects `consensus` or `periphery`.
+ */
+export declare const sharedStretchStrategy: Strategy<"router", RouterPreset<SharedOptions>>;
+export { type AdvectionSettings, type AmbiguityGuardOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type Biclique, type BreakEvenOptions, type BundleLine, type BundleOrder, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorpusDimension, type CorpusFamily, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, DEFAULT_RNG, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DimensionValues, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FamilyRegistry, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrechetBundle, type FrechetOptions, type FreeLine, type GapOptions, type Gate, type GenerateContext, type GroupScope, type GroupSpine, type GroupedOptions, type GrowthOptions, type GrowthOrder, type HashOptions, type HdbscanOptions, type HierarchyGroups, type HierarchyOptions, type Highway, type HighwayBase, type HighwayInput, type HighwayMember, type HighwayOptions, type HighwayPlan, type HoughOptions, type HoughPeak, type HubAllocation, type HubArcOptions, type HubCandidates, type HysteresisOptions, type Interchange, type InterchangeBase, type InterchangeOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type MeetOptions, type Member, type MemberStatus, type MemberTrace, type MeshOptions, type MingleOptions, type MlsFit, type MlsebOptions, type ModuleRule, type NestedOptions, type NodeKey, type NodeLinks, type OdCellOptions, type OutputGroup, type PHubOptions, type ParamValue, type PathStep, type PickSpec, type Portfolio, type PortfolioKey, type PortfolioLevel, type PortfolioOptions, type PortfolioPick, type PortfolioTrace, type PowerOptions, type QuickBundlesOptions, RECORD_EPS, type ResistanceOptions, type Ridge, type RidgeOptions, type RidgeSource, type RoadClassOptions, type RoomBends, type RoundedOptions, type RouteCrossing, type RouteSegment, type SbebOptions, type ScaleCluster, type ScaleSpaceOptions, type SearchMove, type SearchOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedNegotiation, type SharedOptions, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SmoothOptions, type SnapLine, type SnapMember, type SnapOptions, type SoftKeyOptions, type SpectralOptions, type SpiralNode, type SpiralOptions, type SplineOptions, type SplitCell, type StableIdOptions, type SteinerGroup, type SteinerMethod, type SteinerMetric, type SteinerOptions, type StreetEdge, type StreetOptions, type StreetRide, type StreetSource, type StretchOptions, type StubEnds, type StubOptions, type TerritoryOptions, type TerritoryPoints, type TraceOptions, type TraclusOptions, type TrafficRule, type TrunkFan, type TrunkSplit, type TrunksOptions, type WeiszfeldOptions, type WspdOptions, type Zip, type ZipLimits, type ZipperOptions, canonicalJson, compareMeasure, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex };
 //# sourceMappingURL=index.d.ts.map