@mark1russell7/highways 0.4.0 → 0.4.2

package/build/index.d.ts

@@ -983,12 +983,24 @@ export declare const straightRouter: Router;
  * It goes to the target plug on the curve of the rule. This router measures the rule alone.
  */
 export declare const plugsRouter: Router;
+/** The ways to place a free plug of the corner router. */
+type PlugPlace = "facing" | "side";
 /** The options of the corner router. */
 interface CornersOptions extends WayOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
+  /**
+   * The place of a free plug. The default is `facing`: the plug faces the other end (`placePlug`).
+   * With `side`, the search starts from the whole free side, and the plug goes where the way leaves the side (`sidePlugs`, WILD-001).
+   */
+  readonly plugs?: PlugPlace;
+  /**
+   * The least gap between two free plugs of one side. The default is 0: each plug stays where it is.
+   * Above 0, the free plugs of each side keep their order and move the least distance (`justifyPlugs`, WILD-002).
+   */
+  readonly plugGap?: number;
 }
 /**
  * This function makes a router that goes around the nodes.
@@ -996,6 +1008,12 @@ interface CornersOptions extends WayOptions {
  * of the box corners, without the needless corners. It enters the target plug along its normal.
  */
 export declare function cornersRouter(options: CornersOptions): Router;
+/** The cost of a link that edges of one key share: a fixed discount, or the flow cost `len * f^alpha` (EDA-029). */
+type ShareCost = "fixed" | "flow";
+/** The order of the edges of one key: the longest first, the shortest first, the most load first, or the order of the input (NAT-024). */
+type ShareOrder = "span" | "shortest" | "load" | "input";
+/** The place where a route joins or leaves a run: at a corner of the graph, or at the Snell angle (NAT-035). */
+type ShareMerge = "corner" | "snell";
 /** The options of the router with shared ways. */
 interface SharedOptions extends WayOptions {
   /** The name in the benchmark. */
@@ -1006,6 +1024,25 @@ interface SharedOptions extends WayOptions {
   readonly discount?: number;
   /** The lane order of the runs. With `bundle`, the default, two edges keep one order on each run of their common stretch. With `run`, each run gets its order alone. */
   readonly laneOrder?: RunOrder;
+  /**
+   * The cost of a shared link. With `fixed`, the default, a link that the key uses already costs `discount` times its length.
+   * With `flow`, one more edge on a link with `f` edges costs `len * ((f + 1)^alpha - f^alpha)` (EDA-029).
+   */
+  readonly cost?: ShareCost;
+  /** The exponent of the flow cost, from 0.1 to 1. A smaller value gives more sharing. The default is 0.6. Only the cost `flow` uses it. */
+  readonly alpha?: number;
+  /** The number of passes. In each pass after the first, each edge leaves its links and finds its way again with the others fixed (HWY-039). The default is 1. */
+  readonly passes?: number;
+  /**
+   * The order of the edges of one key. With `span`, the default, the longest edge goes first. With `shortest`, the shortest edge goes first.
+   * With `load`, the edge with the most edges between its two sections goes first. With `input`, the edges keep the order of the graph (NAT-024).
+   */
+  readonly order?: ShareOrder;
+  /**
+   * The place where a route joins or leaves a run. With `corner`, the default, it is a corner of the graph.
+   * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
+   */
+  readonly merge?: ShareMerge;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -1046,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.
@@ -1557,11 +1602,29 @@ interface TrunksOptions extends WayOptions {
    * A lane that turns back over the trunk leaves at an earlier point of the trunk. With `split`, each lane leaves at the split point, as in version 0.2.0.
    */
   readonly leave?: TrunkLeave;
+  /**
+   * The place of the split point. With `share`, the default, it is at `split` of the way to the center of the targets.
+   * With `gilbert`, it is where the flow cost of the trunk and its branches is least, with the exponent `alpha` (EDA-030).
+   */
+  readonly splitAt?: TrunkSplit;
+  /** The exponent of the flow cost of the split `gilbert`, from 0 to 1. The default is 0.5. */
+  readonly alpha?: number;
+  /**
+   * The shape of each group. With `split`, the default, the edges share a trunk to a split point.
+   * With `tree`, the edges grow a balancing-factor tree from the plug, with the factor `bf` (NAT-017).
+   */
+  readonly fan?: TrunkFan;
+  /** The balancing factor of the fan `tree`, from 0 to 1. 0 gives the least ink, and a larger factor gives more direct routes. The default is 0.4. */
+  readonly bf?: number;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 /** The place where the lanes of a trunk leave it: where their ways part, or at the split point. */
 type TrunkLeave = "part" | "split";
+/** The place of the split point of a trunk: at a share of the way, or at the Gilbert point of the flow cost (EDA-030). */
+type TrunkSplit = "share" | "gilbert";
+/** The shape of a group of the router `trunks`: a trunk and a split point, or a balancing-factor tree (NAT-017). */
+type TrunkFan = "split" | "tree";
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 export declare const byCollection: GroupRule;
 /**
@@ -1600,6 +1663,17 @@ export declare const ROUTERS: readonly Router[];
 export type LaneOrder = "links" | "ends" | "crossings";
 /** The lane orders of `gapLanes`, in the order of the benchmark. */
 export declare const LANE_ORDERS: readonly LaneOrder[];
+/**
+ * The rule that gives each piece of a gap its lane (its track), after the lane order.
+ *
+ * - `stack`: a piece goes one lane past each piece before it in the order that it overlaps. Thus two pieces that overlap keep their order.
+ * - `left-edge`: the constrained left-edge rule of chip routing (EDA-004). Two pieces that overlap keep their order only where a swap adds crossings.
+ *   The rule fills the lowest lane first, with the pieces sorted by their start. Two pieces that do not overlap can share a lane.
+ * - `free`: the left-edge rule without the order. It gives the fewest lanes, but it can add crossings.
+ */
+export type LaneTracks = "stack" | "left-edge" | "free";
+/** The lane rules of `gapLanes`, in the order of the benchmark. */
+export declare const LANE_TRACKS: readonly LaneTracks[];
 /** The options of `gapLanes`. */
 export interface GapLaneOptions {
   /** The largest distance between two lanes. A narrow gap puts its lanes nearer. The default is 4. */
@@ -1608,6 +1682,21 @@ export interface GapLaneOptions {
   readonly order?: LaneOrder;
   /** Two box edges nearer than this distance make one boundary of the sweep, as in `boardGaps`. The default is 0.5. */
   readonly snap?: number;
+  /** The rule that gives each piece its lane. The default is `stack`. */
+  readonly tracks?: LaneTracks;
+}
+/** The lanes of one gap: the axis and the place of the gap, and the number of lanes that its pieces use. */
+export interface GapLaneCount {
+  readonly axis: "x" | "y";
+  readonly at: number;
+  /** The width of the gap. */
+  readonly width: number;
+  /** The number of lanes of the gap. */
+  readonly lanes: number;
+  /** The number of pieces in the gap: the legs of the links that run along it. */
+  readonly pieces: number;
+  /** The largest number of pieces that overlap at one place of the gap. No rule gives fewer lanes. */
+  readonly density: number;
 }
 /**
  * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
@@ -1615,6 +1704,8 @@ export interface GapLaneOptions {
  * When a move puts a link through more boxes than before, the link keeps its points.
  */
 export declare function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options?: GapLaneOptions): LevelLink[];
+/** This function gives the lanes of each gap that holds a piece of a link, with the options of `gapLanes`. A gap without a piece is not in the list. */
+export declare function gapLaneCounts(items: readonly Boxed[], links: readonly LevelLink[], options?: GapLaneOptions): GapLaneCount[];
 /**
  * The boards of the zoom levels of `levelRoom`.
  *
@@ -2191,6 +2282,42 @@ export interface BendRoomRow extends HighwayMeasures {
 export declare function benchBendRoom(router: Router, fixture: string, graph: Graph, options?: RoomOptions): BendRoomRow[];
 /** This function writes the rows of `benchBendRoom` as a Markdown table. The spacing error is a percent of the spacing. */
 export declare function formatBendRoom(rows: readonly BendRoomRow[]): string;
+/** One row of `benchTracks` (EDA-004): the lanes of the far view of one board with one lane rule of `gapLanes`. */
+export interface TrackBenchRow {
+  readonly fixture: string;
+  /** The board: `given` (the board as it is) or `open` (the board that `makeRoom` opens at gutter 8 and spacing 4). */
+  readonly board: string;
+  readonly tracks: LaneTracks;
+  /** The number of gaps with at least one piece. */
+  readonly gaps: number;
+  /** The sum of the lanes of the gaps. */
+  readonly lanes: number;
+  /** The sum of the densities of the gaps: the most pieces that overlap at one place. No rule gives fewer lanes. */
+  readonly density: number;
+  /** The number of gaps whose lanes are nearer than `spacing`, because the gap is too narrow for its lanes. */
+  readonly squeezed: number;
+  /** The crossings of the links of the far view (`measureQuality`). */
+  readonly crossings: number;
+  /** The ink of the links of the far view. */
+  readonly ink: number;
+  /** R12: the length of parallel legs of two links nearer than `spacing`, as a share of the ink. */
+  readonly separation: number;
+  /** The number of links of the far view that go through a box. */
+  readonly through: number;
+}
+/**
+ * This function gives R12 (lane separation) of the links. Two legs of two links are near when they are parallel and nearer than `near`.
+ * R12 is the length of the near legs, as a share of the ink.
+ * It reads only the legs on an axis. The links of the far view have no other legs.
+ */
+export declare function laneSeparation(links: readonly LevelLink[], near: number): number;
+/**
+ * This function measures each lane rule of `gapLanes` (EDA-004) on the board as it is, and on the board that `makeRoom` opens.
+ * The lane order is `crossings` for each rule. The lanes are `spacing` apart where the gap has room.
+ */
+export declare function benchTracks(fixture: string, graph: Graph, spacing?: number, rules?: readonly LaneTracks[]): TrackBenchRow[];
+/** This function writes the rows of `benchTracks` as a Markdown table. */
+export declare function formatTracks(rows: readonly TrackBenchRow[]): string;
 /** The options of one setting of the router `sections`, without the name. */
 export type SectionsSettingOptions = Omit<SectionsOptions, "name" | "maxNodes">;
 /** One setting of a sweep of the router `sections`. */
@@ -2377,6 +2504,34 @@ export interface AmbiguityOptions {
  * `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
  */
 export declare function ambiguity(graph: Graph, routes: readonly Route[], options?: AmbiguityOptions): Ambiguity;
+/**
+ * This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
+ * An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
+ * The scale is 0 to 1. A higher value is better only in context. The cost is linear.
+ */
+export declare function bundledShare(result: Result): number;
+/** The bundle stretch of the routes against base routes (B3 of MEAS0). */
+export interface BundleStretch {
+  /** The median of `st(e) = L(r_e) / L(r*_e)`. A value of 1 is the length of the base route. Lower is better. */
+  readonly median: number;
+  /** The `0.95` quantile of `st(e)`: the tail of long detours that the bundles add. */
+  readonly q95: number;
+  /** The number of edges with a route in both lists and a base route longer than 1 unit. */
+  readonly edges: number;
+}
+/**
+ * This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
+ * The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
+ * The cost is an extra run of the base router, and then linear.
+ */
+export declare function bundleStretch(routes: readonly Route[], base: readonly Route[]): BundleStretch;
+/**
+ * This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
+ * A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
+ * One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
+ * Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
+ */
+export declare function mergeAngle(routes: readonly Route[]): number;
 /** A joint of a curve: the end of one drawn segment and the start of the next drawn segment. */
 export interface CurveJoint {
   readonly at: Point;
@@ -2558,6 +2713,80 @@ export declare function dominates(a: Readonly<Record<string, number>>, b: Readon
  * The function `values` gives the measures of an item. The front keeps the order of the list. The cost is quadratic in the items.
  */
 export declare function paretoFront<T>(items: readonly T[], values: (item: T) => Readonly<Record<string, number>>, objectives: readonly Objective[]): T[];
+/** The order fragility of a router on one graph (W3 of MEAS3, from WILD-056). */
+export interface OrderFragility {
+  /** The number of random orders. */
+  readonly orders: number;
+  /** `IQR / median` of the crossings (R1) over the orders. A value of 0 is a router that the order does not move. */
+  readonly crossings: number;
+  /** `IQR / median` of the median detour (R5) over the orders. */
+  readonly detour: number;
+  /** `IQR / median` of the ink saved (B1) over the orders. */
+  readonly inkSaved: number;
+  /** `IQR / median` of the ink over the orders. */
+  readonly ink: number;
+  /** The share of the orders whose routes differ from the routes of the input order. A value of 0 is a router that is free of the order. */
+  readonly changed: number;
+  /**
+   * The crossings of the input order divided by the fewest crossings over the orders (the price of anarchy of WILD-056).
+   * A value of 1 is a default order as good as the best random order. It is `NaN` when the best order has 0 crossings and the input order has more.
+   */
+  readonly poa: number;
+}
+/** The options of `orderFragility`. */
+export interface OrderFragilityOptions {
+  /** The number of random orders of the edges. The default is 20. */
+  readonly orders?: number;
+  /** The seed of the first order. The order `k` has the seed `seed + k`. The default is 1. */
+  readonly seed?: number;
+  /** The result of the input order, when the caller has it. Without it, the function routes the input order one time more. */
+  readonly base?: Result;
+}
+/**
+ * This function measures the order fragility of a router on one graph (W3, from WILD-056).
+ * It routes the graph with `orders` random orders of the edges.
+ * It gives the spread `IQR / median` of the crossings, the detour, the ink saved and the ink.
+ * It also gives the share of orders that change a route, and the price of anarchy of the crossings.
+ * 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`. */
@@ -2827,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">;
 /**
@@ -2835,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">;
 /**
@@ -2843,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`. */
@@ -2929,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[];
@@ -3373,6 +4161,13 @@ export type ScreenStep = CompareStep | "highway";
 export declare const SCREEN_STEPS: readonly ScreenStep[];
 /** The routers that the screen of the step `highway` also runs by default. They are the baselines of the note on highways. */
 export declare const HIGHWAY_BASE_ROUTERS: readonly string[];
+/**
+ * A wrapper of each router of a screen. `stable` routes the edges in the stable order of WILD-053 (`stableOrderStrategy`).
+ * `repair` runs the repair step of RULE-046 after the router (`repairStrategy`).
+ */
+export type ScreenWrap = "stable" | "repair";
+/** The wrappers of `ScreenWrap`. */
+export declare const SCREEN_WRAPS: readonly ScreenWrap[];
 /** The hard rules of each step of the screen, in the order of the records. A good run has 0 for each rule. */
 export declare const SCREEN_RULES: Readonly<Record<ScreenStep, readonly string[]>>;
 /** The options of `screen`. */
@@ -3397,8 +4192,24 @@ export interface ScreenOptions {
    * The default is `HIGHWAY_BASE_ROUTERS`. The other steps do not read it.
    */
   readonly baseRouters?: readonly string[];
-  /** The seed of the small change of the stability measures. The default is 1. */
+  /** The seed of the small change of the stability measures, and of the first random order of `shuffles`. The default is 1. */
   readonly seed?: number;
+  /**
+   * The wrappers of each router of the steps `router` and `highway`. Each wrapper `w` adds the router `<name>+<w>` as a new strategy, beside the router `<name>`.
+   * The default is none. The steps `group` and `curve` do not read it.
+   */
+  readonly wrap?: readonly ScreenWrap[];
+  /**
+   * The number of random orders of the edges for the order fragility (W3, from WILD-056). Each router routes each input this number of times more.
+   * 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. */
@@ -3462,6 +4273,8 @@ export interface ScreenReport {
   readonly records: readonly LayoutRecord[];
   readonly summary: ScreenSummary;
 }
+/** This function gives the name of a router without the suffix of a wrapper, for example `shared` for `shared+repair`. */
+export declare function unwrappedName(name: string): string;
 /**
  * This function screens strategies of one step on the inputs of a screen set. It is the cheap test of a new idea before a full build.
  * Each strategy runs on each input with `compareStep`, and each run gives one record of the form `layout-record/1`.
@@ -3534,5 +4347,144 @@ 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>;
-export type { ArcOptions, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, FollowOptions, Highway, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeysOptions, LaneCurve, NodeKey, RoomBends, RoundedOptions, SectionsOptions, SharedOptions, SharedWaysOptions, SmoothOptions, SplineOptions, TrunksOptions };
+/** 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.
+ * The hash spreads the edges, so the stable order does not favor the edges of one node or one collection.
+ */
+export declare function stableOrder(graph: Graph): Graph;
+/** This function gives the graph with its edges in a random order of the seed. The same graph and seed always give the same order. */
+export declare function shuffleEdges(graph: Graph, seed: number): Graph;
+/**
+ * This function routes the graph in the stable order of `stableOrder`, with the function `route`.
+ * The routes come back in the order of the input edges, so the caller sees no change of order.
+ * The bundles, the runs and the levels come from the stable order. Thus each order of the input gives the same data.
+ */
+export declare function routeInStableOrder(graph: Graph, route: (graph: Graph) => Result): Result;
+/** This function gives a router that routes each graph in the stable order of WILD-053. It keeps the name and the `maxNodes` of the router. */
+export declare function withStableOrder(router: Router): Router;
+/**
+ * This function gives a router strategy that runs `strategy` in the stable order of WILD-053. The output does not depend on the order of the input edges.
+ * The new strategy has the name `<name>+stable`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+ */
+export declare function stableOrderStrategy<O extends object>(strategy: Strategy<"router", O>): Strategy<"router", O>;
+/**
+ * The boundary walk of the repair step (RULE-046): a graph of the sides of the boxes.
+ * The vertices are the corners of the boxes. The edges are the parts of each side between two corners on it.
+ * A walk on this graph goes along the boundaries of the boxes, and not through a box. Thus it joins two boxes also when the boxes touch.
+ * The graph drops each part of a side that goes through another box, so overlapping boxes do not open a way.
+ */
+export declare class BoundaryWalk {
+  #private;
+  /** This constructor makes the graph of the sides of the nodes. `grid` holds the nodes by their boxes. */
+  constructor(nodes: readonly Node[], grid: Grid<Node>);
+  /**
+   * This method gives a way along the boundaries of the boxes. The way goes from the point `a` on the box of `s` to the point `b` on the box of `t`.
+   * A point that is not on its box goes first to the nearest point of the boundary.
+   * The method gives `undefined` when no way joins the two boxes.
+   */
+  path(a: Point, s: Node, b: Point, t: Node): Point[] | undefined;
+}
+/** This function gives the point of the boundary of the box that is nearest to `p`. A point on the boundary gives itself. */
+export declare function nearestOnBoundary(box: Box, p: Point): Point;
+/** The options of the repair step (RULE-046). */
+export interface RepairOptions {
+  /** The distance from a box to the corners of a detour, and twice the clearance of a pushed leg. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner of the detour graph. The default is 8. */
+  readonly k?: number;
+  /** With `false`, the step does not push a leg out of a box. The default is `true`. */
+  readonly push?: boolean;
+  /** With `false`, the step takes no detour through the corner graph. The default is `true`. */
+  readonly detour?: boolean;
+  /** With `false`, the step does not route a whole faulty route again through the corner graph. The default is `true`. */
+  readonly reroute?: boolean;
+  /** With `false`, the step does not walk along the boundaries of the boxes. The default is `true`. */
+  readonly walk?: boolean;
+}
+/** The counts of one repair: what the step found and what it did. */
+export interface RepairCounts {
+  /** The number of edges whose two nodes are in the graph. */
+  readonly routes: number;
+  /** The routes with a break of a hard rule before the repair, and the missing routes. */
+  readonly faulty: number;
+  /** The ends that the step moved back to their plugs or to the boxes of their nodes. */
+  readonly snapped: number;
+  /** The legs that the step pushed out of a box. */
+  readonly pushed: number;
+  /** The legs that the step replaced with a detour through the corner graph. */
+  readonly detoured: number;
+  /** The faulty routes that the step routed again from end to end through the corner graph. */
+  readonly rerouted: number;
+  /** The faulty routes that the step replaced with a walk along the boundaries of the boxes. */
+  readonly walked: number;
+  /** The missing routes that the step added. */
+  readonly added: number;
+  /** The faulty routes that the step could not repair. They keep their base routes. */
+  readonly kept: number;
+  /** The edges that the step took out of a run or a bundle. The repaired route of such an edge does not hold the run or the trunk. */
+  readonly unbundled: number;
+  /** The ends of level links that the step moved to the boundaries of their items. */
+  readonly linkEnds: number;
+}
+/** The result of `repairResult`: the repaired result and the counts. */
+export interface RepairReport {
+  readonly result: Result;
+  readonly counts: RepairCounts;
+}
+/**
+ * This function repairs the breaks of the hard rules in the routes of any router (RULE-046). The input result does not change.
+ *
+ * - It adds a route through the corner graph for each edge without a route (`complete`).
+ * - It moves each end back to its fixed plug, or to the nearest point of the box of its node (`ends-at-plugs` and `fixed-plugs`).
+ * - It pushes each inner leg out of a box that it goes through, to the near side of the box (`no-pass-through`).
+ * - It replaces each other leg through a box with a detour through the corner graph.
+ * - When a leg does not repair, it routes the whole route again through the corner graph.
+ *   Else it walks along the boundaries of the boxes (`BoundaryWalk`).
+ * - A route that still breaks a rule keeps its base route.
+ * - It takes an edge out of a run or a bundle when its new route does not hold the run or the trunk (`run-shared` and `bundle-trunk`).
+ * - It moves the ends of each level link to the boundaries of its items (`link-ends`).
+ *
+ * A route without a break does not change. The same input gives the same output.
+ */
+export declare function repairResult(graph: Graph, result: Result, options?: RepairOptions): RepairReport;
+/** This function gives a router that repairs the routes of `router` with `repairResult`. It keeps the name and the `maxNodes` of the router. */
+export declare function withRepair(router: Router, options?: RepairOptions): Router;
+/**
+ * This function gives a router strategy that runs `strategy` and then the repair step (RULE-046) with `repair`.
+ * The new strategy has the name `<name>+repair`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+ */
+export declare function repairStrategy<O extends object>(strategy: Strategy<"router", O>, repair?: RepairOptions): Strategy<"router", O>;
+export type { AmbiguityGuardOptions, ArcOptions, BreakEvenOptions, BundleLine, BundleOrder, CandidateSource, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, EdgeGroup, EdgeLengths, EdgePlugs, FieldEnd, FlowFieldOptions, FollowOptions, Gate, GroupSpine, GroupedOptions, Highway, HighwayBase, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, HysteresisOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeyedWay, KeysOptions, LaneCurve, LevelHighwayOptions, MeetOptions, NodeKey, OdCellOptions, QuickBundlesOptions, RoadClassOptions, RoomBends, RoundedOptions, SectionsOptions, SelectOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedStretchOptions, SharedWaysOptions, SmoothOptions, SplineOptions, SplitCell, StableIdOptions, StretchOptions, StubEnds, StubOptions, TrunkFan, TrunkSplit, TrunksOptions, WeiszfeldOptions, WspdOptions, Zip, ZipLimits, ZipperOptions };
 //# sourceMappingURL=index.d.ts.map