@mark1russell7/highways 0.4.1 → 0.4.2

package/build/index.d.ts

@@ -1083,6 +1083,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.
@@ -2742,6 +2750,43 @@ 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 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 +3056,180 @@ 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 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 +3238,223 @@ 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 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 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 `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;
+/** 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;
 /** 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 +3463,156 @@ 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 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 `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 +3699,30 @@ 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 "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[];
@@ -3600,6 +4204,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 +4347,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 +4486,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, BreakEvenOptions, BundleLine, BundleOrder, CandidateSource, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, EdgeGroup, EdgeLengths, EdgePlugs, FieldEnd, FlowFieldOptions, FollowOptions, Gate, GroupSpine, GroupedOptions, Highway, HighwayBase, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, HysteresisOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeyedWay, KeysOptions, LaneCurve, LevelHighwayOptions, MeetOptions, NodeKey, OdCellOptions, QuickBundlesOptions, RoadClassOptions, RoomBends, RoundedOptions, SectionsOptions, SelectOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedStretchOptions, SharedWaysOptions, SmoothOptions, SplineOptions, SplitCell, StableIdOptions, StretchOptions, StubEnds, StubOptions, TrunkFan, TrunkSplit, TrunksOptions, WeiszfeldOptions, WspdOptions, Zip, ZipLimits, ZipperOptions };
 //# sourceMappingURL=index.d.ts.map