@mark1russell7/highways 0.4.2 → 0.5.1

package/build/index.d.ts

@@ -1,3 +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";
 /** A point in the plane. */
 export interface Point {
   readonly x: number;
@@ -734,6 +735,8 @@ export declare class CornerGraph {
   constructor(nodes: readonly Node[], obstacles: Obstacles, options: CornerGraphOptions);
   /** This method gives the number of links of the graph. */
   get linkCount(): number;
+  /** This method gives the corners that link to the corner `i`, in the order of their indexes. A corner that is not in the graph gives an empty list. */
+  neighbours(i: number): readonly number[];
   /** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
   nearest(p: Point): number;
   /** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
@@ -783,6 +786,19 @@ export declare class SoftGraph {
    */
   path(from: Point, to: Point, cost: (n: Node) => number): Point[];
 }
+/** The largest distance that `channelWidth` looks on each side of a link. A wider channel counts as this width on that side. */
+export declare const CHANNEL_REACH = 64;
+/**
+ * This function gives the distance from `p` along the unit direction `d` to the box, or `Infinity` when the ray does not meet the box.
+ * A point inside the box gives 0. The function uses the slab test.
+ */
+export declare function rayToBox(p: Point, d: Point, box: Box): number;
+/**
+ * This function gives the width of the channel of the link from `a` to `b`. The width is the free space between the nearest boxes on the two sides.
+ * It measures the width at five points of the link, and gives the smallest. Each side counts up to `reach`.
+ * A link of length 0 gives the free space across the x axis at its point.
+ */
+export declare function channelWidth(obstacles: Obstacles, a: Point, b: Point, reach?: number): number;
 /** The options of a way finder. */
 export interface WayOptions {
   /** The distance from a box to the corners of the graph. The default is 5. */
@@ -1043,6 +1059,20 @@ interface SharedOptions extends WayOptions {
    * 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;
 }
@@ -2619,6 +2649,16 @@ export declare function positionStability(levels: readonly Level[]): number;
  * A result without such a level gives 1. The cost is `n log n`, with a sample above 1500 items.
  */
 export declare function orderStability(graph: Graph, levels: readonly Level[]): number;
+/**
+ * This function gives the link agreement of the levels with groups (Z9 of MEAS0).
+ * `la = mean over links of hausdorff(link, routes of its edges outside the two items) / u`, with `u` the argument `unit`.
+ * The edges of a link are the edges between a node of one item and a node of the other item, in either direction.
+ *
+ * The function samples each polyline at points `u / 4` apart, with at most 64 points for each polyline. It keeps the points outside the boxes of the two items.
+ * A link without such points on both sides does not count. It gives `undefined` when no link counts.
+ * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
+ */
+export declare function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined;
 /** A grouping of the nodes: a map from the id of each node to the id of its group. */
 export type Grouping = ReadonlyMap<string, string>;
 /** This function gives the grouping of one level: each node goes to the id of its item. */
@@ -2787,6 +2827,92 @@ export interface HighwayEdits {
  * `follow` routes each plan with the way options of the strategy. The same graph, strategy, options and seed give the same values.
  */
 export declare function highwayEdits(graph: Graph, strategy: Strategy<"highway", object>, options: object | undefined, edits: number, seed?: number): HighwayEdits;
+/**
+ * The lane width of the lane measures, in units of the board. The room bench opens the lanes at the same width (`spacing` of `measureBoard`).
+ * R12 also uses it as the smallest correct distance between two parallel legs.
+ */
+export declare const MEASURE_LANE_WIDTH = 4;
+/** The routes of a result with each shared segment open: one lane for each edge. */
+export interface OpenLanes {
+  /** The segments of the result. The shared segments are the runs and the trunks of the bundles. */
+  readonly graph: SegmentGraph;
+  /** The lane route of each edge, from `laneRoutes`. Without a shared segment, the lane routes are the routes. */
+  readonly lanes: readonly Route[];
+  /** The distance between two lanes. */
+  readonly width: number;
+}
+/** This function opens each shared segment of a result: each edge of a run or of a trunk gets its own lane, `width` apart. */
+export declare function openLanes(result: Result, width?: number): OpenLanes;
+/**
+ * This function gives the lane separation of the routes (R12 of MEAS0): the share of the ink that runs too near a parallel leg of other edges.
+ *
+ * A leg is a drawn segment of `S`, and a leg that several routes share counts one time, as in B1. Two legs are near when four things are true.
+ * The sets of their edges are different. They are within `maxAngle` degrees of parallel. Their projections overlap. Their distance is less than `near`.
+ *
+ * `ns = Σ_s length(the part of s that the projections of its near legs cover) / ink(S)`. Each part counts one time, so the scale is 0 to 1.
+ * Lower is better. Routes without ink give 0. A grid of buckets finds the near legs, so the cost is `n log n` for an even density.
+ */
+export declare function routeSeparation(routes: readonly Route[], near?: number, maxAngle?: number): number;
+/**
+ * This function gives the orthogonality of the routes (R14 of MEAS0): `orth = Σ L(legs within maxAngle degrees of an axis) / Σ_e L(r_e)`.
+ * Each route counts its own legs, also on a shared segment. The scale is 0 to 1, and higher is better for an orthogonal style.
+ * Routes without length give 1. The cost is linear.
+ */
+export declare function orthogonality(routes: readonly Route[], maxAngle?: number): number;
+/**
+ * This function counts the lane crossings of the segments of a result (B5 of MEAS0): the pairs of edges whose lane order flips.
+ * Along the route of each edge `e`, it takes the shared segments in order. On each one, another edge `f` is on the left or on the right of `e`, in the way of `e`.
+ *
+ * A pair `(e, f)` counts one time when the side of `f` changes from one shared segment of both edges to the next one.
+ * Lower is better. A result without shared segments gives 0. The cost is the sum of the squares of the edge counts of the shared segments.
+ */
+export declare function laneCrossings(graph: SegmentGraph): number;
+/**
+ * This function gives the occupied area of the routes (B7 of MEAS0): `moa = cells that S touches / cells that the straight lines touch`.
+ * The cells are squares of side `unit` from the origin, and `unit` is `u` of the board (`boardUnit`). The straight line of an edge joins the two ends of its route.
+ * The scale is a ratio, and lower is better. Routes without a straight line give 1. The cost is linear in the cells.
+ */
+export declare function occupiedArea(routes: readonly Route[], unit: number): number;
+/** The run profile of a result (B8 of MEAS0). */
+export interface RunProfile {
+  /** The number of shared segments: the runs and the trunks of the bundles with two edges or more. */
+  readonly runs: number;
+  /** The median of the edges of each shared segment. It is 0 without a shared segment. */
+  readonly median: number;
+  /** The most edges of one shared segment. It is 0 without a shared segment. */
+  readonly max: number;
+}
+/** This function gives the run profile of a result (B8 of MEAS0): the shared segments, and the median and the most edges of each. The cost is linear. */
+export declare function runProfile(graph: SegmentGraph): RunProfile;
+/** The lane fidelity of a result (B9 of MEAS0). */
+export interface LaneFidelity {
+  /** The median of `lf(e)` over the edges with a shared segment. */
+  readonly median: number;
+  /** The largest `lf(e)`. */
+  readonly max: number;
+  /** The number of edges with a shared segment. */
+  readonly edges: number;
+}
+/**
+ * This function gives the lane fidelity (B9 of MEAS0): `lf(e) = frechet(lane(e), r_e) / (width · k / 2)` for each edge `e` with a shared segment.
+ * `lane(e)` is the lane route of `openLanes`, `r_e` is the route, and `k` is the edge count of the widest shared segment of `e`.
+ * `frechet` is the discrete Fréchet distance of the points. A value of 1 or less is correct, and lower is better.
+ * It gives `undefined` when no edge has a shared segment. The cost is quadratic in the points of each route.
+ */
+export declare function laneFidelity(routes: readonly Route[], open: OpenLanes): LaneFidelity | undefined;
+/**
+ * This function counts the lane routes that go through a box that is not one of their ends (M4 of MEAS0).
+ * It is the count `laneThrough` of the room bench (`measureBoard`), for the lanes of any result. Lower is better. The cost is `n log n`.
+ */
+export declare function lanesThrough(graph: Graph, open: OpenLanes): number;
+/**
+ * This function gives the area of a result (M1 of MEAS0) for a router: the growth of the board that the open lanes need.
+ * The value is the area of the bounding box of the boxes and the lane routes. The function divides it by the area of the bounding box of the boxes.
+ *
+ * It is the room form `area(open) / area(packed)` with the boxes as they are. The scale is a ratio of 1 or more, and lower is better.
+ * A board without area gives 1. The cost is linear.
+ */
+export declare function laneArea(graph: Graph, open: OpenLanes): number;
 /** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
 export declare const PROPOSED_RULES: readonly string[];
 /** The options of `runSuite`. */
@@ -3211,94 +3337,34 @@ export declare const STRETCH_DEFAULTS: Readonly<StretchOptions>;
 export declare function stretchPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StretchOptions>, way?: WayOptions): HighwayPlan;
 /** The gate `stretch` (HWY-048): an edge joins a highway only when its route stays in a budget of its route alone. */
 export declare const stretchGate: Gate<StretchOptions>;
-/** The end of the edges that gets a field: the target of a fan-in, or the source of a fan-out. */
-type FieldEnd = "target" | "source";
-/** The options of the highway strategy `flow-field` (EDA-046 with HWY-037 of the notes). */
-interface FlowFieldOptions extends Pick<WayOptions, "margin" | "k"> {
-  /** An end with this number of edges or more on one side of its box gets a field. The default is 2. */
-  readonly minFanIn: number;
-  /** The end that gets a field. The default is `target`. */
-  readonly end: FieldEnd;
-}
-/** The default options of the strategy `flow-field`. */
-export declare const FLOW_FIELD_DEFAULTS: Readonly<Required<Omit<FlowFieldOptions, "margin" | "k">>>;
-/**
- * This function gives the highways of a flow field for each target (EDA-046, HWY-037).
- * The edges into one side of one box make a fan. The root of the fan is the point out of the median plug of the fan.
- * Each edge of the fan goes the shortest way from the point out of its other plug to the root, through the corner graph.
- * The shortest ways to one root make a tree, so they merge like streams and do not cross. Each stretch that two ways share is one highway.
- * With the end `source`, the same holds for the edges out of one side of one box.
- */
-export declare function flowFieldPlan(input: HighwayInput, o: Readonly<FlowFieldOptions>): HighwayPlan;
-/** The options of the highway strategy `keys`: the options of the router `trunks`, without the name and the limit of the benchmark. */
-type KeysOptions = Omit<TrunksOptions, "name" | "maxNodes">;
-/**
- * This function gives the highways that the router `trunks` decides. A rule gives each edge a key.
- * The edges from one plug with one key share a trunk to a split point. The edges that go on together share a run past it.
- * Each trunk and each run becomes one highway. The function does not change the router: it reads its bundles and its runs.
- */
-export declare function keysPlan(input: HighwayInput, options: KeysOptions): HighwayPlan;
-/**
- * The plan that a post step changes. `none` is the empty plan: `follow` then routes each edge as the router `corners` does.
- * `shared-ways` and `corridors` are the plans of those highway strategies, with their defaults.
- */
-type HighwayBase = "none" | "shared-ways" | "corridors";
-/** The values of `HighwayBase`. */
-export declare const HIGHWAY_BASES: readonly HighwayBase[];
-/** This function gives the plan of a base. */
-export declare function basePlan(input: HighwayInput, base: HighwayBase): HighwayPlan;
-/** The options of the highway strategy `level-links` (HWY-056 with WILD-034 of the notes). */
-interface LevelHighwayOptions {
-  /** The plan of the edges that do not ride a level link. The default is `shared-ways`. */
-  readonly from: HighwayBase;
-  /** The depth of the level in the tree of sections. Depth 1 is the level below the root. The default is 1. */
-  readonly depth: number;
-  /** A level link becomes a highway when this number of edges or more ride it. The default is 2. */
+/** The options of the highway strategy `diffusion` (HWY-020 of the note on highways). */
+interface DiffusionOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The share of the density that each step of the diffusion takes from the links next to a link. The default is 0.25. */
+  readonly a: number;
+  /** The number of steps of the diffusion. The default is 3. */
+  readonly steps: number;
+  /** The weight of the density in the cost of a link. The default is 1. */
+  readonly lambda: number;
+  /** The power of the discount of a dense link. The default is 1. */
+  readonly gamma: number;
+  /** A highway has this number of edges or more. The default is 2. */
   readonly minSize: number;
-  /** An edge rides the link only when its way along the link is this many times its first route, or shorter. The default is 1.5. */
-  readonly stretch: number;
-}
-/** The default options of the strategy `level-links`. */
-export declare const LEVEL_HIGHWAY_DEFAULTS: Readonly<LevelHighwayOptions>;
-/**
- * This function gives a highway for each link of a zoom level, with the edges between its two items (HWY-056, WILD-034).
- * The level is the cut of the tree of sections at `depth`. The link goes around the boxes of the other items (`levelLinks`).
- * The spine is the link without a margin at each end, so it stays off the boxes of the two items. It must stay out of each box.
- * The edges between the two items, in each direction, ride the spine. The ramps go through the corner graph inside the items.
- *
- * An edge rides only when the ramps (as straight lines) and the spine are `stretch` times its first route, or shorter.
- * A link with fewer than `minSize` such edges is not a highway. The other edges keep their highways of the plan `from`.
- * Thus a zoom from the level to the routes shows the same lines, which open into lanes.
- */
-export declare function levelHighwayPlan(input: HighwayInput, o: Readonly<LevelHighwayOptions>): HighwayPlan;
-/** The options of the highway strategy `meet` (HWY-050 of the note on highways). */
-interface MeetOptions {
-  /** The plan whose merge points and split points the strategy moves. The default is `shared-ways`. */
-  readonly from: HighwayBase;
-  /** A first route meets the spine where it is this distance from the spine, or nearer. The default is 8: two lanes of 4. */
-  readonly near: number;
-  /** A first route meets the spine only where it runs at this angle to the spine, or less, in degrees. The default is 45. */
-  readonly maxTurn: number;
-  /** A member keeps its places when the stretch where its first route meets the spine is shorter than this length. The default is 10. */
-  readonly minRun: number;
 }
-/** The default options of the strategy `meet`. */
-export declare const MEET_DEFAULTS: Readonly<MeetOptions>;
+/** The default options of the strategy `diffusion`. */
+export declare const DIFFUSION_DEFAULTS: Readonly<Required<Omit<DiffusionOptions, "margin" | "k">>>;
 /**
- * This function gives a member with its merge point and its split point where its first route meets the spine and parts from it (HWY-050).
- * The function samples the stretch of the member on the spine, at steps of `near / 2` or less.
- * A sample meets the route when the route is `near` or nearer, and its nearest leg runs at `maxTurn` or less to the spine.
- * The new merge point is the first sample that meets the route, in the direction of the member. The new split point is the last one.
- * So the edge joins the spine late and leaves it early. The places only move inward.
- * The member keeps its places when no sample meets the route, or when the met stretch is shorter than `minRun`.
+ * This function gives the density of the edges on the links of the corner graph after the diffusion, as a share of the largest density.
+ * The density of a link starts as the number of first ways on it. Each step mixes it with the mean density of the links that share a corner with it:
+ * `rho_{k+1}(l) = (1 - a) rho_k(l) + a mean(rho_k(l'))`. The key of a link is `i * M + j` for the corners `i < j` of a graph of `M` corners.
  */
-export declare function meetMember(spine: readonly Point[], member: HighwayMember, route: readonly Point[] | undefined, o: Readonly<MeetOptions>): HighwayMember;
+export declare function linkDensity(neighbours: (i: number) => readonly number[], corners: number, use: ReadonlyMap<number, number>, a: number, steps: number): Map<number, number>;
 /**
- * This function gives the highways of the plan `from`, with merge points and split points where the routes meet and part (HWY-050).
- * The first route of each edge is the route of `input.routes`, or its route without highways.
- * Each member gets the places of `meetMember`. The spines and the trips do not change.
+ * This function gives the highways of the route-aware bundling on the corner graph (HWY-020).
+ * The first ways of the edges give the density of each link. A diffusion along the graph smooths it.
+ * Then each edge takes a shortest way where a dense link costs less: `cost(l) = len(l) / (1 + lambda rho(l))^gamma`, with `rho` from 0 to 1.
+ * Each stretch that `minSize` ways or more share after the second pass is one highway. The highways stay on the links of the corner graph.
  */
-export declare function meetPlan(input: HighwayInput, o: Readonly<MeetOptions>): HighwayPlan;
+export declare function diffusionPlan(input: HighwayInput, o: Readonly<DiffusionOptions>): HighwayPlan;
 /**
  * The spine of a group of edges. With `shared`, the edges of each group go through the router `shared` with the group as their key.
  * Each stretch that they share is a highway. With `trunk`, each group gets one trunk between two terminals, with a leg from each plug.
@@ -3334,93 +3400,188 @@ export declare function weberPoint(points: readonly Point[], iterations?: number
  * A terminal is the Weber point of the points out of the plugs at one end of the group. A terminal in a box moves to the nearest of those points.
  */
 export declare function groupedPlan(input: HighwayInput, groups: ReadonlyMap<string, EdgeGroup>, o: Readonly<GroupedOptions>): HighwayPlan;
-/** The options of the highway strategy `od-cells` (EDA-033 with WILD-032 of the notes). */
-interface OdCellOptions {
-  /** The depth of the cells in the tree of sections. Depth 1 is the level below the root. The default is 2. */
-  readonly level: number;
-  /** A pair of cells with this number of edges or more gets a trunk. The default is 3. */
-  readonly minGroup: number;
-  /** An edge rides the trunk only when each of its legs is this share of the span or shorter. The default is 0.3. */
-  readonly legMax: number;
-  /** The spine of each pair of cells. The default is `trunk`. */
+/** The linkage of the hierarchical clustering: the distance of two clusters from the distances of their edges. */
+type Linkage = "average" | "complete" | "single";
+/** The values of `Linkage`. */
+export declare const LINKAGES: readonly Linkage[];
+/** The options of the highway strategy `flow-clusters` (HWY-023 of the note on highways). */
+interface FlowClusterOptions {
+  /** Two clusters join while their distance is this value or less. The distance is a share of the length of the shorter edge. The default is 0.3. */
+  readonly tau: number;
+  /** The linkage. The default is `average`. */
+  readonly linkage: Linkage;
+  /** With `true`, the source of one edge only compares with the source of the other edge. The default is `false`. */
+  readonly directed: boolean;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `trunk`: one flow line from one area to the other area. */
   readonly spine: GroupSpine;
 }
-/** The default options of the strategy `od-cells`. */
-export declare const OD_CELL_DEFAULTS: Readonly<OdCellOptions>;
+/** The default options of the strategy `flow-clusters`. */
+export declare const FLOW_CLUSTER_DEFAULTS: Readonly<FlowClusterOptions>;
 /**
- * This function gives the groups of the edges by the pair of the cells of their two nodes (EDA-033, WILD-032).
- * The cells are the items of the zoom level at the depth `level`. The edges of one pair of cells, in either direction, are one group.
- * An edge inside one cell is in no group.
+ * This function gives the flow distance of two edges (Zhu and Guo 2014): `max(|s_e - s_f|, |t_e - t_f|) / min(len e, len f)`.
+ * Without `directed`, it is the smaller value of the two directions of `f`, and `flip` is `true` when the opposite direction is smaller.
  */
-export declare function odGroups(input: HighwayInput, o: Readonly<OdCellOptions>): Map<string, EdgeGroup>;
+export declare function flowDistance(s1: Point, t1: Point, s2: Point, t2: Point, directed: boolean): {
+  d: number;
+  flip: boolean;
+};
 /**
- * This function gives the highways of the consolidation by origin and destination cells (EDA-033, WILD-032).
- * Carriers merge the loads from one region to another into one truck between two terminals. Thus each pair of cells with `minGroup` edges or more gets one trunk.
- * The terminals are the Weber points of the plugs in each cell. An edge with a leg longer than `legMax` times the span goes alone.
+ * This function clusters the points of a distance matrix with the chain of nearest neighbours. The linkage is reducible, so the chain gives the same tree as the greedy order.
+ * The clusters join while their distance is `tau` or less. The function gives the cluster of each point, as the index of a point of the cluster.
  */
-export declare function odCellPlan(input: HighwayInput, o: Readonly<OdCellOptions>): HighwayPlan;
-/** The line of each edge that QuickBundles compares: its first route, or the straight line between its plugs. */
-type BundleLine = "routes" | "lines";
-/** The order of the edges in the one pass: the order of the graph, or the longest line first. */
-type BundleOrder = "input" | "length";
-/** The options of the highway strategy `quickbundles` (HWY-026 of the note on highways). */
-interface QuickBundlesOptions {
-  /** An edge joins a cluster when its distance to the centroid is this value or less, in units of the board. The default is 3. */
-  readonly theta: number;
-  /** The number of points of each line after the resampling. The default is 12. */
-  readonly points: number;
-  /** The line of each edge. The default is `routes`. */
-  readonly line: BundleLine;
-  /** The order of the edges. The default is `input`, so an added edge does not change the clusters before it. */
-  readonly order: BundleOrder;
-  /** A cluster with this number of edges or more gets highways. The default is 2. */
+export declare function chainClusters(n: number, d: Float64Array, tau: number, linkage: Linkage): Int32Array;
+/**
+ * This function gives the flow clusters of the edges (HWY-023). It clusters the edges as points in 4D, with the cut at `tau`.
+ * Each edge of a cluster gets the key of the cluster. It gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export declare function flowClusters(input: HighwayInput, o: Readonly<FlowClusterOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the flow clusters (HWY-023). The clusters of `flowClusters` with `minSize` edges or more get highways.
+ * With the spine `trunk`, each cluster gets one trunk from one area to the other area. With `shared`, the edges of a cluster share their ways.
+ */
+export declare function flowClusterPlan(input: HighwayInput, o: Readonly<FlowClusterOptions>): HighwayPlan;
+/** The options of the highway strategy `edge-paths` (HWY-012 of the note on highways). */
+interface EdgePathOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** An edge takes a path of other edges only when the path is this many times its own length or less. The default is 2. */
+  readonly distortion: number;
+  /** The weight of a link in the search is its length to this power. A larger power prefers paths of many short links. The default is 2. */
+  readonly power: number;
+  /** A highway has this number of edges or more. The default is 2. */
   readonly minSize: number;
-  /** The spine of each cluster. The default is `shared`. */
+}
+/** The default options of the strategy `edge-paths`. */
+export declare const EDGE_PATH_DEFAULTS: Readonly<Required<Omit<EdgePathOptions, "margin" | "k">>>;
+/** One step of the path of an edge: the edge of the step and `true` when the path goes from its target to its source. */
+interface PathStep {
+  readonly edge: string;
+  readonly back: boolean;
+}
+/**
+ * This function gives the edge paths of the graph (Wallinger and others 2022). The edges go in the order of their lengths, the longest first.
+ * An edge looks for the shortest path of other edges between its nodes, with the weight `length ^ power`. A path is good when its length is `distortion` times the length of the edge or less.
+ * The edges of a good path lock: they keep their own ways. An edge with a good path leaves the graph of the search. The map holds the path of each such edge.
+ */
+export declare function edgePaths(input: HighwayInput, o: Readonly<Pick<EdgePathOptions, "distortion" | "power">>): Map<string, PathStep[]>;
+/**
+ * This function gives the highways of the edge paths (HWY-012). An edge with a good path follows the ways of the edges of its path.
+ * Each edge of the path keeps its own way through the corner graph. So the ways share their links, and each shared stretch is a highway.
+ */
+export declare function edgePathPlan(input: HighwayInput, o: Readonly<EdgePathOptions>): HighwayPlan;
+/** The distance of two edges: 1 less their compatibility of FDEB, or the flow distance in 4D of HWY-023. */
+type EdgeDistance = "compatibility" | "flow";
+/** The values of `EdgeDistance`. */
+export declare const EDGE_DISTANCES: readonly EdgeDistance[];
+/** The options of the highway strategy `hdbscan` (HWY-028 of the note on highways). */
+interface HdbscanOptions {
+  /** A cluster has this number of edges or more. The default is 3. */
+  readonly minClusterSize: number;
+  /** The core distance of an edge is the distance to its neighbour of this rank. The default is 3. */
+  readonly minSamples: number;
+  /** The distance of two edges. The default is `compatibility`. */
+  readonly distance: EdgeDistance;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
   readonly spine: GroupSpine;
 }
-/** The default options of the strategy `quickbundles`. */
-export declare const QUICKBUNDLES_DEFAULTS: Readonly<QuickBundlesOptions>;
-/** This function gives `k` points at equal steps of length along a polyline, from its first point to its last point. */
-export declare function resample(line: readonly Point[], k: number): Point[];
+/** The default options of the strategy `hdbscan`. */
+export declare const HDBSCAN_DEFAULTS: Readonly<HdbscanOptions>;
 /**
- * This function gives the MDF distance of two lines with the same number of points. It is the mean distance of their points.
- * The function compares the points in the same direction and in the opposite direction, and keeps the smaller mean.
- * `flip` is `true` when the opposite direction is smaller.
+ * This function gives the compatibility of two edges of FDEB (Holten and van Wijk 2009): `Ca Cs Cp Cv`, from 0 to 1.
+ * `Ca` is the angle, `Cs` the scale, `Cp` the position and `Cv` the visibility. The direction of an edge does not change the value.
  */
-export declare function mdf(p: readonly Point[], q: readonly Point[]): {
-  d: number;
-  flip: boolean;
-};
+export declare function compatibility(p0: Point, p1: Point, q0: Point, q1: Point): number;
 /**
- * This function gives the clusters of QuickBundles (Garyfallidis 2012) as groups of edges.
- * In one pass, each edge joins the cluster with the nearest centroid when the MDF distance is `theta` units or less. Else it starts a cluster.
- * The centroid is the running mean of the lines of the cluster, each in the direction of the centroid.
+ * This function gives the HDBSCAN clusters of the points of a distance matrix (Campello, Moulavi and Sander 2013). The value -1 is noise.
+ * The core distance of a point is the distance to its `minSamples`-th nearest point. The mutual reachability is `max(core(a), core(b), d(a, b))`.
+ * The minimum spanning tree of the mutual reachability gives the tree of the clusters. A split with two parts of `minClusterSize` or more gives two clusters.
+ * The selection keeps the clusters with the largest stability, `sum (lambda_leave - lambda_birth)`, with `lambda = 1 / distance`. The root is not a cluster.
  */
-export declare function quickBundles(input: HighwayInput, o: Readonly<QuickBundlesOptions>): Map<string, EdgeGroup>;
+export declare function hdbscanLabels(n: number, d: Float64Array, minClusterSize: number, minSamples: number): Int32Array;
 /**
- * This function gives the highways of QuickBundles (HWY-026). The clusters of `quickBundles` with `minSize` edges or more get highways.
- * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
+ * This function gives the HDBSCAN clusters of the edges (HWY-028). The edges that are noise get no group.
+ * Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
  */
-export declare function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan;
-/** The options of the highway strategy `road-classes` (HWY-034 with EDA-050 of the notes). */
-interface RoadClassOptions extends Pick<WayOptions, "margin" | "k"> {
-  /** A link is a highway link when its use is at this quantile of the use of the links, or higher. The default is 0.9. */
-  readonly quantile: number;
-  /** A highway link has this number of edges or more on it, and a highway has this number of edges or more. The default is 2. */
+export declare function hdbscanClusters(input: HighwayInput, o: Readonly<HdbscanOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the HDBSCAN clusters (HWY-028). The clusters that live over a long range of densities are the highways.
+ * The number of highways is not fixed, and the noise edges stay alone.
+ */
+export declare function hdbscanPlan(input: HighwayInput, o: Readonly<HdbscanOptions>): HighwayPlan;
+/** One edge that snaps to a line: the points where it joins and leaves the line, and its place along its own way. */
+interface SnapMember {
+  readonly edge: string;
+  /** The point on the line where the edge joins it. */
+  readonly from: Point;
+  /** The point on the line where the edge leaves it. */
+  readonly to: Point;
+  /** The place of the join along the edge, from 0 at the source to 1 at the target. It orders the highways of one edge. */
+  readonly at: number;
+}
+/** A straight line that a finder gives as the place of a highway, with the edges that snap to it. */
+interface SnapLine {
+  readonly key: string;
+  readonly a: Point;
+  readonly b: Point;
+  readonly members: readonly SnapMember[];
+}
+/** The options of `snapPlan`. */
+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;
-  /** The second pass gives each highway link this discount, as a share of its length. The default is 0.5. */
-  readonly discount: number;
 }
-/** The default options of the strategy `road-classes`. */
-export declare const ROAD_CLASS_DEFAULTS: Readonly<Required<Omit<RoadClassOptions, "margin" | "k">>>;
+/** 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;
+/**
+ * This function gives the highways of straight lines in the free space. Each line becomes a spine through the corner graph between its two ends.
+ * An end inside a box moves to the nearest corner of the graph.
+ * Each member joins the spine at the place nearest to its point `from`, and leaves it at the place nearest to its point `to`.
+ * A member whose part of the spine is shorter than the margin does not ride. A spine with fewer than `minSize` members is not a highway.
+ * An edge on several highways takes them in the order of `at`.
+ */
+export declare function snapPlan(input: HighwayInput, lines: readonly SnapLine[], o: Readonly<SnapOptions>): HighwayPlan;
+/** This function gives the points of a spine from the place `on` to the place `off`, backward when `on` is larger. */
+export declare function spinePart(spine: readonly Point[], on: number, off: number): Point[];
+/** The options of the highway strategy `hough` (HWY-024 of the note on highways). */
+interface HoughOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The width of the votes in the angle, in degrees. An edge joins a peak within this angle. The default is 8. */
+  readonly dTheta: number;
+  /** The width of the votes in the offset, in units of the board. An edge joins a peak when its middle is this near to the line. The default is 12. */
+  readonly dRho: number;
+  /** A peak with fewer edges than this number is not a corridor. The default is 3. */
+  readonly minVotes: number;
+  /** With `true`, the peaks are only horizontal or vertical lines. The default is `false`. */
+  readonly orthogonal: boolean;
+}
+/** The default options of the strategy `hough`. */
+export declare const HOUGH_DEFAULTS: Readonly<Required<Omit<HoughOptions, "margin" | "k">>>;
+/** A peak of the votes: its angle, its offset and the sum of its votes. */
+interface HoughPeak {
+  readonly theta: number;
+  readonly rho: number;
+  readonly votes: number;
+}
 /**
- * This function gives the highways of the road classes (HWY-034, EDA-050). It counts how many first ways use each link of the corner graph.
- * The links with a use at the quantile `quantile` or higher, and at least `minSize`, are the highway links.
- * They are the main roads of a road map.
- * A second pass routes each edge again, with the discount on the highway links, so more edges join them.
- * Each stretch of highway links that `minSize` ways or more share after the second pass is one highway.
+ * This function gives the peaks of the votes of the lines (Duda and Hart 1972). Each line votes for its angle and its offset, with a weight of its length.
+ * A vote spreads as a Gaussian with the widths `dTheta / 2` and `dRho / 2`. The accumulator has bins of 1 degree and of `dRho / 4`.
+ * A peak is a bin with a larger sum than each other bin within `dTheta` and `dRho`. The peaks come in the order of their votes.
  */
-export declare function roadClassPlan(input: HighwayInput, o: Readonly<RoadClassOptions>): HighwayPlan;
+export declare function houghPeaks(lines: readonly {
+  theta: number;
+  mid: Point;
+  len: number;
+}[], o: Readonly<Pick<HoughOptions, "dTheta" | "dRho" | "orthogonal">>): HoughPeak[];
+/**
+ * This function gives the corridors of the votes (HWY-024). Each edge joins the first peak with an angle within `dTheta` and its middle within `dRho` of the line.
+ * The corridor runs over the common span of the projections of its edges on the line. Each edge snaps to the ends of that span.
+ * A member that makes the span shorter than four margins leaves, while the peak keeps `minVotes` edges.
+ */
+export declare function houghLines(input: HighwayInput, o: Readonly<HoughOptions>): SnapLine[];
+/**
+ * This function gives the highways of the Hough votes (HWY-024). The peaks of the votes of the straight lines of the edges are corridors.
+ * Each corridor is a spine through the corner graph, and its edges ride it over their common span.
+ */
+export declare function houghPlan(input: HighwayInput, o: Readonly<HoughOptions>): HighwayPlan;
 /** A generator of candidate highways: a highway strategy with its defaults. */
 type CandidateSource = "corridors" | "quickbundles" | "wspd" | "road-classes" | "flow-field" | "od-cells" | "shared-ways";
 /** The values of `CandidateSource`. */
@@ -3455,41 +3616,1458 @@ export declare function candidateScore(h: Highway, routes: ReadonlyMap<string, r
  * swaps in a candidate. The swap occurs when the net gain of the candidate is more than the sum of the selected candidates in conflict with it.
  */
 export declare function selectPlan(input: HighwayInput, o: Readonly<SelectOptions>): HighwayPlan;
-/** The options of the highway strategy `shared-ways`: the options of the router `shared`, without the name and the limit of the benchmark. */
-type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
-/**
- * This function gives the highways that the router `shared` decides. The edges of one key go one by one through the corner graph.
- * A link that the key uses already costs less, so the ways of a key come together. Each stretch that two edges or more share becomes one highway.
- * The function does not change the router: it reads its runs.
- */
-export declare function sharedWaysPlan(input: HighwayInput, options: SharedWaysOptions): HighwayPlan;
-/** The ends of the edges that get stubs: the source ends, the target ends, or both. */
-type StubEnds = "source" | "target" | "both";
-/** The options of the highway strategy `stubs` (HWY-015 with WILD-005 of the notes). */
-interface StubOptions {
-  /** The plan that the stubs go into. The default is `shared-ways`. */
-  readonly from: HighwayBase;
-  /** The ends of one side of a box whose directions are in a window of this angle share a stub, in degrees. The default is 30. */
-  readonly omega: number;
-  /** The length of a stub is this share of the distance to the nearest other end. The default is 0.25. */
-  readonly sigma: number;
-  /** The ends that get stubs. The default is `both`. */
-  readonly ends: StubEnds;
-  /** A stub has this number of edges or more. The default is 2. */
+/** A generator of candidate arcs: `runs` (the shared stretches of the first ways of all edges) or a generator of the strategy `select`. */
+type ArcSource = "runs" | CandidateSource;
+/** The values of `ArcSource`. */
+export declare const ARC_SOURCES: readonly ArcSource[];
+/** The options of the highway strategy `hub-arcs` (HWY-042 of the note on highways). */
+interface HubArcOptions {
+  /** The largest number of arcs (highways). The default is 12. */
+  readonly q: number;
+  /** The cost of a length on an arc against a length off the arcs, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** An edge rides an arc only when its legs plus its part of the arc are this many times its first route or less. The default is 1.25. */
+  readonly stretch: number;
+  /** The number of passes of the local search with one swap. The default is 1. */
+  readonly swaps: number;
+  /** An arc with fewer edges than this number is not a highway. The default is 2. */
   readonly minSize: number;
+  /** The generators of the candidate arcs. The default is `runs`, `corridors` and `road-classes`. */
+  readonly generators: readonly ArcSource[];
 }
-/** The default options of the strategy `stubs`. */
-export declare const STUB_DEFAULTS: Readonly<StubOptions>;
+/** The default options of the strategy `hub-arcs`. */
+export declare const HUB_ARC_DEFAULTS: Readonly<HubArcOptions>;
+/** This function gives the candidate arcs: the spines of the plans of the generators, without the copies, with the longest first. */
+export declare function candidateArcs(input: HighwayInput, generators: readonly ArcSource[]): Point[][];
 /**
- * This function gives the highways of the plan `from`, with a stub at the ends of the edges (HWY-015, WILD-005).
- * The ends on one side of one box are sorted by the direction of their other node. A run of ends in a window of `omega` makes a group.
- * Each group of `minSize` ends or more shares one plug and one stub along the normal of the side. Then the edges fan out.
- *
- * The length of the stub is `sigma` times the distance to the nearest other node, and half that distance at most.
+ * This function gives the highways of the hub arc location (Campbell, Ernst and Krishnamoorthy 2005). It chooses at most `q` arcs from the candidates.
+ * An edge on an arc costs its two legs plus `alpha` times its part of the arc. An edge off the arcs costs its first route.
+ * The greedy step adds the arc that saves the most cost. Then each swap pass changes one chosen arc for one other arc while the saving grows.
+ * Each edge rides the arc that saves the most for it.
+ */
+export declare function hubArcPlan(input: HighwayInput, o: Readonly<HubArcOptions>): HighwayPlan;
+/**
+ * The plan that a post step changes. `none` is the empty plan: `follow` then routes each edge as the router `corners` does.
+ * `shared-ways` and `corridors` are the plans of those highway strategies, with their defaults.
+ */
+type HighwayBase = "none" | "shared-ways" | "corridors";
+/** The values of `HighwayBase`. */
+export declare const HIGHWAY_BASES: readonly HighwayBase[];
+/** This function gives the plan of a base. */
+export declare function basePlan(input: HighwayInput, base: HighwayBase): HighwayPlan;
+/** The side of the road that the traffic keeps to. */
+type TrafficRule = "right" | "left";
+/** The values of `TrafficRule`. */
+export declare const TRAFFIC_RULES: readonly TrafficRule[];
+/** The options of the highway strategy `divided` (HWY-011 of the notes). */
+interface DividedOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that the strategy divides. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The side of the road of the traffic. With `right`, the edges of each direction keep to the right of the spine. The default is `right`. */
+  readonly rule: TrafficRule;
+  /** The gap between the two carriageways, in lanes. The default is 1. */
+  readonly gap: number;
+  /** The width of one lane, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** A highway divides only when each direction has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `divided`. */
+export declare const DIVIDED_DEFAULTS: Readonly<Required<Omit<DividedOptions, "margin" | "k">>>;
+/**
+ * This function gives the polyline at the distance `offset` from `line`, with the same number of points. A positive offset is on the right of the line.
+ * The y axis points down, so the right of the direction `(dx, dy)` is `(-dy, dx)`. Each inner point moves along the bisector of its two legs (a miter join).
+ */
+export declare function offsetLine(line: readonly Point[], offset: number): Point[];
+/**
+ * This function divides one highway into two carriageways, one for each direction (HWY-011, divided edge bundling of Selassie, Heller and Heer 2011).
+ * Each carriageway is a copy of the spine at an offset to the side of its traffic. The offset is half the lanes of that side plus half the gap.
+ * When an offset spine is not clear of the boxes, the function tries one half and one quarter of the offset. It gives `undefined` when none fits.
+ */
+export declare function divideHighway(h: Highway, finder: WayFinder, o: Readonly<Omit<DividedOptions, "from" | "margin" | "k">>): Highway[] | undefined;
+/**
+ * This function gives the highways of the plan `from`, with each highway of two-way traffic divided into two carriageways (HWY-011).
+ * The edges of each direction get their own spine on the side of the rule `rule`. Thus the two directions do not cross in the lanes.
+ * A highway with fewer than `minSize` edges in one direction, or without the room for the offsets, stays as it is.
+ */
+export declare function dividedPlan(input: HighwayInput, o: Readonly<DividedOptions>): HighwayPlan;
+/** The trees of sections that the strategy `hierarchy` can use. */
+type HierarchyGroups = "quadtree" | "kd" | "cut";
+/** The values of `HierarchyGroups`. */
+export declare const HIERARCHY_GROUPS: readonly HierarchyGroups[];
+/** The options of the highway strategy `hierarchy` (HWY-001 of the notes). */
+interface HierarchyOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The tree of sections. The default is `quadtree`. */
+  readonly group: HierarchyGroups;
+  /** A section with more nodes splits. The default is 8. */
+  readonly cap: number;
+  /** The pull of the hubs, from 0 to 1 (Holten 2006). The value 0 gives the straight line, and 1 goes through each hub. The default is 0.85. */
+  readonly beta: number;
+  /** The largest number of hubs on each side of the lowest common section. `Infinity` uses all of them. The default is `Infinity`. */
+  readonly hubs: number;
+  /** The side of the grid that the hubs snap to, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `hierarchy`. */
+export declare const HIERARCHY_DEFAULTS: Readonly<Required<Omit<HierarchyOptions, "margin" | "k">>>;
+/**
+ * This function gives the control points of one edge. They are the sections from the leaf of the source up to the lowest common section, then down to the target leaf.
+ * The lowest common section is not in the chain (Holten 2006), so the edges do not all meet at the hub of the root.
+ * `hubs` limits the sections on each side. The sections nearest to the common section stay.
+ */
+export declare function controlChain(from: readonly Section[], to: readonly Section[], hubs: number): Section[];
+/**
+ * This function gives the highways of the hierarchical edge bundling (HWY-001, Holten 2006).
+ * The tree of sections gives a hub to each section. Each edge goes near the hubs of the sections between its two leaves.
+ * The waypoint of a hub is `beta hub + (1 - beta) p`, with `p` the point of the straight line at the same share of the chain.
+ * The waypoints snap to a grid of side `snap`, and the ways go through the corner graph. The stretches that `minSize` ways share become highways.
+ */
+export declare function hierarchyPlan(input: HighwayInput, o: Readonly<HierarchyOptions>): HighwayPlan;
+/** The options of the highway strategy `fdeb` (HWY-002 with RULE-002 of the notes). */
+interface FdebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two edges attract each other when their compatibility is this value or more. The default is 0.6. */
+  readonly compatibility: number;
+  /** The spring constant that keeps each edge smooth. The default is 0.1. */
+  readonly spring: number;
+  /** The number of cycles. Each cycle doubles the points of each edge and halves the step. The default is 5. */
+  readonly cycles: number;
+  /** The number of steps of the first cycle. Each later cycle has two thirds of the steps of the cycle before it. The default is 50. */
+  readonly iterations: number;
+  /** The weight of the push of the boxes (RULE-002). The value 0 turns it off. The default is 1. */
+  readonly repulsion: number;
+  /**
+   * The stretch budget of each edge (RULE-002). An edge whose polyline is longer than this value times its straight line gets no pull.
+   * `Infinity` sets no budget. The default is 1.25.
+   */
+  readonly pullLimit: number;
+  /** The side of the grid that the points of the edges snap to after the cycles, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `fdeb`. */
+export declare const FDEB_DEFAULTS: Readonly<Required<Omit<FdebOptions, "margin" | "k">>>;
+/**
+ * This function gives the polylines of the force-directed edge bundling (HWY-002, Holten and van Wijk 2009), with the box field of RULE-002.
+ * Each edge starts as the straight line between its two points out of the plugs. Each cycle doubles its points.
+ * In each step, a point moves by `step` times the mean pull to the matching points of its partners. The springs to its two neighbours also move it.
+ * The boxes push the points, and after each cycle a point in a box moves out of it. An edge over its stretch budget gets no pull in that step.
+ */
+export declare function fdebLines(input: HighwayInput, finder: WayFinder, o: Readonly<FdebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the force-directed edge bundling (HWY-002 with RULE-002).
+ * The points of the bundled polylines snap to a grid of side `snap`, so the points of one bundle come together.
+ * Each edge then goes through its points along the corner graph, and the stretches that `minSize` edges share become highways.
+ */
+export declare function fdebPlan(input: HighwayInput, o: Readonly<FdebOptions>): HighwayPlan;
+/** The options of the highway strategy `mesh` (HWY-004 of the notes). */
+interface MeshOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The side of a cell of the mesh, in units of the boxes: the median of the smaller side of each box. The default is 4. */
+  readonly cell: number;
+  /** A cluster of crossings on one segment of the mesh has at most about this number of edges. The default is 8. */
+  readonly capacity: number;
+  /** Two clusters nearer than this value, in units of the boxes, become one. The default is 1. */
+  readonly merge: number;
+  /** The largest angle in degrees between a line and the main direction of a cell. A line with a larger angle does not cross the mesh there. The default is 45. */
+  readonly angle: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `mesh`. */
+export declare const MESH_DEFAULTS: Readonly<Required<Omit<MeshOptions, "margin" | "k">>>;
+/** This function gives the median of the smaller side of each box of the graph, or 1 for a graph without boxes. */
+export declare function boxUnit(graph: Graph): number;
+/** This function gives the clusters of the values by a 1D k-means with `k` centres, then joins the centres nearer than `merge`. The result gives the centre of each value. */
+export declare function clusters1d(values: readonly number[], k: number, merge: number): number[];
+/**
+ * This function gives the waypoints of the control mesh (HWY-004, GBEC of Cui, Zhou, Qu, Wong and Li 2008).
+ * A grid of cells covers the board. The main direction of each cell is the peak of a histogram of the angles of the straight lines through it.
+ * The segment of the mesh in a cell goes through its middle, across that direction. The crossings of the lines with the segment form clusters by a 1D k-means.
+ * The centre of the cluster of each crossing is a waypoint of its edge. The waypoints of an edge are in the order of the edge.
+ */
+export declare function meshWaypoints(input: HighwayInput, finder: WayFinder, o: Readonly<MeshOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the control mesh (HWY-004). Each edge goes through the centres of its clusters on the mesh, along the corner graph.
+ * The centres of one cluster are one point, so the edges of a cluster share the ways between them. The stretches that `minSize` ways share become highways.
+ */
+export declare function meshPlan(input: HighwayInput, o: Readonly<MeshOptions>): HighwayPlan;
+/**
+ * The way to compute the density from the sample points. `direct` adds a Gaussian at each sample point (KDEEB).
+ * `separable` counts the points in the cells and blurs the counts along x, then along y (CUBu). `fft` blurs the counts with a product of Fourier transforms (FFTEB).
+ */
+type DensityKernel = "direct" | "separable" | "fft";
+/** The values of `DensityKernel`. */
+export declare const DENSITY_KERNELS: readonly DensityKernel[];
+/** The lines that make the first density: the straight lines of the edges, or their first routes. */
+type DensitySource = "lines" | "routes";
+/** The options of the highway strategy `kdeeb` (RULE-028 with HWY-006 of the notes). */
+interface KdeebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The lines of the first density. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The side of a cell of the density image, in units of the board. The default is 8. A large board gets larger cells, up to 512 cells on a side. */
+  readonly cell: number;
+  /** The width of the kernel at the first step, in units of the board. The default is 24. */
+  readonly bandwidth: number;
+  /** Each step multiplies the width of the kernel by this value. The default is 0.7. */
+  readonly decay: number;
+  /** The number of steps. The default is 10. */
+  readonly steps: number;
+  /** The share of the Laplacian smoothing of each polyline after each step, from 0 to 1. The default is 0.5. */
+  readonly smoothing: number;
+  /** With this option, the density is 0 in the boxes, so no ridge forms over a box (RULE-028). The default is `true`. */
+  readonly mask: boolean;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `kdeeb`. */
+export declare const KDEEB_DEFAULTS: Readonly<Required<Omit<KdeebOptions, "margin" | "k">>>;
+/** The settings of the advection that the strategies `kdeeb` and `cubu` share. */
+interface AdvectionSettings {
+  /** The way to compute the density. */
+  readonly kernel: DensityKernel;
+  /** The spacing of the sample points after each step, in units of the board. The value 0 keeps the points where they are. */
+  readonly resample: number;
+}
+/** A grid of cells over the board: its size, the side of a cell, and the place of its first cell. */
+interface DensityGrid {
+  readonly w: number;
+  readonly h: number;
+  readonly cell: number;
+  readonly x0: number;
+  readonly y0: number;
+}
+/** This function gives the fast Fourier transform of a row of `n` complex values in place, with `n` a power of 2. `inverse` gives the inverse without the division by `n`. */
+export declare function fft(re: Float64Array, im: Float64Array, inverse?: boolean): void;
+/** This function gives the density of the points on the grid with the kernel `kernel` of the width `bandwidth` in units of the board. */
+export declare function pointDensity(points: readonly Point[], g: DensityGrid, bandwidth: number, kernel: DensityKernel): Float64Array;
+/**
+ * This function gives the polylines of the density bundling (KDEEB, Hurter, Ersoy and Telea 2012). The ends of each polyline stay.
+ * In each step, the sample points of all edges make a density. Each inner point moves `h / 4` up the gradient of the density, with `h` the width of the kernel.
+ * The width then shrinks by `decay`, so the edges gather into ridges. A Laplacian smoothing keeps each polyline smooth.
+ * With `mask`, the density is 0 in the boxes (RULE-028), and a point in a box moves out of it.
+ */
+export declare function kdeebLines(input: HighwayInput, finder: WayFinder, o: Readonly<KdeebOptions>, settings: Readonly<AdvectionSettings>): Map<string, Point[]>;
+/** This function gives the highways of the bundled polylines of `kdeebLines`. The points snap to a grid of side `snap`, and the ways go through the corner graph. */
+export declare function densityPlan(input: HighwayInput, o: Readonly<KdeebOptions>, settings: Readonly<AdvectionSettings>, key: string): HighwayPlan;
+/**
+ * This function gives the highways of the density bundling with a mask of the free space (RULE-028 with HWY-006).
+ * The kernel is direct: each sample point adds a Gaussian. The final ridges of the polylines become the highways.
+ */
+export declare function kdeebPlan(input: HighwayInput, o: Readonly<KdeebOptions>): HighwayPlan;
+/** The options of the highway strategy `cubu` (HWY-007 of the notes). */
+interface CubuOptions extends KdeebOptions {
+  /** The way to compute the density: `separable` (CUBu) or `fft` (FFTEB). The default is `separable`. */
+  readonly kernel: Exclude<DensityKernel, "direct">;
+  /** The spacing of the sample points after each step, in units of the board. The value 0 keeps the points. The default is 8. */
+  readonly resample: number;
+}
+/** The default options of the strategy `cubu`. */
+export declare const CUBU_DEFAULTS: Readonly<Required<Omit<CubuOptions, "margin" | "k">>>;
+/**
+ * This function gives the highways of the fast density bundling (HWY-007: CUBu of van der Zwan, Codreanu and Telea 2016, and FFTEB of Lhuillier, Hurter and Telea 2017).
+ * The steps are those of `kdeeb`, with the mask of the boxes. The density comes from the counts of the cells, blurred by a separable kernel or by a Fourier transform.
+ * The sample points of each edge are spaced again after each step.
+ */
+export declare function cubuPlan(input: HighwayInput, o: Readonly<CubuOptions>): HighwayPlan;
+/** The local fit of the moving least squares: a line, or a parabola in the frame of the line. */
+type MlsFit = "line" | "parabola";
+/** The values of `MlsFit`. */
+export declare const MLS_FITS: readonly MlsFit[];
+/** The options of the highway strategy `mlseb` (HWY-008 of the notes). */
+interface MlsebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the fit at the first step, as a multiple of `boardUnit`: the median short side of the boxes. The default is 2. */
+  readonly radius: number;
+  /** Each step multiplies the radius by this value. The default is 0.8. */
+  readonly decay: number;
+  /** The number of steps. The default is 6. */
+  readonly steps: number;
+  /** The local fit. The default is `line`. */
+  readonly fit: MlsFit;
+  /** The weight of the angle, from 0 to 1. With 1, a sample at a right angle to the point has no weight. The default is 1. */
+  readonly angleWeight: number;
+  /** The spacing of the sample points of each edge, in units of the board. The default is 8. */
+  readonly spacing: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `mlseb`. */
+export declare const MLSEB_DEFAULTS: Readonly<Required<Omit<MlsebOptions, "margin" | "k">>>;
+/** One sample point of an edge, with the unit tangent of its edge there. */
+interface Sample {
+  readonly p: Point;
+  readonly tx: number;
+  readonly ty: number;
+}
+/**
+ * This function gives the point of the moving least squares fit at the point `p`. The weight of a sample `q` is `exp(-|q-p|^2 / r^2)`.
+ * The angle term multiplies it by `1 - a + a |cos|`, with `cos` the cosine of the angle between the two tangents.
+ * The fit `line` gives the projection of `p` on the weighted line of the samples. The fit `parabola` fits `s = c0 + c1 t + c2 t^2` in the frame of that line.
+ * Without weight, the function gives `p`.
+ */
+export declare function mlsPoint(p: Point, t: {
+  tx: number;
+  ty: number;
+}, near: readonly Sample[], r: number, angleWeight: number, fit: MlsFit): Point;
+/**
+ * This function gives the polylines of the moving least squares bundling (MLSEB, Wu, Zeng, Zhu and Yu 2017). The ends of each polyline stay.
+ * In each step, each inner point moves to the local fit of the samples of all edges within the radius. Then the radius shrinks by `decay`.
+ * A move is at most the radius. A point in a box moves out of it.
+ */
+export declare function mlsebLines(input: HighwayInput, finder: WayFinder, o: Readonly<MlsebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the moving least squares bundling (HWY-008). The points of `mlsebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export declare function mlsebPlan(input: HighwayInput, o: Readonly<MlsebOptions>): HighwayPlan;
+/** The clusterer that gives the groups of edges: QuickBundles (HWY-026) with its defaults, or the collection of each edge. */
+type SkeletonGroups = "quickbundles" | "keys";
+/** The values of `SkeletonGroups`. */
+export declare const SKELETON_GROUPS: readonly SkeletonGroups[];
+/** The point that each sample point moves toward: the nearest point of the skeleton of its group, or of the mean polyline of its group. */
+type SkeletonTarget = "skeleton" | "mean";
+/** The values of `SkeletonTarget`. */
+export declare const SKELETON_TARGETS: readonly SkeletonTarget[];
+/** The options of the highway strategy `sbeb` (HWY-009 of the notes). */
+interface SbebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The share of the distance to the target that a point moves in one step, from 0 to 1. The default is 0.5. */
+  readonly attraction: number;
+  /** The number of steps. The default is 4. */
+  readonly steps: number;
+  /** The share of the Laplacian smoothing of each polyline after each step, from 0 to 1. The default is 0.5. */
+  readonly smoothing: number;
+  /** The target of the points. The default is `skeleton`. */
+  readonly target: SkeletonTarget;
+  /** The side of a cell of the image of the shape, in units of the board. A large shape gets larger cells, up to 256 cells on a side. The default is 4. */
+  readonly cell: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A group with this number of edges or more moves, and a highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `sbeb`. */
+export declare const SBEB_DEFAULTS: Readonly<Required<Omit<SbebOptions, "margin" | "k">>>;
+/** This function gives the group of each edge: the clusters of QuickBundles, or the collection of the edge. An edge without a collection has no group with `keys`. */
+export declare function skeletonGroups(input: HighwayInput, group: SkeletonGroups): Map<string, EdgeGroup>;
+/** This function gives the first line of each edge. The line goes from a point at `margin` out of the source plug to a point at `margin` out of the target plug. */
+export declare function firstLines(input: HighwayInput, finder: WayFinder, source: DensitySource, spacing: number): Map<string, Point[]>;
+/** The image of the shape of a group and its skeleton. */
+interface ShapeSkeleton {
+  readonly grid: DensityGrid;
+  /** The distance of each cell to the nearest cell outside the shape, in cells. A cell outside the shape has 0. */
+  readonly depth: Float64Array;
+  /** The value is 1 for each cell of the skeleton. */
+  readonly skeleton: Uint8Array;
+}
+/**
+ * This function gives the shape of a group and its skeleton (its medial axis). The shape is the union of the disks of radius `radius` along the lines, minus the boxes.
+ * The depth is a chamfer distance transform with the steps 1 and √2. A cell is on the skeleton when two conditions are true.
+ * Its depth is half of `radius` or more. Its depth is a ridge along one of the four pairs of opposite neighbours.
+ * A ridge is not lower than the two neighbours, and it is higher than one of them.
+ */
+export declare function shapeSkeleton(lines: readonly (readonly Point[])[], finder: WayFinder, radius: number, cell: number): ShapeSkeleton;
+/** This function gives the middle of the skeleton cell nearest to `p`, within `reach` in units of the board, or `undefined`. */
+export declare function nearestSkeleton(s: ShapeSkeleton, p: Point, reach: number): Point | undefined;
+/** This function gives the mean polyline of lines in one direction, with `k` points. */
+export declare function meanLine(lines: readonly (readonly Point[])[], k: number): Point[];
+/** This function gives the point of a polyline nearest to `p`. */
+export declare function nearestOnLine(line: readonly Point[], p: Point): Point;
+/** This function gives the groups with `min` edges or more, as lists of edges. The groups are in the order of their first edges. */
+export declare function bigGroups(groups: ReadonlyMap<string, EdgeGroup>, min: number): {
+  key: string;
+  edges: {
+    edge: string;
+    flip: boolean;
+  }[];
+}[];
+/**
+ * This function gives the polylines of the skeleton-based edge bundling (SBEB, Ersoy, Hurter, Paulovich, Cantareiro and Telea 2011). The ends of each polyline stay.
+ * In each step, each group of `minSize` edges or more draws its shape, and each inner point moves the share `attraction` toward its target.
+ * The share falls to 0 at the distance `2 radius`. A Laplacian smoothing keeps each polyline smooth, and a point in a box moves out of it.
+ * The edges outside such a group do not move.
+ */
+export declare function sbebLines(input: HighwayInput, finder: WayFinder, o: Readonly<SbebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the skeleton-based edge bundling (HWY-009). The points of `sbebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export declare function sbebPlan(input: HighwayInput, o: Readonly<SbebOptions>): HighwayPlan;
+/** The rule of the half width of an area: the spread of the edges of the group, or the number of its lanes. */
+type AreaWidth = "spread" | "count";
+/** The values of `AreaWidth`. */
+export declare const AREA_WIDTHS: readonly AreaWidth[];
+/** The options of the highway strategy `areas` (HWY-010 of the notes). */
+interface AreaOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The lines of the edges that make the shape: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The rule of the half width of the area. The default is `spread`. */
+  readonly width: AreaWidth;
+  /** The width of one lane for the rule `count`, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** The side of a cell of the image of the shape, in units of the board. The default is 4. */
+  readonly cell: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `areas`. */
+export declare const AREA_DEFAULTS: Readonly<Required<Omit<AreaOptions, "margin" | "k">>>;
+/**
+ * This function gives the longest path of the largest part of a skeleton, as the middles of its cells. The neighbours of a cell are its 8 neighbours.
+ * The function finds the cell farthest from a first cell, then the cell farthest from that cell. A skeleton without cells gives an empty list.
+ */
+export declare function skeletonPath(s: ShapeSkeleton): Point[];
+/**
+ * This function gives the highways of the image-based edge bundles (HWY-010, Telea and Ersoy 2010). Each group of edges is one area with one spine.
+ * The spine goes through the corner graph between the two ends of the longest path of the skeleton of the shape of the group.
+ * The area is the skeleton path with a half width. With `spread`, the half width is the 90th percentile of the distances of the points to the path.
+ * With `count`, it is the number of lanes times half of `laneWidth`. The half width is at least the margin.
+ * An edge joins the spine where its line first goes into the area. It leaves the spine where its line last comes out of the area.
+ */
+export declare function areaPlan(input: HighwayInput, o: Readonly<AreaOptions>): HighwayPlan;
+/** The edges that one group can hold: the edges of one collection, or each edge. */
+type GroupScope = "collection" | "all";
+/** The values of `GroupScope`. */
+export declare const GROUP_SCOPES: readonly GroupScope[];
+/** The options of the highway strategy `confluent` (HWY-013 of the notes). */
+interface ConfluentOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A biclique `K(A, B)` becomes a track when `|A| |B|` is this value or more. The default is 4. */
+  readonly minBiclique: number;
+  /** The edges of one track. With `collection`, a track holds the edges of one collection, and an edge without a collection is on no track. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each track. The default is `trunk`: one trunk from the merge junction to the split junction. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+/** The default options of the strategy `confluent`. */
+export declare const CONFLUENT_DEFAULTS: Readonly<Required<Omit<ConfluentOptions, "margin" | "k">>>;
+/** The edges between pairs of nodes of one scope: for each node, its neighbours and the edges to each of them. */
+interface NodeLinks {
+  /** The key of the scope. */
+  readonly key: string;
+  /** For each node, the edges to each neighbour, by the id of the neighbour. */
+  readonly links: Map<string, Map<string, string[]>>;
+}
+/** This function gives the links of each scope. A loop (an edge from a node to itself) is not a link. The order of the maps follows the order of the edges. */
+export declare function nodeLinks(graph: Graph, scope: GroupScope): NodeLinks[];
+/** A biclique: the two sets of nodes, with a link from each node of `a` to each node of `b`. */
+interface Biclique {
+  readonly a: readonly string[];
+  readonly b: readonly string[];
+}
+/**
+ * This function gives the bicliques of a greedy search (HWY-013). Each search starts at one node `x` with `A = {x}` and `B` its neighbours.
+ * It then adds to `A` the node that gives the largest `|A| |B|`, with `B` cut to the common neighbours, while the product grows.
+ * The best biclique of all starts with `|A| |B| >= min` becomes a track, its links go away, and the search repeats.
+ * The nodes of `A` and `B` are apart. The largest set is `b`.
+ */
+export declare function greedyBicliques(links: Map<string, Map<string, string[]>>, min: number): Biclique[];
+/**
+ * This function gives the group of each edge of a set of bicliques. The edges of one biclique are one group, with the key `<prefix><scope>/<index>`.
+ * An edge from a node of `b` to a node of `a` has `flip`. Thus each trunk goes from the side `a` to the side `b`.
+ */
+export declare function bicliqueGroups(graph: Graph, scope: NodeLinks, bicliques: readonly Biclique[], prefix: string, into: Map<string, EdgeGroup>): void;
+/**
+ * This function gives the highways of the confluent drawing (HWY-013, Dickerson, Eppstein, Goodrich and Meng 2005).
+ * Each biclique `K(A, B)` of the greedy search is one track. The track merges the edges near the side `A` and splits them near the side `B`.
+ * The junctions are the Weber points of the ends, as in the spine `trunk` of `groupedPlan`.
+ */
+export declare function confluentPlan(input: HighwayInput, o: Readonly<ConfluentOptions>): HighwayPlan;
+/** The rule of a module: the nodes with the same neighbours (`exact`), or with near neighbours by the Jaccard index (`near`). */
+type ModuleRule = "exact" | "near";
+/** The values of `ModuleRule`. */
+export declare const MODULE_RULES: readonly ModuleRule[];
+/** The options of the highway strategy `power` (HWY-014 of the notes). */
+interface PowerOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The rule of the modules. The default is `exact`. */
+  readonly modules: ModuleRule;
+  /** With the rule `near`, a node joins a module at this Jaccard index or more with the first node of the module. The default is 0.8. */
+  readonly jaccard: number;
+  /** A power edge saves the number of its edges less 1. It becomes a highway when it saves this number of edges or more. The default is 2. */
+  readonly minSaved: number;
+  /** The edges of one power edge. With `collection`, a power edge holds the edges of one collection. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each power edge. The default is `trunk`. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+/** The default options of the strategy `power`. */
+export declare const POWER_DEFAULTS: Readonly<Required<Omit<PowerOptions, "margin" | "k">>>;
+/** This function gives the Jaccard index of two sets: the size of their common part over the size of their union. Two empty sets give 1. */
+export declare function jaccardIndex(a: ReadonlySet<string>, b: ReadonlySet<string>): number;
+/**
+ * This function gives the module of each node. With `exact`, the nodes with the same set of neighbours are one module.
+ * With `near`, the nodes go in the order of their degree, the largest first. A node joins the first module whose first node has a Jaccard index of `jaccard` or more with it.
+ * The function gives the modules as lists of nodes, each in the order of the ids.
+ */
+export declare function modulesOf(links: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>, rule: ModuleRule, jaccard: number): string[][];
+/**
+ * This function gives the highways of the edge compression with modules and power graphs (HWY-014, Dwyer, Henry Riche, Marriott and Mears 2013).
+ * The edges between two modules are one power edge. With modules of the rule `exact`, each node of one module links to each node of the other.
+ * A power edge that saves `minSaved` edges or more is one highway from module to module.
+ * Its trunk goes between the Weber points of the two ends.
+ * The search does not nest modules, so it finds no power edge inside a power edge.
+ */
+export declare function powerPlan(input: HighwayInput, o: Readonly<PowerOptions>): HighwayPlan;
+/** The options of the highway strategy `crossbars` (HWY-022 of the notes). */
+interface CrossbarOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that gets the bundled crossings. Only the edges outside its highways can be on a crossbar. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two segments are parallel when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly tolerance: number;
+  /** Each side of a crossbar has this number of edges or more. The default is 2. */
+  readonly minBar: number;
+  /** The crossings of one crossbar are this distance or nearer to its first crossing, as a multiple of `boardUnit`. The default is 3. */
+  readonly reach: number;
+}
+/** The default options of the strategy `crossbars`. */
+export declare const CROSSBAR_DEFAULTS: Readonly<Required<Omit<CrossbarOptions, "margin" | "k">>>;
+/** One crossing of two routes: the edges, the point and the unit directions of the two segments there. */
+interface RouteCrossing {
+  readonly e: string;
+  readonly f: string;
+  readonly p: Point;
+  readonly de: Point;
+  readonly df: Point;
+}
+/** This function gives each crossing of two routes of the list, in the order of the list. */
+export declare function routeCrossings(routes: readonly {
+  readonly edge: string;
+  readonly points: readonly Point[];
+}[]): RouteCrossing[];
+/** A crossbar: two sets of edges, with a crossing of each edge of `p` with each edge of `q` near one place. */
+interface Crossbar {
+  readonly p: readonly string[];
+  readonly q: readonly string[];
+  /** The mean point of the crossings of the crossbar. */
+  readonly at: Point;
+  /** The mean direction of the side `p`, and of the side `q`. */
+  readonly dp: Point;
+  readonly dq: Point;
+}
+/**
+ * This function gives the crossbars of a greedy search (HWY-022, after Fink, Hershberger, Suri and Verbeek 2016).
+ * The search starts at each crossing in order. It grows the two sides while each new edge crosses each edge of the other side near the start, at the same angles.
+ * A crossbar with `minBar` edges or more on each side is kept. Each edge is on one crossbar at most.
+ */
+export declare function greedyCrossbars(crossings: readonly RouteCrossing[], reach: number, tolDeg: number, minBar: number): Crossbar[];
+/**
+ * This function gives the highways of the bundled crossings (HWY-022). The edges outside the highways of the plan `from` keep their routes after `follow`.
+ * Each crossbar of those routes gives two highways, one for each side. Each spine is a line through the mean crossing, along the mean direction of its side.
+ * It is `2 reach` long, and it goes through the corner graph. So each side crosses the other side at one place, as a bundle.
+ * An edge joins the spine near the point of its route nearest to one end of the line. It leaves the spine near the other end.
+ */
+export declare function crossbarPlan(input: HighwayInput, o: Readonly<CrossbarOptions>): HighwayPlan;
+/** The options of the highway strategy `frechet` (HWY-027 of the notes). */
+interface FrechetOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two parts of routes are one bundle when their discrete Fréchet distance is this value or less, as a multiple of `boardUnit`. The default is 1. */
+  readonly eps: number;
+  /** A bundle has this number of edges or more, with the reference edge. The default is 2. */
+  readonly minSize: number;
+  /** The reference part of a bundle is this length or longer, as a multiple of `boardUnit`. The default is 2. */
+  readonly minLength: number;
+  /** The distance between two samples of a route, as a multiple of `boardUnit`. The default is 0.5. */
+  readonly step: number;
+  /** A search starts at each sample of this number along each route. The default is 2. */
+  readonly stride: number;
+}
+/** The default options of the strategy `frechet`. */
+export declare const FRECHET_DEFAULTS: Readonly<Required<Omit<FrechetOptions, "margin" | "k">>>;
+/** This function gives the points of a polyline at equal distances of `step` or less, with its first and its last point. */
+export declare function samplesOf(line: readonly Point[], step: number): Point[];
+/** The cells of one row of the free space that a monotone path reaches. Each cell is a sorted index of the other curve. */
+type Row = readonly number[];
+/**
+ * This function gives the next row of the free space of the discrete Fréchet distance. The curve `q` has a free start and a free end.
+ * A cell `(j, b)` is free when the distance of `p[j]` to `q[b]` is `eps` or less.
+ * A path reaches a free cell from `(j - 1, b)`, `(j - 1, b - 1)` or `(j, b - 1)`.
+ */
+export declare function nextRow(prev: Row, pj: Point, q: readonly Point[], eps: number): number[];
+/**
+ * This function tells if a part of `q` has a discrete Fréchet distance of `eps` or less to the whole of `p`. The part of `q` is free to start and to end anywhere.
+ * It uses the rows of `nextRow`.
+ */
+export declare function partWithin(p: readonly Point[], q: readonly Point[], eps: number): boolean;
+/** One bundle of the search: the reference edge, the part of its samples, and the other edges with their sense. */
+interface FrechetBundle {
+  readonly edge: string;
+  readonly from: number;
+  readonly to: number;
+  readonly length: number;
+  /** The other edges. `back` is true when the edge goes along the reference part in the reverse sense. */
+  readonly members: readonly {
+    readonly edge: string;
+    readonly back: boolean;
+  }[];
+}
+/**
+ * This function gives the bundles of the search (HWY-027, after Buchin, Buchin, Gudmundsson, Löffler and Luo 2011, in a simple exact form).
+ * For each reference route and each start sample (at each `stride`), it grows the reference part one sample at a time.
+ * It keeps the other routes, in both senses, with a part at a discrete Fréchet distance of `eps` or less.
+ * It stops when fewer than `minSize - 1` routes remain.
+ * Each start gives the part with the best score: the number of edges times the length.
+ * The search uses the discrete distance on samples only. It does not use the continuous distance or the full free space diagram.
+ */
+export declare function frechetBundles(samples: ReadonlyMap<string, readonly Point[]>, eps: number, minSize: number, minLength: number, stride: number): FrechetBundle[];
+/**
+ * This function gives the highways of the subtrajectory clusters of the first routes (HWY-027). The samples of each route leave out its two end points.
+ * The bundles go in the order of their score, the best first. A bundle keeps the members whose part of the route is not on a bundle already.
+ * The spine of a highway is the reference part. Each member rides the whole spine, in its own sense.
+ */
+export declare function frechetPlan(input: HighwayInput, o: Readonly<FrechetOptions>): HighwayPlan;
+/** The options of the highway strategy `spectral` (HWY-029 of the note on highways). */
+interface SpectralOptions {
+  /** Two edges are a pair of the graph only when their compatibility is this value or more. The default is 0.5. */
+  readonly c0: number;
+  /** The number of clusters of each part of the graph. The value 0 lets the largest eigengap choose it. The default is 0. */
+  readonly clusters: number;
+  /** The eigengap chooses at most this number of clusters in each part of the graph. The default is 16. */
+  readonly kMax: number;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `spectral`. */
+export declare const SPECTRAL_DEFAULTS: Readonly<SpectralOptions>;
+/** The ends of one edge of the board. */
+interface EdgeEnds {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+}
+/** This function gives the ends of each edge of the input: the points of its two plugs. */
+export declare function edgeEnds(input: HighwayInput): EdgeEnds[];
+/**
+ * This function gives the eigenvalues and the eigenvectors of a symmetric matrix of `n` rows (the Householder steps and the QL steps of JAMA).
+ * The values are in increasing order. The column `j` of `vectors` (the values `vectors[i * n + j]`) is the unit vector of the value `j`.
+ */
+export declare function symmetricEigen(n: number, a: Float64Array): {
+  values: Float64Array;
+  vectors: Float64Array;
+};
+/**
+ * This function puts the rows of a matrix of `n` rows and `k` columns into `k` clusters (the steps of Lloyd).
+ * The first centre is row 0. Each next centre is the row farthest from the centres that exist. The result is the cluster of each row.
+ */
+export declare function kMeans(n: number, k: number, rows: Float64Array, iterations?: number): Int32Array;
+/**
+ * This function gives the spectral clusters of the points of a weight matrix (von Luxburg 2007, with the normalization of Ng, Jordan and Weiss).
+ * Each connected part of the graph is one problem. `L_sym = I - D^-1/2 W D^-1/2`.
+ * The number of clusters `k` of a part is `clusters`, or the place of the largest gap of the first `kMax + 1` eigenvalues.
+ * The first `k` eigenvectors, with each row at the length 1, go into `kMeans`. The result is the cluster of each point, and -1 for a point with no pair.
+ */
+export declare function spectralLabels(n: number, w: Float64Array, o: Readonly<Pick<SpectralOptions, "clusters" | "kMax">>): Int32Array;
+/** This function gives the matrix of the compatibility of the pairs of edges, with 0 for a pair below `c0`. Then a `scale` changes the value of each pair that stays. */
+export declare function compatibilityMatrix(ends: readonly EdgeEnds[], c0: number, scale?: (i: number, j: number) => number): Float64Array;
+/**
+ * This function gives the edge groups of the clusters of the edges of one matrix. Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ * An edge with the label -1 gets no group.
+ */
+export declare function labelGroups(ends: readonly EdgeEnds[], labels: Int32Array, prefix: string, groups: Map<string, EdgeGroup>): void;
+/** This function splits the edges into blocks of at most `BLOCK` edges, in the order of their sources. A small graph is one block. */
+export declare function edgeBlocks<T extends EdgeEnds>(ends: readonly T[]): T[][];
+/** This function gives the spectral clusters of the edges (HWY-029). A pair of edges is in the graph when its compatibility of FDEB is `c0` or more. */
+export declare function spectralClusters(input: HighwayInput, o: Readonly<SpectralOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph (HWY-029). The eigengap gives the number of highways of each part.
+ * The clusters with `minSize` edges or more get highways.
+ */
+export declare function spectralPlan(input: HighwayInput, o: Readonly<SpectralOptions>): HighwayPlan;
+/** The options of the highway strategy `resistance` (HWY-021 of the note on highways). */
+interface ResistanceOptions extends SpectralOptions {
+  /** The number of random projections of the estimate of the resistance. The default is 16. */
+  readonly projections: number;
+  /** The weight of the resistance, from 0 to 1. A pair with `C >= c0` gets the weight `C (1 - weight R_e R_f)`. The default is 0.5. */
+  readonly weight: number;
+  /** With `true`, an edge with a resistance of 0.99 or more (a bridge) gets no pair. The default is `false`. */
+  readonly sparsify: boolean;
+}
+/** The default options of the strategy `resistance`. */
+export declare const RESISTANCE_DEFAULTS: Readonly<ResistanceOptions>;
+/**
+ * This function gives an estimate of the effective resistance of each edge of the graph (Spielman and Srivastava 2011).
+ * It takes `k` random vectors `q` of the values `±1/√k` on the edges. It solves `L z = Bᵀ q` for each vector. Then `R(u, v) ≈ Σ (z_u - z_v)²`.
+ * The value is from 0 to 1. A loop and an edge with an unknown node get 0. Parallel edges share the current, so each gets a lower value.
+ */
+export declare function edgeResistance(graph: Graph, projections: number): Map<string, number>;
+/**
+ * This function gives the clusters of the edges with the compatibility scaled by the resistance (HWY-021).
+ * The compatibility of a pair is `C (1 - weight R_e R_f)`. A pair of two bridges thus gets a lower value. Then the spectral clusters of `spectral` apply.
+ */
+export declare function resistanceClusters(input: HighwayInput, o: Readonly<ResistanceOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph with the weights of the effective resistance (HWY-021).
+ * The clusters with `minSize` edges or more get highways.
+ */
+export declare function resistancePlan(input: HighwayInput, o: Readonly<ResistanceOptions>): HighwayPlan;
+/** The options of the highway strategy `link-communities` (HWY-030 of the note on highways). */
+interface LinkCommunityOptions {
+  /** The cut of the tree of the edges. The value 0 cuts at the best partition density. A value above 0 keeps the joins with this similarity or more. The default is 0. */
+  readonly threshold: number;
+  /** A community with this number of edges or more gets highways, after the check of the geometry. The default is 2. */
+  readonly minSize: number;
+  /** The largest distance of an end of an edge to the Weber point of its end of the community, in units of the board. The default is 6. */
+  readonly spread: number;
+  /** The spine of each community. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `link-communities`. */
+export declare const LINK_COMMUNITY_DEFAULTS: Readonly<LinkCommunityOptions>;
+/** The ends of one edge as node indices. */
+interface LinkEdge {
+  readonly u: number;
+  readonly v: number;
+}
+/**
+ * This function gives the link communities of the edges: the single linkage of the edges by their similarity.
+ * With `threshold` 0, the cut is at the level of the best partition density `D = (2/M) Σ m_c (m_c - n_c + 1) / ((n_c - 2)(n_c - 1))`.
+ * When the best `D` is above 0, the first level with it applies. When it is 0 (a forest), the last level applies.
+ * The result is the community of each edge, as the index of an edge of the community. A loop is alone.
+ */
+export declare function linkCommunities(n: number, edges: readonly LinkEdge[], threshold: number): Int32Array;
+/**
+ * This function gives the edge groups of the link communities (HWY-030). The hub of a community is its node with the most edges.
+ * Each edge goes from its end at the hub, or else in the direction of the hub edges. The check of the geometry removes each edge with an end
+ * farther than `spread` units from the Weber point of that end of the community. A community with fewer than `minSize` edges after the check gets no group.
+ */
+export declare function linkCommunityGroups(input: HighwayInput, o: Readonly<LinkCommunityOptions>): Map<string, EdgeGroup>;
+/** This function gives the highways of the link communities of the line graph (HWY-030). Each community that passes the check of the geometry gets highways. */
+export declare function linkCommunityPlan(input: HighwayInput, o: Readonly<LinkCommunityOptions>): HighwayPlan;
+/** The characteristic points of the territories: the plugs, the bends of the first routes, or both. */
+type TerritoryPoints = "plugs" | "bends" | "both";
+/** The values of `TerritoryPoints`. */
+export declare const TERRITORY_POINTS: readonly TerritoryPoints[];
+/** The options of the highway strategy `territories` (HWY-033 of the note on highways). */
+interface TerritoryOptions {
+  /** The radius of a group of points, in units of the board. The default is 4. */
+  readonly radius: number;
+  /** A flow between two cells becomes a highway when this number of edges or more cross it. The default is 2. */
+  readonly minSize: number;
+  /** The characteristic points. The default is `both`. */
+  readonly points: TerritoryPoints;
+}
+/** The default options of the strategy `territories`. */
+export declare const TERRITORY_DEFAULTS: Readonly<TerritoryOptions>;
+/**
+ * This function puts points into groups of the radius `r` (Andrienko and Andrienko 2011). Each point joins the group with the nearest centre within `r`.
+ * Else it starts a new group. The centre of a group is the mean of its points. A second pass puts each point into the group of its nearest centre.
+ * The result is the centres of the groups that keep points.
+ */
+export declare function pointGroups(points: readonly Point[], r: number): Point[];
+/** This function gives the index of the centre nearest to `p`. The first of two equal centres wins. */
+export declare function nearestCentre(centres: readonly Point[], p: Point): number;
+/** One crossing of a route from the cell `from` into the cell `to`, at the share `at` of the length of the route. */
+interface CellStep {
+  readonly from: number;
+  readonly to: number;
+  readonly at: number;
+}
+/**
+ * This function gives the crossings of the cells of a polyline. The cells are the Voronoi cells of the centres.
+ * It samples the polyline at the spacing `step`, and gives each change of the nearest centre.
+ */
+export declare function cellSteps(line: readonly Point[], centres: readonly Point[], step: number): CellStep[];
+/**
+ * This function gives the highways of the territories of the flows (HWY-033, Andrienko and Andrienko 2011).
+ * The characteristic points form groups of the radius `radius`. The centres of the groups make Voronoi cells.
+ * Each first route becomes a list of crossings between neighbour cells.
+ *
+ * A pair of cells with `minSize` crossings or more is a line from centre to centre. The edges that cross it snap to it. The centres of the cells are the interchanges.
+ */
+export declare function territoryPlan(input: HighwayInput, o: Readonly<TerritoryOptions>): HighwayPlan;
+/** The linkage of the clusters of the vote matrix: `average` (the mean distance of the pairs) or `single` (the nearest pair). */
+type ConsensusLinkage = "average" | "single";
+/** The values of `ConsensusLinkage`. */
+export declare const CONSENSUS_LINKAGES: readonly ConsensusLinkage[];
+/** The options of the highway strategy `consensus` (HWY-035 of the note on highways). */
+interface ConsensusOptions {
+  /** The finders that vote. The default is `corridors`, `quickbundles`, `wspd` and `road-classes`. */
+  readonly members: readonly CandidateSource[];
+  /** Two clusters join while their distance `1 - A` is below this value. The default is 0.5: more than half of the votes. */
+  readonly cut: number;
+  /** The linkage of the clusters. The default is `average`. */
+  readonly linkage: ConsensusLinkage;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `consensus`. */
+export declare const CONSENSUS_DEFAULTS: Readonly<ConsensusOptions>;
+/**
+ * This function gives the co-association matrix of the plans (Fred and Jain 2005). `A[e][f]` is the share of the plans with a highway that holds both `e` and `f`.
+ * The edges are in the order of `edges`. An edge of no plan has no pair.
+ */
+export declare function coAssociation(edges: readonly string[], plans: readonly HighwayPlan[]): Float64Array;
+/**
+ * This function gives the clusters of the agglomerative linkage on the distance `1 - A`. Two clusters join while their distance is below `cut`.
+ * The linkage `average` uses the mean of the distances of the pairs, and `single` the smallest distance.
+ * The result is the cluster of each edge, and -1 for an edge that stays alone.
+ */
+export declare function consensusLabels(n: number, a: Float64Array, cut: number, linkage: ConsensusLinkage): Int32Array;
+/** This function gives the edge groups of the consensus of the plans of the finders `members` (HWY-035). */
+export declare function consensusGroups(input: HighwayInput, o: Readonly<ConsensusOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the consensus of clusterings (HWY-035). Each finder of `members` votes for the pairs of edges that share one of its highways.
+ * The clusters of the vote matrix with `minSize` edges or more get highways. A small edit changes few votes, so the clusters are stable.
+ */
+export declare function consensusPlan(input: HighwayInput, o: Readonly<ConsensusOptions>): HighwayPlan;
+/** The allocation of the edges to the hubs: `single` (each node to its nearest hub) or `multiple` (each edge to its best pair of hubs). */
+type HubAllocation = "single" | "multiple";
+/** The values of `HubAllocation`. */
+export declare const HUB_ALLOCATIONS: readonly HubAllocation[];
+/** The candidate points of the hubs: the corners of the corner graph, or the centres of the cells of the tree of sections. */
+type HubCandidates = "corners" | "sections";
+/** The values of `HubCandidates`. */
+export declare const HUB_CANDIDATES: readonly HubCandidates[];
+/** The options of the highway strategy `p-hub` (HWY-041 of the note on highways). */
+interface PHubOptions {
+  /** The number of hubs. The value 0 gives the root of the number of nodes, rounded. The default is 0. */
+  readonly p: number;
+  /** The cost of a length on a link between two hubs against a length off the links, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** The allocation of the edges to the hubs. The default is `single`. */
+  readonly allocation: HubAllocation;
+  /** The candidate points of the hubs. The default is `corners`. */
+  readonly candidates: HubCandidates;
+  /** An edge rides a link only when its way through the two hubs is this many times its first route or less. The default is 1.25. */
+  readonly detour: number;
+  /** The number of passes of the local search with one swap of a hub. The default is 1. */
+  readonly swaps: number;
+  /** A link with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `p-hub`. */
+export declare const P_HUB_DEFAULTS: Readonly<PHubOptions>;
+/** This function gives the candidate points of the hubs, at most `MAX_CANDIDATES`, without the copies. */
+export declare function hubCandidates(input: HighwayInput, candidates: HubCandidates): Point[];
+/**
+ * This function chooses `p` points of `candidates` as the p-median of `points`. The greedy step adds the candidate that lowers the sum of the distances most.
+ * Then at most 4 passes of swaps lower the sum more. The result is the indices of the chosen candidates.
+ */
+export declare function pMedian(points: readonly Point[], candidates: readonly Point[], p: number): number[];
+/**
+ * This function gives the highways of the hub location (HWY-041, the p-hub median of O'Kelly 1987). The p-median of the plugs chooses `p` hubs from the candidates.
+ * Each swap pass changes one hub for one other candidate while the total cost falls. Each link between two hubs with `minSize` edges or more is a highway.
+ * The edges that ride a link snap to it, from their first hub to their second hub.
+ */
+export declare function pHubPlan(input: HighwayInput, o: Readonly<PHubOptions>): HighwayPlan;
+/** The line of each edge that QuickBundles compares: its first route, or the straight line between its plugs. */
+type BundleLine = "routes" | "lines";
+/** The order of the edges in the one pass: the order of the graph, or the longest line first. */
+type BundleOrder = "input" | "length";
+/** The options of the highway strategy `quickbundles` (HWY-026 of the note on highways). */
+interface QuickBundlesOptions {
+  /** An edge joins a cluster when its distance to the centroid is this value or less, in units of the board. The default is 3. */
+  readonly theta: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`, so an added edge does not change the clusters before it. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `quickbundles`. */
+export declare const QUICKBUNDLES_DEFAULTS: Readonly<QuickBundlesOptions>;
+/** This function gives `k` points at equal steps of length along a polyline, from its first point to its last point. */
+export declare function resample(line: readonly Point[], k: number): Point[];
+/**
+ * This function gives the MDF distance of two lines with the same number of points. It is the mean distance of their points.
+ * The function compares the points in the same direction and in the opposite direction, and keeps the smaller mean.
+ * `flip` is `true` when the opposite direction is smaller.
+ */
+export declare function mdf(p: readonly Point[], q: readonly Point[]): {
+  d: number;
+  flip: boolean;
+};
+/**
+ * This function gives the clusters of QuickBundles (Garyfallidis 2012) as groups of edges.
+ * In one pass, each edge joins the cluster with the nearest centroid when the MDF distance is `theta` units or less. Else it starts a cluster.
+ * The centroid is the running mean of the lines of the cluster, each in the direction of the centroid.
+ */
+export declare function quickBundles(input: HighwayInput, o: Readonly<QuickBundlesOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of QuickBundles (HWY-026). The clusters of `quickBundles` with `minSize` edges or more get highways.
+ * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
+ */
+export declare function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan;
+/** The options of the highway strategy `scale-space` (HWY-053 of the note on highways). */
+interface ScaleSpaceOptions {
+  /** The first scale, in units of the board. The default is 1.5. */
+  readonly theta: number;
+  /** The scale of each next scale is this value times the scale before it. The default is the root of 2. */
+  readonly ratio: number;
+  /** The number of scales. The default is 8. */
+  readonly scales: number;
+  /** The scale of the plan, from 0 (the first scale). With the defaults, the scale 2 is 3 units, as in the level 0 of `nested`. The default is 2. */
+  readonly level: number;
+  /** A cluster gets highways only when its persistence `ln(σ_death / σ_birth)` is this value or more. The default is 0.6: two steps of the root of 2. */
+  readonly p0: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `scale-space`. */
+export declare const SCALE_SPACE_DEFAULTS: Readonly<ScaleSpaceOptions>;
+/** One cluster of one scale: its edges (as indices), and the scales of its birth and its death. */
+interface ScaleCluster {
+  readonly members: readonly number[];
+  /** The first scale of the cluster. A cluster of the first scale has the birth 0. */
+  readonly birth: number;
+  /** The first scale where the cluster joins a larger one. A cluster that lives past the last scale has the death `scales`. */
+  readonly death: number;
+}
+/**
+ * This function gives the clusters of the single linkage of `n` items at each scale. The distance `d(i, j)` of each pair is in `pairs`.
+ * At the scale `s`, two items with a distance of `limits[s]` or less are in one cluster. Thus each cluster of a scale is in one cluster of each larger scale.
+ * The result has the clusters of each scale with 2 items or more, with their birth and their death.
+ */
+export declare function scaleClusters(n: number, pairs: readonly {
+  i: number;
+  j: number;
+  d: number;
+}[], limits: readonly number[]): ScaleCluster[][];
+/**
+ * This function gives the groups of the edges at the scale `level` that persist (HWY-053). The scale `s` is `theta × ratio^s` units of the board.
+ * A cluster of the level gets a group when its persistence `(death - birth) × ln(ratio)` is `p0` or more. Each edge of a group gets `flip` against the first edge of the group.
+ */
+export declare function scaleSpaceGroups(input: HighwayInput, o: Readonly<ScaleSpaceOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of one scale of the scale space with persistence (HWY-053). Only the clusters that live over `p0` of the log scale get highways.
+ * 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 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). */
+interface RidgeOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The lines of the density. The default is `lines`. */
+  readonly source: RidgeSource;
+  /** The side of a cell of the density image, in units of the board. The default is 8. A large board gets larger cells, up to 1024 cells on a side. */
+  readonly cell: number;
+  /** The width of the blur, in units of the board. The default is 16. */
+  readonly bandwidth: number;
+  /** A ridge cell has this share of the largest strength or more. The default is 0.15. */
+  readonly strength: number;
+  /** A ridge has this length or more, in units of the board. The default is 60. */
+  readonly minLength: number;
+  /** An edge snaps to a ridge when its line is this near to the ridge, in units of the board. The default is 16. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `ridges`. */
+export declare const RIDGE_DEFAULTS: Readonly<Required<Omit<RidgeOptions, "margin" | "k">>>;
+/** The density image: the cells, its size, and the place of its first cell. */
+interface DensityImage {
+  readonly w: number;
+  readonly h: number;
+  readonly cell: number;
+  readonly x0: number;
+  readonly y0: number;
+  readonly rho: Float64Array;
+}
+/**
+ * This function gives the density of the polylines on a grid of cells, after a Gaussian blur of the width `bandwidth`.
+ * Each polyline adds 1 to each cell that it goes through, one time for each polyline.
+ */
+export declare function lineDensity(lines: readonly (readonly Point[])[], box: {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}, cellSize: number, bandwidth: number): DensityImage;
+/** One ridge: its two ends and the length between them. */
+interface Ridge {
+  readonly a: Point;
+  readonly b: Point;
+}
+/**
+ * This function gives the ridges of a density image (Lindeberg 1998). A ridge cell has a negative eigenvalue of the Hessian with the larger size.
+ * Its density is a maximum along the eigenvector of that eigenvalue. Its strength is the density times the size of that eigenvalue.
+ * The cells with `strength` times the largest strength or more join their neighbours with a direction within 30 degrees.
+ * Each group of cells gives the segment of its main axis. A segment of `minLength` or more is a ridge. The ridges come in the order of their total strength.
+ */
+export declare function densityRidges(img: DensityImage, strength: number, minLength: number): Ridge[];
+/**
+ * This function gives the lines of the ridges (HWY-032), each with the edges that snap to it.
+ * An edge snaps to a ridge when the part of its line near the ridge is half of `minLength` or longer.
+ * The angle between the edge and the ridge is 30 degrees or less.
+ * The edge joins and leaves the ridge at the ends of that part. When two ridges hold one part of an edge, only the longer part rides.
+ */
+export declare function ridgeLines(input: HighwayInput, o: Readonly<RidgeOptions>): SnapLine[];
+/**
+ * This function gives the highways of the ridges of the line density (HWY-032). One pass draws the density, with no advection.
+ * The ridges of the density are the spines, and the edges near a ridge snap to it between their nearest entry and exit points.
+ */
+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 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. */
+  readonly tau: number;
+  /** The names of number fields of `data` that add a distance. The default is no field. */
+  readonly attributes: readonly string[];
+  /** The weight of each field of `attributes`. The distance of a field is its difference over its range. The default is 1. */
+  readonly weight: number;
+  /** The linkage of the clustering. The default is `average`. */
+  readonly linkage: Linkage;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`: the router `shared` with the cluster as the key. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `soft-keys`. */
+export declare const SOFT_KEY_DEFAULTS: Readonly<SoftKeyOptions>;
+/**
+ * This function gives the soft-key distance of two edges (Peysakhovich, Hurter and Telea 2015): `d = d_geom + lambda [key(e) != key(f)] + sum_a w |a(e) - a(f)| / range(a)`.
+ * `d_geom` is the flow distance of HWY-023. The key term is 0 when an edge has no key.
+ */
+export declare function softDistance(geom: number, keyA: string | undefined, keyB: string | undefined, lambda: number, attributes: number): number;
+/**
+ * This function gives the soft-key clusters of the edges (HWY-019). It clusters the edges with `softDistance`, with the cut at `tau`.
+ * Each edge of a cluster gets the key of the cluster. It gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export declare function softKeyClusters(input: HighwayInput, o: Readonly<SoftKeyOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the soft keys (HWY-019). The key of an edge is one more term of the distance, not a hard split.
+ * Edges of two keys still share a highway when they are very near, and edges of one key do not bundle when they are far.
+ */
+export declare function softKeyPlan(input: HighwayInput, o: Readonly<SoftKeyOptions>): HighwayPlan;
+/** The end of the edges that gets a field: the target of a fan-in, or the source of a fan-out. */
+type FieldEnd = "target" | "source";
+/** The options of the highway strategy `flow-field` (EDA-046 with HWY-037 of the notes). */
+interface FlowFieldOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** An end with this number of edges or more on one side of its box gets a field. The default is 2. */
+  readonly minFanIn: number;
+  /** The end that gets a field. The default is `target`. */
+  readonly end: FieldEnd;
+}
+/** The default options of the strategy `flow-field`. */
+export declare const FLOW_FIELD_DEFAULTS: Readonly<Required<Omit<FlowFieldOptions, "margin" | "k">>>;
+/**
+ * This function gives the highways of a flow field for each target (EDA-046, HWY-037).
+ * The edges into one side of one box make a fan. The root of the fan is the point out of the median plug of the fan.
+ * Each edge of the fan goes the shortest way from the point out of its other plug to the root, through the corner graph.
+ * The shortest ways to one root make a tree, so they merge like streams and do not cross. Each stretch that two ways share is one highway.
+ * With the end `source`, the same holds for the edges out of one side of one box.
+ */
+export declare function flowFieldPlan(input: HighwayInput, o: Readonly<FlowFieldOptions>): HighwayPlan;
+/** The options of the highway strategy `keys`: the options of the router `trunks`, without the name and the limit of the benchmark. */
+type KeysOptions = Omit<TrunksOptions, "name" | "maxNodes">;
+/**
+ * This function gives the highways that the router `trunks` decides. A rule gives each edge a key.
+ * The edges from one plug with one key share a trunk to a split point. The edges that go on together share a run past it.
+ * Each trunk and each run becomes one highway. The function does not change the router: it reads its bundles and its runs.
+ */
+export declare function keysPlan(input: HighwayInput, options: KeysOptions): HighwayPlan;
+/** The options of the highway strategy `level-links` (HWY-056 with WILD-034 of the notes). */
+interface LevelHighwayOptions {
+  /** The plan of the edges that do not ride a level link. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The depth of the level in the tree of sections. Depth 1 is the level below the root. The default is 1. */
+  readonly depth: number;
+  /** A level link becomes a highway when this number of edges or more ride it. The default is 2. */
+  readonly minSize: number;
+  /** An edge rides the link only when its way along the link is this many times its first route, or shorter. The default is 1.5. */
+  readonly stretch: number;
+}
+/** The default options of the strategy `level-links`. */
+export declare const LEVEL_HIGHWAY_DEFAULTS: Readonly<LevelHighwayOptions>;
+/**
+ * This function gives a highway for each link of a zoom level, with the edges between its two items (HWY-056, WILD-034).
+ * The level is the cut of the tree of sections at `depth`. The link goes around the boxes of the other items (`levelLinks`).
+ * The spine is the link without a margin at each end, so it stays off the boxes of the two items. It must stay out of each box.
+ * The edges between the two items, in each direction, ride the spine. The ramps go through the corner graph inside the items.
+ *
+ * An edge rides only when the ramps (as straight lines) and the spine are `stretch` times its first route, or shorter.
+ * A link with fewer than `minSize` such edges is not a highway. The other edges keep their highways of the plan `from`.
+ * Thus a zoom from the level to the routes shows the same lines, which open into lanes.
+ */
+export declare function levelHighwayPlan(input: HighwayInput, o: Readonly<LevelHighwayOptions>): HighwayPlan;
+/** The options of the highway strategy `meet` (HWY-050 of the note on highways). */
+interface MeetOptions {
+  /** The plan whose merge points and split points the strategy moves. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** A first route meets the spine where it is this distance from the spine, or nearer. The default is 8: two lanes of 4. */
+  readonly near: number;
+  /** A first route meets the spine only where it runs at this angle to the spine, or less, in degrees. The default is 45. */
+  readonly maxTurn: number;
+  /** A member keeps its places when the stretch where its first route meets the spine is shorter than this length. The default is 10. */
+  readonly minRun: number;
+}
+/** The default options of the strategy `meet`. */
+export declare const MEET_DEFAULTS: Readonly<MeetOptions>;
+/**
+ * This function gives a member with its merge point and its split point where its first route meets the spine and parts from it (HWY-050).
+ * The function samples the stretch of the member on the spine, at steps of `near / 2` or less.
+ * A sample meets the route when the route is `near` or nearer, and its nearest leg runs at `maxTurn` or less to the spine.
+ * The new merge point is the first sample that meets the route, in the direction of the member. The new split point is the last one.
+ * So the edge joins the spine late and leaves it early. The places only move inward.
+ * The member keeps its places when no sample meets the route, or when the met stretch is shorter than `minRun`.
+ */
+export declare function meetMember(spine: readonly Point[], member: HighwayMember, route: readonly Point[] | undefined, o: Readonly<MeetOptions>): HighwayMember;
+/**
+ * This function gives the highways of the plan `from`, with merge points and split points where the routes meet and part (HWY-050).
+ * The first route of each edge is the route of `input.routes`, or its route without highways.
+ * Each member gets the places of `meetMember`. The spines and the trips do not change.
+ */
+export declare function meetPlan(input: HighwayInput, o: Readonly<MeetOptions>): HighwayPlan;
+/** The options of the highway strategy `mingle` (HWY-003 of the note on highways). */
+interface MingleOptions {
+  /** Each bundle looks for a merge among this number of nearest bundles in 4D. The default is 8. */
+  readonly k: number;
+  /** The largest turn of an edge at a meeting point, in degrees. A larger turn moves the meeting point along the trunk. The default is 40. */
+  readonly maxTurn: number;
+  /** The number of levels of merges. The default is 6. */
+  readonly levels: number;
+  /** The weight of the trunk in the ink. With 1, the trunk costs its length one time. The default is 1. */
+  readonly weight: number;
+  /** A bundle with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each bundle. The default is `trunk`: one trunk between the two meeting points. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `mingle`. */
+export declare const MINGLE_DEFAULTS: Readonly<MingleOptions>;
+/**
+ * This function gives the bundles of MINGLE (Gansner, Hu, North and Scheidegger 2011) as groups of edges.
+ * Each edge is a point in 4D: its two plugs. At each level, each bundle examines its `k` nearest bundles in 4D.
+ * A merge saves ink when the ink of the joint bundle is less than the sum of the two inks. The merges with the largest gain go first.
+ * A bundle merges one time at most in a level. The levels stop after `levels` levels, or when no merge saves ink.
+ */
+export declare function mingleBundles(input: HighwayInput, o: Readonly<MingleOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of MINGLE (HWY-003). The bundles of `mingleBundles` with `minSize` edges or more get highways.
+ * With the spine `trunk`, each bundle gets one trunk between its two meeting points, through the corner graph.
+ * With `shared`, the edges of each bundle share their ways through the corner graph.
+ */
+export declare function minglePlan(input: HighwayInput, o: Readonly<MingleOptions>): HighwayPlan;
+/** The options of the highway strategy `od-cells` (EDA-033 with WILD-032 of the notes). */
+interface OdCellOptions {
+  /** The depth of the cells in the tree of sections. Depth 1 is the level below the root. The default is 2. */
+  readonly level: number;
+  /** A pair of cells with this number of edges or more gets a trunk. The default is 3. */
+  readonly minGroup: number;
+  /** An edge rides the trunk only when each of its legs is this share of the span or shorter. The default is 0.3. */
+  readonly legMax: number;
+  /** The spine of each pair of cells. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `od-cells`. */
+export declare const OD_CELL_DEFAULTS: Readonly<OdCellOptions>;
+/**
+ * This function gives the groups of the edges by the pair of the cells of their two nodes (EDA-033, WILD-032).
+ * The cells are the items of the zoom level at the depth `level`. The edges of one pair of cells, in either direction, are one group.
+ * An edge inside one cell is in no group.
+ */
+export declare function odGroups(input: HighwayInput, o: Readonly<OdCellOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the consolidation by origin and destination cells (EDA-033, WILD-032).
+ * Carriers merge the loads from one region to another into one truck between two terminals. Thus each pair of cells with `minGroup` edges or more gets one trunk.
+ * The terminals are the Weber points of the plugs in each cell. An edge with a leg longer than `legMax` times the span goes alone.
+ */
+export declare function odCellPlan(input: HighwayInput, o: Readonly<OdCellOptions>): HighwayPlan;
+/** The options of the highway strategy `nested` (HWY-052 of the note on highways). */
+interface NestedOptions {
+  /** The scale of the closest level, in units of the board. An edge joins a cluster when its distance to the centroid is this value or less. The default is 3. */
+  readonly theta: number;
+  /** The scale of each level is this value times the scale of the next closer level. The default is 2. */
+  readonly ratio: number;
+  /** The number of levels. The default is 3. */
+  readonly levels: number;
+  /** The level of the plan. Level 0 is the closest level, and level `levels - 1` is the far level. The default is 0. */
+  readonly level: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `nested`. */
+export declare const NESTED_DEFAULTS: Readonly<NestedOptions>;
+/**
+ * This function gives the groups of edges of each level, from the closest level (index 0) to the far level.
+ * The far level puts all the edges in clusters at the scale `theta × ratio^(levels - 1)`.
+ * Each closer level puts the edges of each cluster of the level above in clusters, at its own scale. Thus each group of a level is in one group of the level above.
+ */
+export declare function nestedGroups(input: HighwayInput, o: Readonly<NestedOptions>): Map<string, EdgeGroup>[];
+/**
+ * This function gives the number of groups of the closer level `fine` with edges in two groups or more of the level `coarse`.
+ * An edge that is not in `coarse` does not count. The groups of `nestedGroups` give 0.
+ */
+export declare function nestingViolations(coarse: ReadonlyMap<string, EdgeGroup>, fine: ReadonlyMap<string, EdgeGroup>): number;
+/**
+ * This function gives the highways of one level of the nested clusters (HWY-052). The level is `o.level`, with 0 as the closest level.
+ * The clusters of that level with `minSize` edges or more get highways, as in the strategy `quickbundles`.
+ */
+export declare function nestedPlan(input: HighwayInput, o: Readonly<NestedOptions>): HighwayPlan;
+/** The options of the highway strategy `lanes` (HWY-051 of the note on highways). */
+interface LanesOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The plan that the strategy changes. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The gap between two lanes. The default is 4. */
+  readonly laneGap: number;
+  /** The largest width of a highway. The default is 32. */
+  readonly maxWidth: number;
+  /** The number of times that a highway can split, one half after the other. The default is 3. */
+  readonly depth: number;
+}
+/** The default options of the strategy `lanes`. */
+export declare const LANES_DEFAULTS: Readonly<LanesOptions>;
+/**
+ * This function gives the number of legs of the spines of a plan where the lanes do not fit in the channel.
+ * A leg with two lanes or more needs `min(maxWidth, lanes × laneGap)`. The channel is the free space across the leg (`channelWidth`).
+ */
+export declare function channelOverflows(graph: Graph, plan: HighwayPlan, o: Readonly<Pick<LanesOptions, "laneGap" | "maxWidth" | "margin" | "k">>): number;
+/**
+ * This function gives the plan of `from`, with each highway that does not fit in its channels split in two (HWY-051).
+ * The lanes split into two halves by lane order. The first half keeps the spine. The second half gets a new spine through the corners, where the narrow links cost more.
+ * A highway with fewer than four lanes moves as one to the new spine.
+ * A half that still does not fit splits again, up to `depth` times. A new spine needs a shorter length of narrow legs than the old spine.
+ */
+export declare function lanesPlan(input: HighwayInput, o: Readonly<LanesOptions>): HighwayPlan;
+/** The order of the edges in the growth: the longest first route first, or the order of the graph. */
+type GrowthOrder = "length" | "input";
+/** The options of the highway strategy `growth` (HWY-055 of the note on highways). */
+interface GrowthOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The order of the edges. The default is `length`. */
+  readonly order: GrowthOrder;
+  /** The cost of the part on a spine, as a share of its length. The ramps cost their full length. The default is 0.5. */
+  readonly share: number;
+  /** An edge joins a highway only when its way along it is this value times its first route or shorter. The default is 1.3. */
+  readonly stretch: number;
+  /** A spine end extends when this number of its lanes or more go on together. The default is 3. */
+  readonly extendLanes: number;
+  /** The lanes go on together when their ends are this distance from their center or nearer, in units of the board. The default is 2. */
+  readonly extendRadius: number;
+  /** A highway with this number of edges or more stays in the plan. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `growth`. */
+export declare const GROWTH_DEFAULTS: Readonly<GrowthOptions>;
+/**
+ * This function gives the highways of local growth (HWY-055). The edges come one by one, by default the longest first route first.
+ * Each edge joins the highway with the largest saving: its first route less its ramps and `share` of its part on the spine. Without a saving, the edge starts a highway on its own way.
+ * After the growth, a spine end can go on to the center of the far ends of its lanes.
+ * This occurs when `extendLanes` of them or more are near that center and the line is clear.
+ */
+export declare function growthPlan(input: HighwayInput, o: Readonly<GrowthOptions>): HighwayPlan;
+/** The options of the highway strategy `road-classes` (HWY-034 with EDA-050 of the notes). */
+interface RoadClassOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A link is a highway link when its use is at this quantile of the use of the links, or higher. The default is 0.9. */
+  readonly quantile: number;
+  /** A highway link has this number of edges or more on it, and a highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+  /** The second pass gives each highway link this discount, as a share of its length. The default is 0.5. */
+  readonly discount: number;
+}
+/** The default options of the strategy `road-classes`. */
+export declare const ROAD_CLASS_DEFAULTS: Readonly<Required<Omit<RoadClassOptions, "margin" | "k">>>;
+/**
+ * This function gives the highways of the road classes (HWY-034, EDA-050). It counts how many first ways use each link of the corner graph.
+ * The links with a use at the quantile `quantile` or higher, and at least `minSize`, are the highway links.
+ * They are the main roads of a road map.
+ * A second pass routes each edge again, with the discount on the highway links, so more edges join them.
+ * Each stretch of highway links that `minSize` ways or more share after the second pass is one highway.
+ */
+export declare function roadClassPlan(input: HighwayInput, o: Readonly<RoadClassOptions>): HighwayPlan;
+/** The options of the highway strategy `shared-ways`: the options of the router `shared`, without the name and the limit of the benchmark. */
+type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
+/**
+ * This function gives the highways that the router `shared` decides. The edges of one key go one by one through the corner graph.
+ * A link that the key uses already costs less, so the ways of a key come together. Each stretch that two edges or more share becomes one highway.
+ * The function does not change the router: it reads its runs.
+ */
+export declare function sharedWaysPlan(input: HighwayInput, options: SharedWaysOptions): HighwayPlan;
+/** The options of the highway strategy `spiral` (HWY-017 with EDA-035 of the notes). */
+interface SpiralOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The spiral angle, in degrees: the largest angle between a branch and the line to the root. The default is 25. */
+  readonly alpha: number;
+  /** A node with this number of edges or more gets a spiral tree. The default is 4. */
+  readonly minTargets: number;
+  /** The number of points of the arc of each branch. The default is 4. */
+  readonly arc: number;
+}
+/** The default options of the strategy `spiral`. */
+export declare const SPIRAL_DEFAULTS: Readonly<Required<Omit<SpiralOptions, "margin" | "k">>>;
+/** One node of a spiral tree, in polar coordinates around the root. A leaf has an edge, and a join has two children. */
+interface SpiralNode {
+  readonly r: number;
+  readonly theta: number;
+  readonly point: Point;
+  /** A join with this node is this distance or more nearer to the root than the node. A leaf keeps its box clear so. A join has 0. */
+  readonly clear: number;
+  readonly edge?: string;
+  readonly children: readonly SpiralNode[];
+}
+/**
+ * This function gives the join of the nodes `p` and `q` of a spiral tree with the angle `alpha`. It gives `undefined` when no join is possible.
+ * Each node can reach the points inside its two spirals toward the root: `|theta - theta_p| <= tan(alpha) ln(r_p / r)`.
+ * The join is the point farthest from the root that both nodes reach, and that is `clear` nearer to the root than each node.
+ * At that radius, the join is at the middle of the angles that both nodes reach.
+ */
+export declare function spiralJoin(p: SpiralNode, q: SpiralNode, alpha: number, root: Point): {
+  r: number;
+  theta: number;
+  point: Point;
+} | undefined;
+/**
+ * This function gives the spiral tree of the leaves around the root (Buchin, Speckmann and Verbeek 2011), with the greedy sweep.
+ * The sweep goes from the far leaves to the root. A leaf joins the wavefront at its radius. Two nodes that are next to each other in angle join at their join point.
+ * The join with the largest radius goes first. No join occurs below the radius `rMin`. The function gives the nodes of the wavefront at the end.
+ */
+export declare function spiralTree(leaves: readonly SpiralNode[], alpha: number, root: Point, rMin: number): SpiralNode[];
+/**
+ * This function gives the highways of the spiral trees (HWY-017, EDA-035). Each node with `minTargets` edges or more is the root of a fan.
+ * The nodes with more edges go first, and each edge is in one fan at most. The far plug of each edge is a leaf of the tree of its fan.
+ * Each branch of a tree with two leaves or more is a highway. Its spine is an arc of a logarithmic spiral, or a way through the corner graph where the arc hits a box.
+ * An edge rides the branches from the root to its leaf, or from its leaf to the root when the root is its target.
+ */
+export declare function spiralPlan(input: HighwayInput, o: Readonly<SpiralOptions>): HighwayPlan;
+/** The ends of the edges that get stubs: the source ends, the target ends, or both. */
+type StubEnds = "source" | "target" | "both";
+/** The options of the highway strategy `stubs` (HWY-015 with WILD-005 of the notes). */
+interface StubOptions {
+  /** The plan that the stubs go into. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The ends of one side of a box whose directions are in a window of this angle share a stub, in degrees. The default is 30. */
+  readonly omega: number;
+  /** The length of a stub is this share of the distance to the nearest other end. The default is 0.25. */
+  readonly sigma: number;
+  /** The ends that get stubs. The default is `both`. */
+  readonly ends: StubEnds;
+  /** A stub has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `stubs`. */
+export declare const STUB_DEFAULTS: Readonly<StubOptions>;
+/**
+ * This function gives the highways of the plan `from`, with a stub at the ends of the edges (HWY-015, WILD-005).
+ * The ends on one side of one box are sorted by the direction of their other node. A run of ends in a window of `omega` makes a group.
+ * Each group of `minSize` ends or more shares one plug and one stub along the normal of the side. Then the edges fan out.
+ *
+ * The length of the stub is `sigma` times the distance to the nearest other node, and half that distance at most.
  * It is two times the margin of the way finder at least, and the stub stays out of the other boxes. Else the group gets no stub.
  * An end with a fixed plug or a side of its own gets no stub. An end whose first highway starts on its box, or near it, keeps the plan.
  */
 export declare function stubPlan(input: HighwayInput, o: Readonly<StubOptions>): HighwayPlan;
+/** The options of the highway strategy `traclus` (HWY-025 of the note on highways). */
+interface TraclusOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two segments are neighbours when their distance is this value or less, in units of the board. The default is 2. */
+  readonly eps: number;
+  /** A cluster has segments of this number of edges or more, and a core segment has this number of neighbours or more. The default is 3. */
+  readonly minLns: number;
+  /** The weight of the perpendicular distance. The default is 1. */
+  readonly wPerp: number;
+  /** The weight of the parallel distance. The default is 1. */
+  readonly wPar: number;
+  /** The weight of the angle distance. The default is 1. */
+  readonly wTheta: number;
+  /** A route keeps a corner when the cost of the line without it is more than this value times the cost with it. The default is 1. */
+  readonly mdl: number;
+}
+/** The default options of the strategy `traclus`. */
+export declare const TRACLUS_DEFAULTS: Readonly<Required<Omit<TraclusOptions, "margin" | "k">>>;
+/** One segment of a partitioned route: the edge, the index of the segment in the route, and its two ends. */
+interface RouteSegment {
+  readonly edge: string;
+  readonly index: number;
+  readonly a: Point;
+  readonly b: Point;
+}
+/**
+ * This function gives the TRACLUS distance of two segments (Lee, Han and Whang 2007): `w_perp d_perp + w_par d_par + w_theta d_theta`.
+ * `d_perp` is `(l1² + l2²) / (l1 + l2)` with the distances of the ends of the shorter segment to the line of the longer segment.
+ * `d_par` is the gap along the longer segment between the two segments, 0 when they overlap. `d_theta` is `|shorter| sin(theta)`.
+ * The segments have no direction, so the angle is 90 degrees or less.
+ */
+export declare function segmentDistance(p: {
+  a: Point;
+  b: Point;
+}, q: {
+  a: Point;
+  b: Point;
+}, w: {
+  perp: number;
+  par: number;
+  theta: number;
+}): number;
+/**
+ * This function gives the characteristic points of a route by the rule of the minimum description length (MDL) of TRACLUS.
+ * A partition from point `i` to point `j` costs `L(H) + L(D|H)`. `L(H)` is the log of its length, and `L(D|H)` the logs of the perpendicular and angle distances of the route parts.
+ * The route keeps the point before `j` when that cost is more than `ratio` times the cost of the route parts. The lengths are in units of the board.
+ */
+export declare function characteristicPoints(route: readonly Point[], unit: number, ratio: number): Point[];
+/**
+ * This function gives the clusters of segments of DBSCAN. A segment with `minLns` neighbours or more within `eps` (itself included) is a core segment.
+ * A cluster grows from each core segment through its neighbours. A cluster with segments of fewer than `minLns` edges is dropped.
+ */
+export declare function segmentClusters(segments: readonly RouteSegment[], eps: number, minLns: number, w: {
+  perp: number;
+  par: number;
+  theta: number;
+}): RouteSegment[][];
+/**
+ * This function gives the representative line of a cluster of segments. The line goes along the mean direction of the segments.
+ * A sweep along that direction stops at each end of a segment. Where `minLns` segments or more cover the stop, the point is the mean of their points there.
+ * Two points of the line are at least `gap` apart.
+ */
+export declare function representative(cluster: readonly RouteSegment[], minLns: number, gap: number): Point[];
+/**
+ * This function gives the highways of TRACLUS (HWY-025). Each first route breaks into a few long segments by the rule of MDL.
+ * DBSCAN puts the segments that are near in distance and angle into clusters. Each cluster with segments of `minLns` edges or more is one highway.
+ * The spine is the representative line of the cluster, or a way through the corner graph between its ends when the line hits a box.
+ * Each edge of the cluster joins the spine nearest to the first end of its segments. It leaves the spine nearest to the last end.
+ * An edge rides only when both ends of its part are within `eps` of the spine.
+ * Its length on the spine is also at most 1.25 times the length of its own route there.
+ * Each edge rides one highway at most: the highway where it rides the longest length.
+ */
+export declare function traclusPlan(input: HighwayInput, o: Readonly<TraclusOptions>): HighwayPlan;
 /** The options of the highway strategy `weiszfeld` (HWY-043 of the note on highways). */
 interface WeiszfeldOptions {
   /** The plan whose highways get new meeting points. The default is `shared-ways`. */
@@ -3718,6 +5296,40 @@ export declare const highwayStrategies: {
   readonly wspd: Strategy<"highway", WspdOptions>;
   readonly "od-cells": Strategy<"highway", OdCellOptions>;
   readonly select: Strategy<"highway", SelectOptions>;
+  readonly mingle: Strategy<"highway", MingleOptions>;
+  readonly spiral: Strategy<"highway", SpiralOptions>;
+  readonly "flow-clusters": Strategy<"highway", FlowClusterOptions>;
+  readonly traclus: Strategy<"highway", TraclusOptions>;
+  readonly diffusion: Strategy<"highway", DiffusionOptions>;
+  readonly nested: Strategy<"highway", NestedOptions>;
+  readonly lanes: Strategy<"highway", LanesOptions>;
+  readonly growth: Strategy<"highway", GrowthOptions>;
+  readonly "edge-paths": Strategy<"highway", EdgePathOptions>;
+  readonly "soft-keys": Strategy<"highway", SoftKeyOptions>;
+  readonly hough: Strategy<"highway", HoughOptions>;
+  readonly ridges: Strategy<"highway", RidgeOptions>;
+  readonly hdbscan: Strategy<"highway", HdbscanOptions>;
+  readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
+  readonly divided: Strategy<"highway", DividedOptions>;
+  readonly hierarchy: Strategy<"highway", HierarchyOptions>;
+  readonly fdeb: Strategy<"highway", FdebOptions>;
+  readonly mesh: Strategy<"highway", MeshOptions>;
+  readonly kdeeb: Strategy<"highway", KdeebOptions>;
+  readonly cubu: Strategy<"highway", CubuOptions>;
+  readonly mlseb: Strategy<"highway", MlsebOptions>;
+  readonly sbeb: Strategy<"highway", SbebOptions>;
+  readonly areas: Strategy<"highway", AreaOptions>;
+  readonly confluent: Strategy<"highway", ConfluentOptions>;
+  readonly power: Strategy<"highway", PowerOptions>;
+  readonly crossbars: Strategy<"highway", CrossbarOptions>;
+  readonly frechet: Strategy<"highway", FrechetOptions>;
+  readonly spectral: Strategy<"highway", SpectralOptions>;
+  readonly resistance: Strategy<"highway", ResistanceOptions>;
+  readonly "link-communities": Strategy<"highway", LinkCommunityOptions>;
+  readonly territories: Strategy<"highway", TerritoryOptions>;
+  readonly consensus: Strategy<"highway", ConsensusOptions>;
+  readonly "p-hub": Strategy<"highway", PHubOptions>;
+  readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -3802,18 +5414,12 @@ 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;
-/** This function gives the bytes of a string in UTF-8. */
+/** 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;
-/** This function gives the SHA-256 digest of a string, as 64 lowercase hex characters. It encodes the string in UTF-8. */
-export declare function sha256Hex(text: string): string;
-/**
- * This function writes a value as canonical JSON: the keys of each object in sorted order, and no whitespace.
- * It drops a key whose value is `undefined`, as `JSON.stringify` does.
- */
-export declare function canonicalJson(value: unknown): string;
 /**
  * This function gives the hash of a JSON document: the first 16 hex characters of the SHA-256 of its canonical JSON.
  * The document does not include its own field `hash`. The function removes that field before it calculates the hash.
+ * The `documentHash` of the contract puts each number on a grid first, so it is not equal to this function. The hashes of the corpus files use this function.
  */
 export declare function documentHash(value: object): string;
 /** This function gives the 32-bit FNV-1a hash of the UTF-8 bytes of a text, as an unsigned integer. */
@@ -3822,7 +5428,7 @@ export declare function fnv1a32(text: string): number;
 export declare function stepSeed(seed: number, step: string): number;
 /** This function gives the generator `mulberry32` for a seed. Each call gives the next number from 0 to below 1. */
 export declare function mulberry32(seed: number): () => number;
-/** This function rounds a number to 3 decimals, as the files of a corpus keep it. The value `-0` becomes `0`. */
+/** This function rounds a number to 3 decimals (a step of `RECORD_EPS`), as the files of a corpus keep it. The value `-0` becomes `0`. */
 export declare function round3(value: number): number;
 /** The side of a port in an input file. The router calls the same sides `north`, `east`, `south` and `west`. */
 export type LayoutSide = "top" | "right" | "bottom" | "left";
@@ -3884,8 +5490,8 @@ export interface LayoutBox {
   readonly parent?: string;
   /** The group of the box. */
   readonly group?: string;
-  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
-  readonly locked?: true;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. `false` is the same as no value. The router ignores it. */
+  readonly locked?: boolean;
   /** The reading order that the caller wants. The router ignores it. */
   readonly rank?: number;
   readonly ports?: readonly LayoutPort[];
@@ -3919,7 +5525,7 @@ export interface LayoutGenerator {
  * The packer reads the first six dimensions. The router reads the last four.
  */
 export interface LayoutCell {
-  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
   readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
   readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
   readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
@@ -4014,6 +5620,19 @@ export interface LayoutRecord {
   readonly commit?: string;
   /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */
   readonly skipped?: string;
+  /**
+   * The first 16 hex characters of the SHA-256 of the output in the highways form (ACTIVATION). `resultHash` gives it for a router.
+   * Two records with the same hash have the same output, at the precision `RECORD_EPS`.
+   */
+  readonly outputHash?: string;
+  /** The facts of the stages of the run. The trace measures `move.<name>` count the own move of the strategy (ACTIVATION). */
+  readonly trace?: readonly RecordTrace[];
+}
+/** The facts of one stage of a run, as the `StageTrace` of the contract: its id, its time and its trace measures. */
+export interface RecordTrace {
+  readonly id: string;
+  readonly ms?: number;
+  readonly measures?: Readonly<Record<string, number>>;
 }
 /** The comparison of a prediction. Without it, `<=` applies to a measure where lower is better, and `>=` to the other measures. */
 export type PredictionOp = "<" | "<=" | "=" | ">=" | ">";
@@ -4045,13 +5664,20 @@ export declare function regionBounds(region: Region): {
   w: number;
   h: number;
 };
+/**
+ * The fields of an input that `inputGraph` reads. A contract input, for example the result of `applyPack`, has these fields.
+ * Without `edges`, the input has no edges.
+ */
+export type RouteInput = Pick<LayoutInput, "id" | "boxes" | "obstacles"> & {
+  readonly edges?: LayoutInput["edges"];
+};
 /**
  * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
  * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
  * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
  * A box without `x` and `y` is an error.
  */
-export declare function inputGraph(input: LayoutInput): Graph;
+export declare function inputGraph(input: RouteInput): Graph;
 /**
  * This function writes an input file as text: the keys in sorted order, and one box or one edge on each line.
  * `JSON.parse` of the text gives the input again.
@@ -4066,6 +5692,21 @@ export declare function parseLines<T>(text: string): T[];
  * A function becomes the text `function:<name>`, and a number that is not finite becomes its text.
  */
 export declare function jsonSafe(value: unknown): unknown;
+/**
+ * The smallest change of a measure that counts as better or worse (WIN-RES).
+ * A number is an absolute change. `{ rel }` is a share of the larger of the two absolute values.
+ * The threshold is not less than `RECORD_EPS` at any time.
+ */
+export type MinEffect = NonNullable<MeasureSpec["minEffect"]>;
+/** The result of a compare of a candidate with a baseline on one measure. A tie is not a win. It is the `Verdict` of the contract. */
+export type MeasureCompare = Verdict;
+/** The part of a measure that a compare reads: the better side and the minimum effect. */
+export type CompareSpec = Pick<MeasureSpec, "direction" | "minEffect">;
+/**
+ * This function applies the wave rule to the compares of one board, for example of `B1` and of the `B3` q95.
+ * The board is a win only when no compare is `worse` and one or more compares are `better`. Thus a board of ties is not a win.
+ */
+export declare function boardWins(compares: readonly MeasureCompare[]): boolean;
 /**
  * One measure of a record. `key` is the key of the measure in the values of `runSuite` and `compareStep`.
  * `name` is the name of the measure in a record of the form `layout-record/1`.
@@ -4084,13 +5725,32 @@ export interface MeasureInfo {
    * Then two values compare only on the same input. The value is `false` when the measure scores the routes or the curves for a fixed placement.
    */
   readonly placementDependent: boolean;
+  /**
+   * The smallest change that counts as better or worse in `compareMeasure` (WIN-RES). `MIN_EFFECTS` gives it by the unit, with its reason.
+   * A measure without this field has the threshold `RECORD_EPS`.
+   */
+  readonly minEffect?: MinEffect;
 }
+/** One rule of `MIN_EFFECTS`: the units, the minimum effect of a measure with one of these units, and the reason. */
+export interface MinEffectRule {
+  readonly units: readonly string[];
+  /** The minimum effect. The value `undefined` gives the threshold `RECORD_EPS`. */
+  readonly minEffect: MinEffect | undefined;
+  readonly reason: string;
+}
+/**
+ * The minimum effect of each measure of `MEASURES`, by the unit of the measure (WIN-RES).
+ * Each unit of `MEASURES` is in one rule. The test of the module checks it.
+ */
+export declare const MIN_EFFECTS: readonly MinEffectRule[];
 /**
  * The measures of the records of the stage `route`, with the placement dependence of each one.
  * A joint harness that moves the boxes and routes the edges reads `placementDependent`.
  * It compares a measure with the value `true` only between runs on the same input.
  */
 export declare const MEASURES: readonly MeasureInfo[];
+/** This function gives the spec of a compare of a measure: its better side and its minimum effect. */
+export declare function compareSpec(info: MeasureInfo): CompareSpec;
 /** This function gives the measure of a key of `runSuite` or `compareStep`, or `undefined` for a key that is not in `MEASURES`. */
 export declare function measureByKey(key: string): MeasureInfo | undefined;
 /** This function gives the measure of a name of a record, or `undefined` for a name that is not in `MEASURES`. */
@@ -4126,7 +5786,7 @@ export interface ScreenSet {
  * This set does not change. The tests compare it with the files in `corpus/screen-v1`.
  */
 export declare const SCREEN_V1: ScreenSet;
-/** The screen sets by id. */
+/** 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). */
 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;
@@ -4152,6 +5812,257 @@ export interface LayoutCorpus {
 }
 /** 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 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.
+ * Each number goes to the grid `RECORD_EPS`, as `round3` does.
+ */
+export declare function resultHash(result: Result): string;
+/** This function gives the highways form of a result of a router: the value that `resultHash` hashes. */
+export declare function resultForm(result: Result): object;
+/** This function gives the output hash of the curves of the step `curve`, in the order of the edge ids. */
+export declare function curvesHash(edges: readonly string[], curves: readonly (readonly CurveSegment[])[]): string;
+/**
+ * The name of the own move of each built-in highway finder. The trace of a record names the count `move.<name>`.
+ * The count is the number of highways of the plan with 2 edges or more. A finder without an entry counts `move.highway`.
+ */
+export declare const MOVE_NAMES: Readonly<Record<string, string>>;
+/**
+ * The highway strategies that change the plan of another strategy (`from`). Their own move is a change of that plan, so they count no move.
+ * The output against the plan `from` tells if they ran.
+ */
+export declare const PLAN_CHANGERS: readonly string[];
+/**
+ * This function gives the built-in highway strategy of a name: the strategy itself, or the strategy of a variant, for example `power` for `power-near`.
+ * It gives `undefined` for a gate (a name with `+`) and for a name of another step.
+ */
+export declare function finderOf(name: string): string | undefined;
+/**
+ * This function gives the count of the own move of a highway strategy on its plan, for example `{ "move.powerEdge": 3 }`.
+ * It gives `undefined` for a gate and for a strategy of `PLAN_CHANGERS`.
+ */
+export declare function planMoves(name: string, plan: HighwayPlan): Record<string, number> | undefined;
+/** A function that gives the own move counts of a strategy on a graph, or `undefined` for a strategy without a count. */
+export type MoveCounter = (strategy: string, graph: Graph) => Readonly<Record<string, number>> | undefined;
+/** This function gives a `MoveCounter` for highway strategies, by the names of the records. It makes the plan of the strategy again. */
+export declare function highwayMoves(strategies: Readonly<Record<string, Strategy<"highway", object>>>): MoveCounter;
+/**
+ * This function gives the base of a strategy for the fallback test: the strategy that it falls back to or extends.
+ * - A gate `X+G` and a wrapped router `X+W` have the base `X`.
+ * - A highway finder of a module (`hw:power`, `w3e:power-near`) has the base `hw:none`, the empty plan.
+ * - A plan changer has the base of its plan `from`: `hw:shared-ways`, or `hw:corridors` and `hw:none` for a name that ends with `-corridors` and `-none`.
+ * - An option of a router (`shared-cap-3`, `shared-all-p3`, `trunks-tree-bf02`, `corners-side`) has the base `shared`, `shared-all`, `trunks` or `corners`.
+ * The function gives `undefined` when the base is not in `known`.
+ */
+export declare function activationBase(name: string, known: ReadonlySet<string>): string | undefined;
+/** The activation of one strategy over the decision inputs of a screen. */
+export interface ActivationRow {
+  readonly strategy: string;
+  /** The base of the fallback test, or `undefined` when the strategy has none. */
+  readonly base?: string;
+  /** The decision inputs where the strategy ran. */
+  readonly inputs: number;
+  /** The decision inputs where a move count is above 0. */
+  readonly moved: readonly string[];
+  /** The decision inputs where the output differs from the output of the base. */
+  readonly differs: readonly string[];
+  /** The sum of each move count over the decision inputs. */
+  readonly moves: Readonly<Record<string, number>>;
+  readonly verdict: "exercised" | "not-exercised";
+  /** The id of the output group of the strategy on the decision inputs. */
+  readonly group: string;
+}
+/** The groups of the strategies with equal output on each input of one cell (a family of boards). They are diagnostics only. */
+export interface CellGroups {
+  readonly cell: string;
+  readonly groups: readonly OutputGroup[];
+}
+/** The activation report of a screen. */
+export interface ActivationReport {
+  /** The decision inputs, in sorted order. */
+  readonly inputs: readonly string[];
+  readonly rows: readonly ActivationRow[];
+  /** The output groups with more than one strategy: equal output hashes on each decision input. */
+  readonly groups: readonly OutputGroup[];
+  /** The cell groups with more than one strategy, for each family of the decision inputs. */
+  readonly cells: readonly CellGroups[];
+}
+/** This function gives the family of an input id, for example `small-clustered` for `screen-v1/small-clustered/s0`. */
+export declare function familyOf(input: string): string;
+/** This function gives the move counts of a record, from its trace. */
+export declare function recordMoves(record: LayoutRecord): Record<string, number>;
+/**
+ * This function gives the activation report of the records of a screen.
+ * A strategy is exercised when a move count is above 0 on a decision input.
+ * It is also exercised when its output differs from the output of its base on a decision input.
+ * The decision inputs are the inputs of the families `families`, or each input. `bases` gives the base of each strategy, or `activationBase` gives it.
+ */
+export declare function activationReport(records: readonly LayoutRecord[], options?: {
+  readonly families?: readonly string[];
+  readonly bases?: Readonly<Record<string, string>>;
+}): ActivationReport;
+/** This function writes the activation report as Markdown: the strategies that are not exercised, and the output groups. */
+export declare function formatActivation(report: ActivationReport, candidates?: ReadonlySet<string>): string;
+/** The rule of the exact model: `collection` lets only the edges of one collection share a link, and `all` lets each edge share a link. */
+export type GapRule = "collection" | "all";
+/** The rules of the gap closed, in the order of the records. */
+export declare const GAP_RULES: readonly GapRule[];
+/**
+ * A view of the gap closed: one rule, or `chosen`. The view `chosen` takes a rule for each run.
+ * It takes `all` when a shared segment of the run holds edges of two collections. Else it takes `collection`.
+ */
+export type GapView = GapRule | "chosen";
+/** The views of the gap closed, in the order of the tables. */
+export declare const GAP_VIEWS: readonly GapView[];
+/** The stretch caps of the exact optima, from small to large. */
+export declare const GAP_CAPS: readonly number[];
+/** The baseline of each rule: the router `shared` for `collection`, and the plan `shared-ways-all` after `follow` for `all`. */
+export declare const GAP_BASELINES: Readonly<Record<GapRule, string>>;
+/** The parameters of the paired bootstrap of the gap closed, from `docs/PROMOTION.md`. */
+export declare const GAP_BOOTSTRAP: {
+  readonly runs: number;
+  readonly level: number;
+  readonly seed: number;
+};
+/** The optimum of the exact model on one input, for one rule and one stretch cap. The file of the optima of a set holds one for each. */
+export interface ExactOptimum {
+  /** The id of the input. */
+  readonly input: string;
+  /** The hash of the input file. The screen uses the optimum only when the hash matches. */
+  readonly hash: string;
+  /** The class of the input: its family in the set. */
+  readonly class: string;
+  readonly nodes: number;
+  readonly edges: number;
+  readonly rule: GapRule;
+  readonly cap: number;
+  /** The status of HiGHS: `optimal`, `time-limit` or another status. */
+  readonly status: string;
+  /** This value is `true` when HiGHS proved the optimum within the time limit. */
+  readonly proven: boolean;
+  /** The objective of the best solution, the dual bound and the relative MIP gap. Each one is `null` when HiGHS gives none. */
+  readonly objective: number | null;
+  readonly bound: number | null;
+  readonly mipGap: number | null;
+  /** The time of the solve, in seconds. */
+  readonly seconds: number;
+  /** The number of binary variables of the model. */
+  readonly binaries: number;
+  /** The ink saved (B1) of the routes of the best plan after `follow`. The gap closed uses this value. */
+  readonly b1: number | null;
+  /** The ink saved of the model itself, without `follow`. */
+  readonly modelB1: number | null;
+  /** The largest bundle stretch (B3) of the routes of the best plan, against the routes of `corners`. */
+  readonly b3max: number | null;
+  /** The number of highways of the best plan. */
+  readonly highways: number;
+}
+/** The file of the optima of a set (`exact-optima/1`). Later screens read it and do not solve again. */
+export interface ExactOptimaFile {
+  readonly schema: "exact-optima/1";
+  readonly set: string;
+  /** The time limit of each solve, in seconds. */
+  readonly seconds: number;
+  /** The commit of the code and the CI run of the solves. */
+  readonly commit?: string;
+  readonly run?: string;
+  readonly optima: readonly ExactOptimum[];
+}
+/** This function gives the file of the optima of a set, with the rows in the order of the input, the rule and the cap. */
+export declare function optimaFile(set: string, rows: readonly ExactOptimum[], at: {
+  readonly seconds: number;
+  readonly commit?: string;
+  readonly run?: string;
+}): ExactOptimaFile;
+/** This function gives the key of an optimum in a map: the input, the rule and the cap. */
+export declare function optimumKey(input: string, rule: GapRule, cap: number): string;
+/** This function gives the smallest cap that is at least the stretch, or `undefined` when the stretch is above the largest cap. */
+export declare function gapCap(stretch: number, caps?: readonly number[]): number | undefined;
+/**
+ * This function gives the gap closed: `(b1 - base) / (optimum - base)`.
+ * It gives `undefined` when the denominator is 0 or less, because then the baseline is at the optimum or above it.
+ */
+export declare function gapClosed(b1: number, base: number, optimum: number): number | undefined;
+/**
+ * This function gives the largest bundle stretch of routes against base routes: the max of `L(r_e) / L(r*_e)` over the edges, as B3 counts them.
+ * An edge without a base route, or with a base route of 1 unit or less, does not count. Without such an edge, the value is 1.
+ */
+export declare function maxStretch(routes: readonly Route[], base: readonly Route[]): number;
+/** The highway strategy `shared-ways-all`: the plan of the router `shared` without a rule. It is the baseline of the rule `all`. */
+export declare const sharedWaysAll: Strategy<"highway", object>;
+/** This function gives the B1 of the baseline of each rule on a graph. */
+export declare function gapBaselines(graph: Graph): Record<GapRule, number>;
+/** A median with its paired bootstrap interval. */
+export interface BootstrapMedian {
+  readonly median: number;
+  readonly lo: number;
+  readonly hi: number;
+}
+/**
+ * This function gives the median of the values and its bootstrap interval: `runs` samples of the values with replacement, from the seed `seed`.
+ * The interval is the central `level` share of the medians of the samples. Each value is the paired value of one input, so the bootstrap is paired.
+ */
+export declare function bootstrapMedian(values: readonly number[], o?: {
+  readonly runs?: number;
+  readonly level?: number;
+  readonly seed?: number;
+}): BootstrapMedian;
+/** The gap closed of one strategy and one view over the inputs of a screen. */
+export interface GapSummary {
+  readonly strategy: string;
+  readonly rule: GapView;
+  /** The number of runs, and the number of runs with a value. A run has no value above the largest cap, or without a proven optimum. */
+  readonly runs: number;
+  readonly values: number;
+  /** The median over the inputs with a value, and its paired bootstrap interval. */
+  readonly median: number;
+  readonly lo: number;
+  readonly hi: number;
+  /** The median of each class, by the family of the input. */
+  readonly byClass: Readonly<Record<string, number>>;
+  /** The number of values at each cap, by the cap. */
+  readonly caps: Readonly<Record<string, number>>;
+  /** The number of runs with some ink saved (B1 above 0): the runs where the strategy builds a shared segment. */
+  readonly builds: number;
+  /** The number of runs where a shared segment holds edges of two collections. */
+  readonly mixed: number;
+}
+/** The names of the measures of the gap closed in a record, for a view. */
+export declare function gapNames(view: GapView): {
+  readonly gap: string;
+  readonly cap: string;
+};
+/**
+ * This function gives the gap closed of each strategy and view over records.
+ * It sorts them by the view and then by the median, from high to low.
+ * A strategy with a value on fewer than half of its runs comes after the others, because its median shows only a few inputs.
+ */
+export declare function summarizeGap(records: readonly {
+  readonly strategy: string;
+  readonly input: string;
+  readonly skipped?: string;
+  readonly measures: Readonly<Record<string, number>>;
+}[]): GapSummary[];
+/** This function writes the gap closed as Markdown: one table for each view, sorted by the median. */
+export declare function formatGap(rows: readonly GapSummary[]): string;
+/** This function gives the count of the shared segments of a result (the runs and the bundles) that hold edges of two collections or more. */
+export declare function mixedSegments(graph: Graph, result: Result): number;
+/** This function tells if a shared segment of a result (a run or a bundle) holds edges of two collections. */
+export declare function mixesCollections(graph: Graph, result: Result): boolean;
+/**
+ * This function gives the gap measures of the result of one run on an input with optima, by the keys of `MEASURES`.
+ * `B3.max` is the largest stretch against the routes of `corners`. `gap.stretch` is the largest stretch as the exact model counts it (`exactStretch`).
+ * The cap is the smallest cap at or above `gap.stretch`, so both sides of the gap have the same stretch limit.
+ *
+ * `gap.<rule>` is the gap closed at the cap `gap.cap.<rule>`. `gap` is the gap closed of the rule of the run.
+ * That rule is `all` when `gap.mixed` is 1, else `collection`.
+ * A rule has no value above the largest cap or without a proven optimum at the cap.
+ * It also has no value when the hash of the optimum is not the hash of the input.
+ */
+export declare function gapValues(input: {
+  readonly id: string;
+  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 screen of the step `highway` routes the plan of each strategy with `follow`, and measures the routes as the routes of a router.
@@ -4214,6 +6125,16 @@ export interface ScreenOptions {
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
   readonly predictions?: readonly LayoutPrediction[];
+  /**
+   * The exact optima of the inputs, from the file of the optima of a set (MEAS2). The steps `router` and `highway` read them.
+   * Each run on an input with optima gets the largest B3 and the gap closed of each rule (B10). The summary then gets the gap table.
+   */
+  readonly optima?: readonly ExactOptimum[];
+  /**
+   * This function gives the own move counts of a strategy on an input (ACTIVATION), for example `{ "move.powerEdge": 3 }`.
+   * Each record of a strategy with counts gets them as the trace measures of its step. The default is no counts.
+   */
+  readonly moves?: MoveCounter;
   /** This function gets one line of progress for each input. */
   readonly log?: (line: string) => void;
 }
@@ -4267,6 +6188,8 @@ export interface ScreenSummary {
   /** The strategies with a break over the floor, without a run or with two different outputs of one input. They do not enter the front. */
   readonly excluded: readonly string[];
   readonly predictions: readonly PredictionCheck[];
+  /** The gap closed of each strategy and rule, when the screen has optima. */
+  readonly gap?: readonly GapSummary[];
 }
 /** The result of `screen`: one record for each strategy and input, and the summary. */
 export interface ScreenReport {
@@ -4302,6 +6225,48 @@ export interface RectScatteredParams {
  * The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
  */
 export declare function rectScattered(seed: number, params: RectScatteredParams, set?: string): LayoutInput;
+/** The board classes of the small boards with a known optimum (MEAS2). */
+export type ExactClass = "uniform" | "clustered" | "hubs" | "fanout";
+/** The board classes of `EXACT_V1`, in the order of the set. */
+export declare const EXACT_CLASSES: readonly ExactClass[];
+/** The edges of each node of a small board with a known optimum. */
+export declare const EXACT_EDGES_PER_NODE = 1.5;
+/** This function gives the seed of the fixture of the member `k` of a class: `100 × (the index of the class + 1) + k`. */
+export declare function exactSeed(cls: ExactClass, k: number): number;
+/** This function gives the generator of a small board: the generator `fixture` with the kind of the class, `nodes` and the seed of `exactSeed`. */
+export declare function exactGenerator(cls: ExactClass, nodes: number, k: number): LayoutGenerator;
+/** This function makes the small board of a class with `nodes` nodes and the member `k`. The same values always give the same graph. */
+export declare function exactBoard(cls: ExactClass, nodes: number, k: number): Graph;
+/**
+ * This function gives a family of small boards of one class. The member `k` has `sizes[k mod sizes.length]` nodes.
+ * The count of the cell is `10`, because each board has fewer than 100 nodes.
+ */
+export declare function exactFamily(cls: ExactClass, sizes: readonly number[], seeds: number): ScreenFamily;
+/**
+ * The node counts of the boards of `EXACT_V1`. The member `k` of each class has `EXACT_V1_SIZES[k mod length]` nodes.
+ * The size ladder of MEAS2 (CI run 40613531631) proved each optimum at 10 nodes within 300 s, for each class, both rules and the cap 1.5.
+ * At 14 nodes, 4 of 24 solves stopped at the time limit.
+ */
+export declare const EXACT_V1_SIZES: readonly number[];
+/** The number of seeds of each class of `EXACT_V1`. It is `cellMin` of the promotion rule. */
+export declare const EXACT_V1_SEEDS = 10;
+/**
+ * The screen set `exact-v1` (MEAS2): small boards of made-up data with a known optimum of the exact model.
+ * It has 4 classes of 10 seeds. The file `optima-exact-v1.json` of `bench/exact` keeps the optimum of each input, each rule and each cap.
+ * This set does not change. The tests compare it with the files in `corpus/exact-v1`.
+ */
+export declare const EXACT_V1: ScreenSet;
+/** The node counts of the boards of `EXACT_V1_BOUNDS`. HiGHS proves few optima at these sizes within 300 s, so the set keeps bounds (EXACT-BOUNDS). */
+export declare const EXACT_V1_BOUNDS_SIZES: readonly number[];
+/** This function gives the name of the family of a class at a size in `EXACT_V1_BOUNDS`: `<class>-n<nodes>`. */
+export declare function boundsFamilyName(cls: ExactClass, nodes: number): string;
+/**
+ * The screen set `exact-v1-bounds` (EXACT-BOUNDS): the boards of the classes of `exact-v1` at 18, 24 and 40 nodes, with 10 seeds each.
+ * Each family is one class at one size. The member `k` uses the seed `exactSeed(class, k)`, as in `exact-v1`.
+ * The file `optima-exact-v1-bounds.json` of `bench/exact` keeps the best bound and the best solution of each input, each rule and each cap.
+ * 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 options of `follow`. */
 interface FollowOptions extends WayOptions {
   /**
@@ -4378,6 +6343,41 @@ interface SharedStretchOptions {
  * The `seq` of each member follows the order of the stretches along the way.
  */
 export declare function sharedStretches(ways: readonly KeyedWay[], o: Readonly<SharedStretchOptions>): HighwayPlan;
+/** The options of `tracePlan`. */
+interface TraceOptions {
+  /** The side of the grid that the waypoints snap to, in units of the board. The value 0 keeps each waypoint where it is. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /** The key of the ways. Only the ways with one key share a highway. */
+  readonly key: string;
+}
+/**
+ * This function moves a point out of each box, made larger by `pad`. A point in a box moves to the nearest side of that box.
+ * The function tries four times, so a point between two near boxes can stay in a box.
+ */
+export declare function outOfBoxes(obstacles: Obstacles, p: Point, pad: number): Point;
+/**
+ * This function gives the push of the boxes on a point. Each box nearer than `reach` adds a unit vector away from it, times `(reach - d) / reach`.
+ * The value `d` is the distance from the point to the box. It is the gradient of a field that is 0 at the distance `reach` from each box.
+ */
+export declare function boxPush(obstacles: Obstacles, p: Point, reach: number): Point;
+/** This function gives points at equal steps of `step` or a little less along a polyline, without its two ends. A polyline without length gives no point. */
+export declare function innerPoints(line: readonly Point[], step: number): Point[];
+/**
+ * This function gives the way of one edge through its waypoints. The way starts at `a` and ends at `b`.
+ * Each waypoint snaps to the grid of side `snap`. A waypoint in a box moves to the nearest corner of the corner graph.
+ * From each waypoint to the next one, the way is a straight line when that line is clear. Otherwise it goes through the corner graph.
+ * A waypoint that the graph does not reach is not on the way. When the way cannot reach `b`, the function gives the way of the corner graph from `a` to `b`.
+ */
+export declare function waypointWay(finder: WayFinder, a: Point, b: Point, waypoints: readonly Point[], snap: number): Point[] | undefined;
+/**
+ * This function gives the highways of the waypoints of each edge. The ways go through the corner graph, so they stay out of the boxes.
+ * Each edge goes from the point at `margin` from its source plug, through its waypoints, to the point at `margin` from its target plug.
+ * Each stretch that `minSize` ways or more share is one highway, with the needless corners removed.
+ * An edge without waypoints takes its way of the corner graph.
+ */
+export declare function tracePlan(input: HighwayInput, finder: WayFinder, waypoints: ReadonlyMap<string, readonly Point[]>, o: Readonly<TraceOptions>): HighwayPlan;
 /**
  * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
  * The nodes and the edges do not change. Two orders of the same edges give the same graph.
@@ -4486,5 +6486,145 @@ export declare function withRepair(router: Router, options?: RepairOptions): Rou
  * The new strategy has the name `<name>+repair`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
  */
 export declare function repairStrategy<O extends object>(strategy: Strategy<"router", O>, repair?: RepairOptions): Strategy<"router", O>;
-export type { AmbiguityGuardOptions, ArcOptions, BreakEvenOptions, BundleLine, BundleOrder, CandidateSource, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, EdgeGroup, EdgeLengths, EdgePlugs, FieldEnd, FlowFieldOptions, FollowOptions, Gate, GroupSpine, GroupedOptions, Highway, HighwayBase, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, HysteresisOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeyedWay, KeysOptions, LaneCurve, LevelHighwayOptions, MeetOptions, NodeKey, OdCellOptions, QuickBundlesOptions, RoadClassOptions, RoomBends, RoundedOptions, SectionsOptions, SelectOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedStretchOptions, SharedWaysOptions, SmoothOptions, SplineOptions, SplitCell, StableIdOptions, StretchOptions, StubEnds, StubOptions, TrunkFan, TrunkSplit, TrunksOptions, WeiszfeldOptions, WspdOptions, Zip, ZipLimits, ZipperOptions };
+/** The rule of the caller. Under `collection`, a shared segment holds edges of one collection only. Under `all`, collections can mix. */
+export type PortfolioRule = "collection" | "all";
+/** The stretch caps of the portfolio router: the caps of the gap closed (B10). */
+export type PortfolioCap = 1.1 | 1.25 | 1.5;
+/** The rules of the portfolio router. */
+export declare const PORTFOLIO_RULES: readonly PortfolioRule[];
+/** The caps of the portfolio router. */
+export declare const PORTFOLIO_CAPS: readonly PortfolioCap[];
+/** The sizes of the sets of the portfolio router, without the base. */
+export declare const PORTFOLIO_KS_API: readonly (3 | 5 | 8)[];
+/** One size band of the inputs. Each band has its own greedy sets. */
+export interface PortfolioBand {
+  readonly id: string;
+  /** The largest node count of the band. An input with more nodes than the last band uses the last band. */
+  readonly maxNodes: number;
+}
+/** The size bands: up to 12 nodes, 13 to 24 nodes, and 25 to 40 nodes. An input above 40 nodes uses the band `n25-40`. */
+export declare const PORTFOLIO_BANDS: readonly PortfolioBand[];
+/** This function gives the band of a node count: the first band whose `maxNodes` is the count or more, else the last band. */
+export declare function portfolioBand(nodes: number, bands?: readonly PortfolioBand[]): PortfolioBand;
+/**
+ * The fit of each rule, cap and size band, by the key `<rule>|<cap>|<band>`: the members of the default of the portfolio router, in their order.
+ * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 40 ms.
+ * The base `shared` is not in a fit: the portfolio always runs it first.
+ */
+export declare const PORTFOLIO_FIT: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly (readonly [string, number])[]>>;
+/** The id of the B1 level of the key of the portfolio router. */
+export declare const PORTFOLIO_B1 = "B1";
+/** This function gives the spec of the B1 level: higher is better, with the `minEffect` of the row `B1.inkSaved` of the table `MEASURES`. */
+export declare function portfolioB1Spec(): CompareSpec;
+/** The facts of one output that the guard reads. The router takes them from the output, and the script `portfolio.ts` from a record. */
+export interface PortfolioFacts {
+  /** The count of the breaks of each hard rule. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The count of the edges with a stretch above each cap, by the cap. The largest stretch of a record gives 1 or 0. */
+  readonly over: (cap: number) => number;
+  /** The count of the shared segments that hold edges of two collections. */
+  readonly mixed: number;
+}
+/**
+ * This function gives the count of the breaks of the guard of an output against the base, with the rule `rule` and the cap `cap`.
+ * The count is the sum of three parts:
+ * - for each hard rule, the breaks above the breaks of the base
+ * - the edges with a stretch above the cap
+ * - under the rule `collection`, the mixed segments.
+ * An output passes the guard when the count is 0.
+ */
+export declare function guardBreaks(facts: PortfolioFacts, base: PortfolioFacts | undefined, rule: PortfolioRule, cap: number): number;
+/**
+ * This function gives the function of the facts of the outputs on the graph `graph`. It builds the network of the stretch one time for the graph.
+ * The hard rules are the rules of `checkProperties`. The stretch is the stretch of the exact model, as the records of the gap screen give it.
+ */
+export declare function portfolioFacts(graph: Graph): (result: Result) => PortfolioFacts;
+/**
+ * This function gives the key of the portfolio router on the graph `graph`, with the rule `rule` and the cap `cap`.
+ * - `hard` is `guardBreaks` against the output of the base. `base` gives that output after the base runs. The output of the base has 0 breaks.
+ *   Before the base runs, or when the base throws, a member has its own breaks of the hard rules.
+ * - The one level `B1` is the ink saved (higher is better), with the `minEffect` of the table `MEASURES`.
+ * - The hash is `resultHash`.
+ * The winner is the first member with the most B1 of the members with 0 breaks (`selectBest`). The base has 0 breaks, so a member that fails the guard does not win.
+ */
+export declare function portfolioKey(graph: Graph, rule: PortfolioRule, cap: PortfolioCap, base?: () => Result | undefined): PortfolioKey<Graph, Result>;
+/** The name of a built-in highway strategy. */
+type HighwayName = keyof typeof highwayStrategies;
+/**
+ * The form of one member:
+ * - `["shared", options]`, `["trunks", options]` or `["corners", options]`: the router with the options. `shared` and `trunks` use the rule `byCollection`.
+ * - `["highway", name]`: the built-in highway strategy `name`, or `shared-ways-all`, with `follow`.
+ * - `["gate", name, gate, budget?]`: the built-in highway strategy with the gate `stretch`, `breakeven` or `ambiguity`. `budget` sets the budget of the gate `stretch`.
+ * - `["plan", name, options]`: the plan of the built-in highway strategy `name` with other options.
+ */
+export type MemberForm = readonly ["shared", Omit<SharedOptions, "name" | "rule">] | readonly ["trunks", Omit<TrunksOptions, "name" | "rule">] | readonly ["corners", Omit<CornersOptions, "name">] | readonly ["highway", HighwayName | "shared-ways-all"] | readonly ["gate", HighwayName, "stretch" | "breakeven" | "ambiguity", number?] | readonly ["plan", HighwayName, Readonly<Record<string, unknown>>];
+/** The forms of the members, by the names of the records. `shared` is the base. The greedy sets of `sets.ts` name only these members. */
+export declare const MEMBER_FORMS: Readonly<Record<string, MemberForm>>;
+/** This function gives the router strategy of a member form, with the name `name`. */
+export declare function memberStrategy(name: string, form: MemberForm): Strategy<"router", object>;
+/** This function gives the member with the name `name`, or `undefined` for a name without a form in `MEMBER_FORMS`. */
+export declare function portfolioMember(name: string): Strategy<"router", object> | undefined;
+/** The options of the portfolio router. */
+export interface PortfolioRouterOptions {
+  /** The rule of the caller. Under `collection` (the default), a shared segment must hold edges of one collection only. Under `all`, collections can mix. */
+  readonly rule?: PortfolioRule;
+  /** The stretch cap of the caller: 1.1, 1.25 or 1.5 (the default). An output with an edge above the cap does not win. The base is the fallback output. */
+  readonly cap?: PortfolioCap;
+  /**
+   * The count of members after the base: 3, 5 or 8. Without `k` (the default), the router runs the fit of `fit.ts`.
+   * The fit gives a member count for each rule, cap and band, and a node limit for each member. Thus the default is deterministic.
+   */
+  readonly k?: 3 | 5 | 8;
+  /**
+   * A time limit of the pick in milliseconds, as a ceiling that the caller sets. The base always runs. The combinator cuts the members that start after the limit.
+   * A cut by the budget makes the output depend on the speed of the machine. Then the trace has `deterministic: false`.
+   */
+  readonly budgetMs?: number;
+  /** The largest count of members that run, with the base. */
+  readonly maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`. */
+  readonly now?: () => number;
+}
+/** The base member of each portfolio: the router `shared` with the rule `byCollection`. It is the fallback output above the cap. */
+export declare const PORTFOLIO_BASE_MEMBER = "shared";
+/** The result of the portfolio router: the output of the winner, the winner, the trace of the pick, the move counts and the band. */
+export interface PortfolioRoute {
+  readonly result: Result;
+  readonly winner: string;
+  readonly trace: PortfolioTrace;
+  /** The move count of the pick (ACTIVATION): `{ "move.pick": 1 }` when the winner is not the base and has another output. */
+  readonly moves: Readonly<Record<string, number>>;
+  /** The size band of the input, from its node count. */
+  readonly band: string;
+  /** The names of the members, in their order. */
+  readonly members: readonly string[];
+}
+/** This function gives the name of the portfolio router with the options `options`: `portfolio-<rule>-<cap>-k<k>`, or `portfolio-<rule>-<cap>-fit` without `k`. */
+export declare function portfolioName(options?: PortfolioRouterOptions): string;
+/**
+ * This function gives the names of the members for an input with `nodes` nodes. The base comes first.
+ * - With `k`, the first `k` names of the set of the band follow.
+ * - Without `k`, the members of the fit of the band follow, each only when `nodes` is at or below its node limit.
+ */
+export declare function portfolioMembers(nodes: number, options?: PortfolioRouterOptions): string[];
+/**
+ * This function routes the graph `graph` with the portfolio of its size band, rule and cap. The base runs first, then the members in their order.
+ * The key is `portfolioKey`: a member wins only when it passes the guard against the base. Of those members, the winner has the most ink saved.
+ * A tie within the `minEffect` of B1 goes to the first member (`selectBest`). A member that throws does not win.
+ * The result carries the trace of the pick and the move count `move.pick`.
+ */
+export declare function routePortfolio(graph: Graph, options?: PortfolioRouterOptions): PortfolioRoute;
+/** This function gives a router that routes each graph with `routePortfolio` and the options `options`. Its name is `portfolioName(options)`. */
+export declare function portfolioRouter(options?: PortfolioRouterOptions): Router;
+/**
+ * The portfolio router as a router strategy. It is not in the registry `STRATEGIES`, so the benchmark and the site do not race it by default.
+ * A caller adds it to a registry of its own, or calls `routePortfolio` for the trace.
+ */
+export declare const portfolioStrategy: Strategy<"router", PortfolioRouterOptions>;
+/**
+ * The greedy set of each rule, cap and size band, by the key `<rule>|<cap>|<band>`. The set of k strategies is the first k names.
+ * 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 };
 //# sourceMappingURL=index.d.ts.map