@mark1russell7/highways 0.4.1 → 0.5.0

package/build/index.d.ts

@@ -734,6 +734,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 +785,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 +1058,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;
 }
@@ -1083,6 +1112,14 @@ interface HighwayInput {
    * The strategy `corridors` makes the ways of the corner graph, as the router `corners` finds them.
    */
   readonly routes?: Result;
+  /**
+   * This value is the graph before an edit and the plan of the same strategy on it. A strategy that keeps its highways stable over edits reads it.
+   * The gates `hysteresis` (HWY-046) and `ids` (HWY-054) read it. The other strategies ignore it.
+   */
+  readonly previous?: {
+    readonly graph: Graph;
+    readonly plan: HighwayPlan;
+  };
 }
 /**
  * One edge of a highway. The edge joins the spine at the merge point and leaves it at the split point.
@@ -2611,6 +2648,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. */
@@ -2742,6 +2789,129 @@ export interface OrderFragilityOptions {
  * The cost is `orders` extra runs of the router.
  */
 export declare function orderFragility(graph: Graph, route: (graph: Graph) => Result, options?: OrderFragilityOptions): OrderFragility;
+/**
+ * This function gives the churn of the highways over one edit (Z10 for highways, from HWY-046). Two edges are a pair when they share a highway.
+ * The churn is the share of the pairs that come or go: `|P ∆ P'| / |P ∪ P'|`. Only the edges of `edges` count, for example the edges of both graphs.
+ * Two plans without pairs give 0. The scale is 0 to 1, and lower is better.
+ */
+export declare function highwayChurn(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): number;
+/** The match of the highways over one edit. */
+export interface HighwayIdKeep {
+  /** The number of new highways with a match in the old plan: a Jaccard index of their edges of 0.5 or more. */
+  readonly matched: number;
+  /** The number of matched highways that keep the id of their match. */
+  readonly kept: number;
+  /** `kept / matched`, or `NaN` without a match. The scale is 0 to 1, and higher is better. */
+  readonly share: number;
+}
+/**
+ * This function tells how many highways keep their id over one edit (HWY-054). It matches the new highways with the old ones by `matchHighways`, with the index 0.5.
+ * A matched highway keeps its id when its id is the id of its match. Only the edges of `edges` count.
+ */
+export declare function highwayIdKeep(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): HighwayIdKeep;
+/** The stability of a highway strategy over a seeded sequence of edits. Each value is the mean over the edits. */
+export interface HighwayEdits {
+  /** The mean Fréchet distance of the routes over one edit, in units of the board (Z10). */
+  readonly mean: number;
+  /** The share of the routes that move over one edit (Z10). */
+  readonly moved: number;
+  /** The churn of the highways over one edit (`highwayChurn`). */
+  readonly churn: number;
+  /** The share of the matched highways that keep their id over one edit (`highwayIdKeep`), or `NaN` without a match. */
+  readonly ids: number;
+}
+/**
+ * This function measures a highway strategy over a sequence of `edits` seeded edits. Each edit is the small change of `changeGraph` with the seed `seed + i`.
+ * The strategy gets the graph and its plan before the edit as `previous`, so a strategy with memory can keep its highways.
+ * `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`. */
@@ -3011,6 +3181,589 @@ export declare function minHash(keys: Iterable<string>, count: number): number[]
  * The edges of the cluster that are not on the spine make the next highway, while `minSize` of them remain.
  */
 export declare function corridorPlan(input: HighwayInput, o: Readonly<CorridorOptions>): HighwayPlan;
+/**
+ * A gate: a rule that keeps, drops or changes the highways of a plan. `gateStrategy` puts a gate after a highway strategy.
+ * A gate does not move a spine. It takes members out of a highway, drops a highway or changes the id of a highway.
+ */
+interface Gate<G extends object> {
+  /** The name of the gate. The strategy of a gate has the name `<strategy>+<gate>`. */
+  readonly name: string;
+  /** One or two sentences that tell what the gate does. */
+  readonly describe: string;
+  /** The values of the options of the gate. Their keys must not be keys of the options of the strategy before the gate. */
+  readonly defaults: G;
+  readonly schema: OptionSchema<G>;
+  /** This function gives the plan after the gate. `way` holds the options of the way finder of the strategy. */
+  apply(input: HighwayInput, plan: HighwayPlan, options: Readonly<G>, way: WayOptions): HighwayPlan;
+}
+/**
+ * This function puts a gate after a highway strategy. The new strategy has the name `<strategy>+<gate>`, and the options of both.
+ * The strategy gets its own options, and the gate gets the plan of the strategy and the options of the gate.
+ * Thus a gate can follow each plan, for example `corridors+breakeven` or `shared-ways+stretch`. Gates can follow gates.
+ */
+export declare function gateStrategy<O extends object, G extends object>(strategy: Strategy<"highway", O>, gate: Gate<G>): Strategy<"highway", O & G>;
+/**
+ * This function gives the plan with only the members that `keep` accepts. A highway with fewer than two members goes away.
+ * The lanes keep their order, and each highway keeps its id, its key and its spine.
+ */
+export declare function keepMembers(plan: HighwayPlan, keep: (h: Highway, m: HighwayMember) => boolean): HighwayPlan;
+/** The lengths of the route of one edge of a plan. */
+interface EdgeLengths {
+  /** The length of the route along the plan, after `follow`. */
+  readonly route: number;
+  /** The length of the route without a highway: the route of the router `corners`. */
+  readonly alone: number;
+}
+/**
+ * This function gives the length of the route of each edge of a plan, along the plan and alone. `follow` routes each edge of a plan on its own.
+ * Thus the route of an edge does not change when another edge leaves the plan.
+ */
+export declare function edgeLengths(graph: Graph, plan: HighwayPlan, way: WayOptions): Map<string, EdgeLengths>;
+/** This function gives the ids of the edges that both graphs have. */
+export declare function commonEdges(a: Graph, b: Graph): Set<string>;
+/** This function gives the Jaccard index of two sets of edges: the common edges over all edges. Two empty sets give 0. */
+export declare function jaccard(a: ReadonlySet<string>, b: ReadonlySet<string>): number;
+/**
+ * This function matches the highways of a plan with the highways of an earlier plan. It pairs the highways with the largest Jaccard index of their edges first.
+ * A pair needs an index of `min` or more. Each highway is in one pair at most. The result maps the index of a new highway to the index of its old highway.
+ * Only the edges of `edges` count, when this set is present: for example the edges of both graphs.
+ */
+export declare function matchHighways(before: HighwayPlan, after: HighwayPlan, min: number, edges?: ReadonlySet<string>): Map<number, number>;
+/** The options of the gate `ambiguity` (HWY-049). */
+interface AmbiguityGuardOptions {
+  /** Two groups of edges merge only when the merge adds this share of false pairs, or less. The default is 0.5. */
+  readonly maxAmbiguity: number;
+  /** With `node`, the default, two groups merge only when they share an end node. With `any`, only `maxAmbiguity` decides. */
+  readonly link: "node" | "any";
+}
+/** The default options of the gate `ambiguity`. */
+export declare const AMBIGUITY_GUARD_DEFAULTS: Readonly<AmbiguityGuardOptions>;
+/**
+ * This function gives the ambiguity of a set of nodes: the share of the pairs of distinct nodes without an edge between them.
+ * The nodes are the ends of the edges of one highway. A set with fewer than two nodes gives 0.
+ */
+export declare function nodeAmbiguity(nodes: ReadonlySet<string>, adj: ReadonlyMap<string, ReadonlySet<string>>): number;
+/**
+ * This function applies the ambiguity guard of HWY-049 to a plan. A highway joins edges that belong together.
+ *
+ * Two nodes are a false pair when their edges share a highway and no edge joins them. The ambiguity of a group of edges is the share of false pairs among the pairs of its end nodes.
+ * In each highway, each edge starts as a group. Two groups merge only when `amb(A ∪ B) - max(amb A, amb B)` is at most `maxAmbiguity`.
+ * With the link `node`, they also must share an end node. The merge with the smallest rise comes first.
+ *
+ * The largest group stays on the highway. The other edges leave it and go alone.
+ */
+export declare function ambiguityPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<AmbiguityGuardOptions>): HighwayPlan;
+/** The gate `ambiguity` (HWY-049): the ambiguity guard. A highway does not join edges whose end nodes have no edges between them. */
+export declare const ambiguityGate: Gate<AmbiguityGuardOptions>;
+/** The options of the gate `breakeven` (HWY-047). */
+interface BreakEvenOptions {
+  /**
+   * The exponent of the cost law: a stretch with `n` edges costs `n^shareAlpha` times its length. Each edge pays the share `n^(shareAlpha - 1)`.
+   * With 0, a shared stretch is one line, as the ink of B1 counts it. The default is 0.5, as the break-even floor of `corridors`.
+   */
+  readonly shareAlpha: number;
+}
+/** The default options of the gate `breakeven`. */
+export declare const BREAK_EVEN_DEFAULTS: Readonly<BreakEvenOptions>;
+/**
+ * This function applies the break-even law of HWY-047 to a plan. An edge stays on its highways only when sharing saves ink.
+ *
+ * The edge pays `n^(shareAlpha - 1)` of each shared stretch, with `n` the members of the highway. Thus it saves `(1 - n^(shareAlpha - 1)) L` on a stretch of the length `L`.
+ * It adds the length of its route along the plan less the length of its route alone. An edge stays when the saving is as large as the added length.
+ * For two parallel edges at the gap `d`, this rule gives the break-even overlap `d √((2 + t) / (2 - t))` with `t = 2^shareAlpha`.
+ *
+ * An edge that does not save ink leaves each of its highways. Then the other members of those highways save less, so the test repeats until no edge leaves.
+ */
+export declare function breakEvenPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<BreakEvenOptions>, way?: WayOptions): HighwayPlan;
+/** The gate `breakeven` (HWY-047): an edge stays on a highway only when sharing saves ink. */
+export declare const breakEvenGate: Gate<BreakEvenOptions>;
+/** The options of the gate `hysteresis` (HWY-046). */
+interface HysteresisOptions {
+  /** A new highway needs this number of edges or more. The default is 3. */
+  readonly kOn: number;
+  /** A highway of the earlier plan stays while it has this number of edges or more. The default is 2. */
+  readonly kOff: number;
+}
+/** The default options of the gate `hysteresis`. */
+export declare const HYSTERESIS_DEFAULTS: Readonly<HysteresisOptions>;
+/** Two highways of two plans are the same highway when the Jaccard index of their edges is this value or more. */
+export declare const SAME_HIGHWAY = .5;
+/**
+ * This function applies the count threshold with hysteresis of HWY-046 to a plan.
+ * A highway with `kOn` edges or more stays. A highway with fewer than `kOff` edges goes away.
+ * A highway between the two limits stays only when it was in the earlier plan, `input.previous`.
+ * The highway of the earlier plan with the most common edges is its match, with a Jaccard index of `SAME_HIGHWAY` or more.
+ *
+ * Thus an edit that adds or removes one edge near the limit does not make a highway come and go. Without an earlier plan, the limit is `kOn`.
+ */
+export declare function hysteresisPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<HysteresisOptions>): HighwayPlan;
+/** The gate `hysteresis` (HWY-046): a highway forms at `kOn` edges and goes away below `kOff` edges. */
+export declare const hysteresisGate: Gate<HysteresisOptions>;
+/** The options of the gate `ids` (HWY-054). */
+interface StableIdOptions {
+  /** A new highway takes the id of an old highway when the Jaccard index of their edges is this value or more. The default is 0.5. */
+  readonly minJaccard: number;
+}
+/** The default options of the gate `ids`. */
+export declare const STABLE_ID_DEFAULTS: Readonly<StableIdOptions>;
+/**
+ * This function gives stable ids to the highways of a plan (HWY-054). The earlier plan is `input.previous`.
+ * Each new highway takes the id of the old highway with the most common edges.
+ * The pairs with the largest Jaccard index of their edges come first.
+ *
+ * A pair needs an index of `minJaccard` or more, and only the edges of both graphs count.
+ * A new highway without a match gets a new id `h<n>` that no old highway and no new highway has. Thus the old highway of a new id ends.
+ * The gate changes only the ids, so the routes do not change. Without an earlier plan, the plan does not change.
+ */
+export declare function stableIdPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StableIdOptions>): HighwayPlan;
+/** The gate `ids` (HWY-054): stable highway ids across edits. A highway keeps the id of its match in the earlier plan. */
+export declare const stableIdGate: Gate<StableIdOptions>;
+/** The options of the gate `stretch` (HWY-048). */
+interface StretchOptions {
+  /** An edge stays on its highways when its route is at most this number times its route alone, plus `pad`. The default is 1.2. */
+  readonly budget: number;
+  /** The added length that each edge can use, in units of the board. The default is 0. */
+  readonly pad: number;
+}
+/** The default options of the gate `stretch`. */
+export declare const STRETCH_DEFAULTS: Readonly<StretchOptions>;
+/**
+ * This function applies the stretch budget of HWY-048 to a plan: the join test of each edge.
+ * An edge stays on its highways only when its route along the plan is at most `budget` times its route alone, plus `pad`.
+ * The route alone is the route of the router `corners`. An edge that fails leaves each of its highways and goes alone, so the highways do not bend for it.
+ * `follow` routes each edge on its own, so the test of one edge does not change with the other edges. One pass is enough.
+ */
+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 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;
+}
+/** The default options of the strategy `diffusion`. */
+export declare const DIFFUSION_DEFAULTS: Readonly<Required<Omit<DiffusionOptions, "margin" | "k">>>;
+/**
+ * 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 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 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 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.
+ */
+type GroupSpine = "shared" | "trunk";
+/** The values of `GroupSpine`. */
+export declare const GROUP_SPINES: readonly GroupSpine[];
+/** The group of one edge: its key, and `flip` when the edge goes from the second end of the group to the first end. */
+interface EdgeGroup {
+  readonly key: string;
+  readonly flip: boolean;
+}
+/** The options of `groupedPlan`. */
+interface GroupedOptions extends WayOptions {
+  readonly spine: GroupSpine;
+  /** A group has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /**
+   * With the spine `trunk`, an edge rides the trunk only when each of its legs is this share of the span or shorter.
+   * The span is the distance between the two terminals. `Infinity` sets no limit.
+   */
+  readonly legMax?: number;
+}
+/**
+ * This function gives the geometric median of points (the Weber point), with the iterations of Weiszfeld.
+ * The point has the least sum of the distances to the points.
+ */
+export declare function weberPoint(points: readonly Point[], iterations?: number): Point;
+/**
+ * This function gives the highways of the groups of edges. Only the edges in `groups` ride a highway, and each group needs `minSize` edges.
+ * The spine `shared` gives the shared stretches of the router `shared` with the group as the key.
+ * The spine `trunk` gives one trunk for each group, through the corner graph between two terminals.
+ * 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 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 `flow-clusters`. */
+export declare const FLOW_CLUSTER_DEFAULTS: Readonly<FlowClusterOptions>;
+/**
+ * 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 flowDistance(s1: Point, t1: Point, s2: Point, t2: Point, directed: boolean): {
+  d: number;
+  flip: boolean;
+};
+/**
+ * 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 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 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 `hdbscan`. */
+export declare const HDBSCAN_DEFAULTS: Readonly<HdbscanOptions>;
+/**
+ * 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 compatibility(p0: Point, p1: Point, q0: Point, q1: Point): number;
+/**
+ * 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 hdbscanLabels(n: number, d: Float64Array, minClusterSize: number, minSamples: number): Int32Array;
+/**
+ * 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 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;
+}
+/** 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 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 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`. */
+export declare const CANDIDATE_SOURCES: readonly CandidateSource[];
+/** The options of the highway strategy `select` (HWY-045 of the note on highways). */
+interface SelectOptions {
+  /** The generators of the candidates. The default is `corridors`, `quickbundles`, `wspd` and `road-classes`. */
+  readonly generators: readonly CandidateSource[];
+  /** The weight of the added length of the edges against the ink that a highway saves (lambda 3 of the note). The default is 1. */
+  readonly lambda: number;
+  /** The number of passes of the local search with one swap. The default is 2. */
+  readonly swaps: number;
+}
+/** The default options of the strategy `select`. */
+export declare const SELECT_DEFAULTS: Readonly<SelectOptions>;
+/** This function gives the plan of a generator, with its defaults. */
+export declare function candidatePlan(input: HighwayInput, source: CandidateSource): HighwayPlan;
+/**
+ * This function gives the ink that a highway saves. It is the sum of the spine lengths of the members, less the length of their union.
+ * The extra length of a member is its detour from its first route. The detour goes to the merge point, along the spine and back from the split point.
+ */
+export declare function candidateScore(h: Highway, routes: ReadonlyMap<string, readonly Point[]>): {
+  gain: number;
+  extra: number;
+};
+/**
+ * This function gives the highways of the candidate generation and selection (HWY-045). Each generator proposes its highways as candidates.
+ * The net gain of a candidate is the ink that it saves, less `lambda` times the length that it adds to its edges.
+ * Two candidates of two generators conflict when they share an edge. The highways of one generator do not conflict.
+ *
+ * The selection takes the candidates by net gain for each edge, without a conflict. Then each pass of the local search
+ * 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;
+/** 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 `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 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 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">;
 /**
@@ -3019,6 +3772,282 @@ type KeysOptions = Omit<TrunksOptions, "name" | "maxNodes">;
  * 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. */
+  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 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 `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">;
 /**
@@ -3027,6 +4056,273 @@ type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
  * 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`. */
+  readonly from: HighwayBase;
+  /** The weight of the trunk is `k^alpha` for `k` members. With 0, the trunk costs its ink one time. With 1, it costs each lane. The default is 0.5. */
+  readonly alpha: number;
+  /** The number of steps of Weiszfeld. The default is 20. */
+  readonly steps: number;
+}
+/** The default options of the strategy `weiszfeld`. */
+export declare const WEISZFELD_DEFAULTS: Readonly<WeiszfeldOptions>;
+/**
+ * This function gives the meeting points `M1` and `M2` of a bundle with the least weighted ink (HWY-043):
+ * `Σ |a_i - M1| + w |M1 - M2| + Σ |M2 - b_i|`. The lists `a` and `b` are the ends of the edges on each side, and `w` is the weight of the trunk.
+ * The function starts at the means of `a` and `b`. Each step moves `M1` and then `M2` by one step of Weiszfeld.
+ */
+export declare function meetingPoints(a: readonly Point[], b: readonly Point[], w: number, steps: number): [Point, Point];
+/**
+ * This function gives the highways of the plan `from`, with the meeting points of Weiszfeld (HWY-043).
+ * The ends of a member are the points where its edge comes to the highway and goes away from it after `follow` of the plan.
+ * They are the plugs, or the split point of the highway before and the merge point of the highway after.
+ * The weight of the trunk is `k^alpha` for `k` members. The trunk stays on the spine: the function projects `M1` and `M2` on the spine.
+ * Each member then joins the spine at `M1` and leaves it at `M2`, but not outside its own stretch. So a member only gets shorter on the spine.
+ */
+export declare function weiszfeldPlan(input: HighwayInput, o: Readonly<WeiszfeldOptions>): HighwayPlan;
+/** The options of the highway strategy `wspd` (HWY-018 of the note on highways). */
+interface WspdOptions {
+  /** The separation `s` of the pairs: the gap between two sets is at least `s` times the radius of the larger set. The default is 2. */
+  readonly separation: number;
+  /** A pair with this number of edges or more gets a highway. The default is 3. */
+  readonly minSize: number;
+  /** The spine of each pair. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `wspd`. */
+export declare const WSPD_DEFAULTS: Readonly<WspdOptions>;
+/** A cell of the split tree: the points at the places `lo` to `hi - 1` of the order, with their bounding circle. */
+interface SplitCell {
+  readonly id: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly c: Point;
+  readonly r: number;
+  readonly kids?: readonly [SplitCell, SplitCell];
+}
+/**
+ * The split tree of a set of points and its well-separated pairs (Callahan and Kosaraju 1995).
+ * Each cell splits at the middle of the longer side of its bounding box. A cell of equal points is a leaf.
+ */
+export declare class SplitTree {
+  #private;
+  readonly root: SplitCell;
+  /** This constructor builds the tree of the points. */
+  constructor(points: readonly Point[]);
+  /** This method tells if the cell holds the point `i`. */
+  holds(cell: SplitCell, i: number): boolean;
+  /**
+   * This method gives the well-separated pair that holds the pair of points `u` and `v`, with the cell of `u` first.
+   * Each pair of two different points is in one pair of the decomposition. Two equal points give `undefined`.
+   */
+  pairOf(u: number, v: number, s: number): [SplitCell, SplitCell] | undefined;
+}
+/**
+ * This function gives the groups of the edges by the well-separated pair of their two nodes (HWY-018).
+ * The points are the centers of the boxes. The edges of one pair, in either direction, are one group.
+ */
+export declare function wspdGroups(input: HighwayInput, o: Readonly<WspdOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of clustered edge routing with the WSPD (HWY-018, after Bouts and Speckmann 2015).
+ * The well-separated pairs split all the pairs of nodes. The edges of one pair with `minSize` edges or more get one highway from one set to the other.
+ */
+export declare function wspdPlan(input: HighwayInput, o: Readonly<WspdOptions>): HighwayPlan;
+/** The options of the highway strategy `zipper` (NAT-022 with WILD-037 of the notes). */
+interface ZipperOptions {
+  /** The plan whose routes the zipper joins. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two legs zip when they are this distance apart or nearer, in units of the board (the median short side of the boxes). The default is 1. */
+  readonly near: number;
+  /** Two legs zip when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly maxAngle: number;
+  /** The adhesion over the tension: two legs zip when `adhesion * overlap` is more than the length that the zip adds. The default is 0.3. */
+  readonly adhesion: number;
+  /** Two legs zip when they overlap along this length or more, in units of the board. The default is 1. */
+  readonly minOverlap: number;
+  /** The number of passes. Each pass routes the plan and zips the legs again. The default is 1. */
+  readonly passes: number;
+}
+/** The default options of the strategy `zipper`. */
+export declare const ZIPPER_DEFAULTS: Readonly<ZipperOptions>;
+/** A pair of legs that can zip, with the line of the zip. */
+interface Zip {
+  readonly gain: number;
+  /** The first point of the zipped line. */
+  readonly from: Point;
+  /** The last point of the zipped line. */
+  readonly to: Point;
+  /** This value is `true` when the leg goes from `from` to `to`, for each of the two legs. */
+  readonly forward: readonly [boolean, boolean];
+}
+/** The limits of `zipLegs`, in the units of the board. */
+interface ZipLimits {
+  readonly near: number;
+  readonly maxAngle: number;
+  readonly adhesion: number;
+  readonly minOverlap: number;
+}
+/**
+ * This function tells if two legs zip (NAT-022), and gives the zipped line.
+ * The zipped line is the mean of the two legs, with the weight of their lengths, along the stretch where they overlap.
+ * The legs zip when the angle between them is `maxAngle` or less, and they are `near` or nearer along the overlap.
+ * The overlap must be `minOverlap` or more.
+ * The zip adds two jogs to each leg, so it adds the length `2 (d_a + d_b)`, with the distances of the legs to the zipped line.
+ * The legs zip only when `adhesion * overlap` is more than that length.
+ */
+export declare function zipLegs(a0: Point, a1: Point, b0: Point, b1: Point, o: ZipLimits): Zip | undefined;
+/**
+ * This function gives the highways of the plan `from`, with the legs that run near and nearly parallel zipped together (NAT-022, WILD-037).
+ * A pass routes the plan with `follow` and takes each leg that no other route shares. A grid of the legs finds the near pairs.
+ * The pairs that zip (`zipLegs`) go from the largest gain to the smallest, and each leg zips one time in a pass at most.
+ * A zipped line that goes into a box, made larger by 1, does not zip.
+ * Each zip is a new highway of two members. The `seq` of each member follows the place of its merge point along the route of the edge.
+ */
+export declare function zipperPlan(input: HighwayInput, o: Readonly<ZipperOptions>): HighwayPlan;
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
 /** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
@@ -3113,12 +4409,44 @@ export declare const groupStrategies: {
 };
 /**
  * The built-in highway strategies: the decisions of the routers `trunks` and `shared` as plans, and corridor signatures (HWY-031).
+ * The strategies `corridors+<gate>` put a gate of BUILD-W2A after `corridors`: `breakeven` (HWY-047), `stretch` (HWY-048), `ambiguity` (HWY-049),
+ * `hysteresis` (HWY-046) and `ids` (HWY-054). `gateStrategy` puts a gate after any other plan.
  * `follow` routes the edges along a plan, and `highwayRouter` gives a router that does both.
  */
 export declare const highwayStrategies: {
   readonly keys: Strategy<"highway", KeysOptions>;
   readonly "shared-ways": Strategy<"highway", SharedWaysOptions>;
   readonly corridors: Strategy<"highway", CorridorOptions>;
+  readonly meet: Strategy<"highway", MeetOptions>;
+  readonly weiszfeld: Strategy<"highway", WeiszfeldOptions>;
+  readonly stubs: Strategy<"highway", StubOptions>;
+  readonly zipper: Strategy<"highway", ZipperOptions>;
+  readonly "level-links": Strategy<"highway", LevelHighwayOptions>;
+  readonly quickbundles: Strategy<"highway", QuickBundlesOptions>;
+  readonly "road-classes": Strategy<"highway", RoadClassOptions>;
+  readonly "flow-field": Strategy<"highway", FlowFieldOptions>;
+  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 "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
+  readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
+  readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
+  readonly "corridors+hysteresis": Strategy<"highway", CorridorOptions & HysteresisOptions>;
+  readonly "corridors+ids": Strategy<"highway", CorridorOptions & StableIdOptions>;
 };
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 export declare const BUILT_IN_STRATEGIES: readonly AnyStrategy[];
@@ -3280,8 +4608,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[];
@@ -3315,7 +4643,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";
@@ -3441,13 +4769,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.
@@ -3600,6 +4935,12 @@ export interface ScreenOptions {
    * The default is 0: no measure of the order fragility. The steps `group` and `curve` do not read it.
    */
   readonly shuffles?: number;
+  /**
+   * The number of seeded edits of the step `highway` (BUILD-W2A). Each highway strategy runs again after each edit of `highwayEdits`, with its plan before the edit.
+   * The records then get `Z10.edits.*`, the churn of the highways and the share of the highways that keep their id.
+   * The default is 0: no edits. The other steps and the base routers do not read it.
+   */
+  readonly edits?: number;
   /** The commit of the code, for the records. */
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
@@ -3737,6 +5078,37 @@ export declare function highwayRouter<O extends object>(strategy: Strategy<"high
  * The benchmark and the screen race such a router with the other routers.
  */
 export declare function highwayRouterStrategy<O extends object>(strategy: Strategy<"highway", O>): Strategy<"router", O>;
+/** An edge with its two plugs, as the router `corners` places them. */
+interface EdgePlugs {
+  readonly edge: Edge;
+  readonly ps: Plug;
+  readonly pt: Plug;
+}
+/** This function gives the plugs of each edge of the graph, in the order of the edges. An edge with an unknown node is not in the list. */
+export declare function edgePlugs(graph: Graph): EdgePlugs[];
+/** The way of one edge through the corner graph, with a key. Only the ways with one key share a highway. */
+interface KeyedWay {
+  readonly edge: string;
+  readonly key: string;
+  /** The points of the way, without the plugs. Two ways share a link when the link has the same two points. */
+  readonly points: readonly Point[];
+}
+/** The options of `sharedStretches`. */
+interface SharedStretchOptions {
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /** This function tells if a link can be part of a highway. Without it, each link can. */
+  readonly link?: (a: Point, b: Point) => boolean;
+  /** This function removes the needless corners of a spine. Without it, the spine keeps each point of the stretch. */
+  readonly pull?: (points: readonly Point[]) => Point[];
+}
+/**
+ * This function gives a highway for each stretch that two ways or more of one key share. A way is a polyline through the corner graph.
+ * Each way breaks into stretches where the set of the ways on its links stays the same. The router `shared` makes its runs in the same way.
+ * A stretch with fewer than `minSize` ways is not a highway. Each way joins the spine at one end of the stretch and leaves it at the other end.
+ * 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;
 /**
  * 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.
@@ -3845,5 +5217,5 @@ 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 { ArcOptions, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, FollowOptions, Highway, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeysOptions, LaneCurve, NodeKey, RoomBends, RoundedOptions, SectionsOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedWaysOptions, SmoothOptions, SplineOptions, TrunkFan, TrunkSplit, TrunksOptions };
+export type { AmbiguityGuardOptions, ArcOptions, ArcSource, BreakEvenOptions, BundleLine, BundleOrder, CandidateSource, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, DensityImage, DiffusionOptions, EdgeDistance, EdgeGroup, EdgeLengths, EdgePathOptions, EdgePlugs, FieldEnd, FlowClusterOptions, FlowFieldOptions, FollowOptions, Gate, GroupSpine, GroupedOptions, GrowthOptions, GrowthOrder, HdbscanOptions, Highway, HighwayBase, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, HoughOptions, HoughPeak, HubArcOptions, HysteresisOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeyedWay, KeysOptions, LaneCurve, LanesOptions, LevelHighwayOptions, Linkage, MeetOptions, MingleOptions, NestedOptions, NodeKey, OdCellOptions, PathStep, QuickBundlesOptions, Ridge, RidgeOptions, RidgeSource, RoadClassOptions, RoomBends, RoundedOptions, RouteSegment, SectionsOptions, SelectOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedStretchOptions, SharedWaysOptions, SmoothOptions, SnapLine, SnapMember, SnapOptions, SoftKeyOptions, SpiralNode, SpiralOptions, SplineOptions, SplitCell, StableIdOptions, StretchOptions, StubEnds, StubOptions, TraclusOptions, TrunkFan, TrunkSplit, TrunksOptions, WeiszfeldOptions, WspdOptions, Zip, ZipLimits, ZipperOptions };
 //# sourceMappingURL=index.d.ts.map