@mark1russell7/highways 0.4.2 → 0.5.0

package/build/index.d.ts

@@ -734,6 +734,8 @@ export declare class CornerGraph {
   constructor(nodes: readonly Node[], obstacles: Obstacles, options: CornerGraphOptions);
   /** This method gives the number of links of the graph. */
   get linkCount(): number;
+  /** This method gives the corners that link to the corner `i`, in the order of their indexes. A corner that is not in the graph gives an empty list. */
+  neighbours(i: number): readonly number[];
   /** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
   nearest(p: Point): number;
   /** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
@@ -783,6 +785,19 @@ export declare class SoftGraph {
    */
   path(from: Point, to: Point, cost: (n: Node) => number): Point[];
 }
+/** The largest distance that `channelWidth` looks on each side of a link. A wider channel counts as this width on that side. */
+export declare const CHANNEL_REACH = 64;
+/**
+ * This function gives the distance from `p` along the unit direction `d` to the box, or `Infinity` when the ray does not meet the box.
+ * A point inside the box gives 0. The function uses the slab test.
+ */
+export declare function rayToBox(p: Point, d: Point, box: Box): number;
+/**
+ * This function gives the width of the channel of the link from `a` to `b`. The width is the free space between the nearest boxes on the two sides.
+ * It measures the width at five points of the link, and gives the smallest. Each side counts up to `reach`.
+ * A link of length 0 gives the free space across the x axis at its point.
+ */
+export declare function channelWidth(obstacles: Obstacles, a: Point, b: Point, reach?: number): number;
 /** The options of a way finder. */
 export interface WayOptions {
   /** The distance from a box to the corners of the graph. The default is 5. */
@@ -1043,6 +1058,20 @@ interface SharedOptions extends WayOptions {
    * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
    */
   readonly merge?: ShareMerge;
+  /**
+   * The pull of the busy links of the pass before (HWY-005, Winding Roads). With a value above 0 and two passes or more, each later pass routes each edge again from no ways.
+   * A link then costs `len / (1 + reuse * u)^reuseExponent`, with `u` the edges of the key on it in the pass before. The default is 0: the later passes are rip-up passes.
+   */
+  readonly reuse?: number;
+  /** The exponent of the pull of `reuse`. The default is 1. */
+  readonly reuseExponent?: number;
+  /**
+   * The cost of a lane that does not fit in its channel (HWY-016). One more edge on a link with `f` edges of the key costs `capacity * max(0, (f + 1) * laneWidth - width)` more.
+   * `width` is the free space across the link (`channelWidth`). The default is 0: the router does not read the channels.
+   */
+  readonly capacity?: number;
+  /** The width of one lane, for `capacity`. The default is 4. */
+  readonly laneWidth?: number;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -2619,6 +2648,16 @@ export declare function positionStability(levels: readonly Level[]): number;
  * A result without such a level gives 1. The cost is `n log n`, with a sample above 1500 items.
  */
 export declare function orderStability(graph: Graph, levels: readonly Level[]): number;
+/**
+ * This function gives the link agreement of the levels with groups (Z9 of MEAS0).
+ * `la = mean over links of hausdorff(link, routes of its edges outside the two items) / u`, with `u` the argument `unit`.
+ * The edges of a link are the edges between a node of one item and a node of the other item, in either direction.
+ *
+ * The function samples each polyline at points `u / 4` apart, with at most 64 points for each polyline. It keeps the points outside the boxes of the two items.
+ * A link without such points on both sides does not count. It gives `undefined` when no link counts.
+ * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
+ */
+export declare function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined;
 /** A grouping of the nodes: a map from the id of each node to the id of its group. */
 export type Grouping = ReadonlyMap<string, string>;
 /** This function gives the grouping of one level: each node goes to the id of its item. */
@@ -2787,6 +2826,92 @@ export interface HighwayEdits {
  * `follow` routes each plan with the way options of the strategy. The same graph, strategy, options and seed give the same values.
  */
 export declare function highwayEdits(graph: Graph, strategy: Strategy<"highway", object>, options: object | undefined, edits: number, seed?: number): HighwayEdits;
+/**
+ * The lane width of the lane measures, in units of the board. The room bench opens the lanes at the same width (`spacing` of `measureBoard`).
+ * R12 also uses it as the smallest correct distance between two parallel legs.
+ */
+export declare const MEASURE_LANE_WIDTH = 4;
+/** The routes of a result with each shared segment open: one lane for each edge. */
+export interface OpenLanes {
+  /** The segments of the result. The shared segments are the runs and the trunks of the bundles. */
+  readonly graph: SegmentGraph;
+  /** The lane route of each edge, from `laneRoutes`. Without a shared segment, the lane routes are the routes. */
+  readonly lanes: readonly Route[];
+  /** The distance between two lanes. */
+  readonly width: number;
+}
+/** This function opens each shared segment of a result: each edge of a run or of a trunk gets its own lane, `width` apart. */
+export declare function openLanes(result: Result, width?: number): OpenLanes;
+/**
+ * This function gives the lane separation of the routes (R12 of MEAS0): the share of the ink that runs too near a parallel leg of other edges.
+ *
+ * A leg is a drawn segment of `S`, and a leg that several routes share counts one time, as in B1. Two legs are near when four things are true.
+ * The sets of their edges are different. They are within `maxAngle` degrees of parallel. Their projections overlap. Their distance is less than `near`.
+ *
+ * `ns = Σ_s length(the part of s that the projections of its near legs cover) / ink(S)`. Each part counts one time, so the scale is 0 to 1.
+ * Lower is better. Routes without ink give 0. A grid of buckets finds the near legs, so the cost is `n log n` for an even density.
+ */
+export declare function routeSeparation(routes: readonly Route[], near?: number, maxAngle?: number): number;
+/**
+ * This function gives the orthogonality of the routes (R14 of MEAS0): `orth = Σ L(legs within maxAngle degrees of an axis) / Σ_e L(r_e)`.
+ * Each route counts its own legs, also on a shared segment. The scale is 0 to 1, and higher is better for an orthogonal style.
+ * Routes without length give 1. The cost is linear.
+ */
+export declare function orthogonality(routes: readonly Route[], maxAngle?: number): number;
+/**
+ * This function counts the lane crossings of the segments of a result (B5 of MEAS0): the pairs of edges whose lane order flips.
+ * Along the route of each edge `e`, it takes the shared segments in order. On each one, another edge `f` is on the left or on the right of `e`, in the way of `e`.
+ *
+ * A pair `(e, f)` counts one time when the side of `f` changes from one shared segment of both edges to the next one.
+ * Lower is better. A result without shared segments gives 0. The cost is the sum of the squares of the edge counts of the shared segments.
+ */
+export declare function laneCrossings(graph: SegmentGraph): number;
+/**
+ * This function gives the occupied area of the routes (B7 of MEAS0): `moa = cells that S touches / cells that the straight lines touch`.
+ * The cells are squares of side `unit` from the origin, and `unit` is `u` of the board (`boardUnit`). The straight line of an edge joins the two ends of its route.
+ * The scale is a ratio, and lower is better. Routes without a straight line give 1. The cost is linear in the cells.
+ */
+export declare function occupiedArea(routes: readonly Route[], unit: number): number;
+/** The run profile of a result (B8 of MEAS0). */
+export interface RunProfile {
+  /** The number of shared segments: the runs and the trunks of the bundles with two edges or more. */
+  readonly runs: number;
+  /** The median of the edges of each shared segment. It is 0 without a shared segment. */
+  readonly median: number;
+  /** The most edges of one shared segment. It is 0 without a shared segment. */
+  readonly max: number;
+}
+/** This function gives the run profile of a result (B8 of MEAS0): the shared segments, and the median and the most edges of each. The cost is linear. */
+export declare function runProfile(graph: SegmentGraph): RunProfile;
+/** The lane fidelity of a result (B9 of MEAS0). */
+export interface LaneFidelity {
+  /** The median of `lf(e)` over the edges with a shared segment. */
+  readonly median: number;
+  /** The largest `lf(e)`. */
+  readonly max: number;
+  /** The number of edges with a shared segment. */
+  readonly edges: number;
+}
+/**
+ * This function gives the lane fidelity (B9 of MEAS0): `lf(e) = frechet(lane(e), r_e) / (width · k / 2)` for each edge `e` with a shared segment.
+ * `lane(e)` is the lane route of `openLanes`, `r_e` is the route, and `k` is the edge count of the widest shared segment of `e`.
+ * `frechet` is the discrete Fréchet distance of the points. A value of 1 or less is correct, and lower is better.
+ * It gives `undefined` when no edge has a shared segment. The cost is quadratic in the points of each route.
+ */
+export declare function laneFidelity(routes: readonly Route[], open: OpenLanes): LaneFidelity | undefined;
+/**
+ * This function counts the lane routes that go through a box that is not one of their ends (M4 of MEAS0).
+ * It is the count `laneThrough` of the room bench (`measureBoard`), for the lanes of any result. Lower is better. The cost is `n log n`.
+ */
+export declare function lanesThrough(graph: Graph, open: OpenLanes): number;
+/**
+ * This function gives the area of a result (M1 of MEAS0) for a router: the growth of the board that the open lanes need.
+ * The value is the area of the bounding box of the boxes and the lane routes. The function divides it by the area of the bounding box of the boxes.
+ *
+ * It is the room form `area(open) / area(packed)` with the boxes as they are. The scale is a ratio of 1 or more, and lower is better.
+ * A board without area gives 1. The cost is linear.
+ */
+export declare function laneArea(graph: Graph, open: OpenLanes): number;
 /** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
 export declare const PROPOSED_RULES: readonly string[];
 /** The options of `runSuite`. */
@@ -3211,6 +3336,415 @@ export declare const STRETCH_DEFAULTS: Readonly<StretchOptions>;
 export declare function stretchPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StretchOptions>, way?: WayOptions): HighwayPlan;
 /** The gate `stretch` (HWY-048): an edge joins a highway only when its route stays in a budget of its route alone. */
 export declare const stretchGate: Gate<StretchOptions>;
+/** The options of the highway strategy `diffusion` (HWY-020 of the note on highways). */
+interface DiffusionOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The share of the density that each step of the diffusion takes from the links next to a link. The default is 0.25. */
+  readonly a: number;
+  /** The number of steps of the diffusion. The default is 3. */
+  readonly steps: number;
+  /** The weight of the density in the cost of a link. The default is 1. */
+  readonly lambda: number;
+  /** The power of the discount of a dense link. The default is 1. */
+  readonly gamma: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `diffusion`. */
+export declare const DIFFUSION_DEFAULTS: Readonly<Required<Omit<DiffusionOptions, "margin" | "k">>>;
+/**
+ * This function gives the density of the edges on the links of the corner graph after the diffusion, as a share of the largest density.
+ * The density of a link starts as the number of first ways on it. Each step mixes it with the mean density of the links that share a corner with it:
+ * `rho_{k+1}(l) = (1 - a) rho_k(l) + a mean(rho_k(l'))`. The key of a link is `i * M + j` for the corners `i < j` of a graph of `M` corners.
+ */
+export declare function linkDensity(neighbours: (i: number) => readonly number[], corners: number, use: ReadonlyMap<number, number>, a: number, steps: number): Map<number, number>;
+/**
+ * This function gives the highways of the route-aware bundling on the corner graph (HWY-020).
+ * The first ways of the edges give the density of each link. A diffusion along the graph smooths it.
+ * Then each edge takes a shortest way where a dense link costs less: `cost(l) = len(l) / (1 + lambda rho(l))^gamma`, with `rho` from 0 to 1.
+ * Each stretch that `minSize` ways or more share after the second pass is one highway. The highways stay on the links of the corner graph.
+ */
+export declare function diffusionPlan(input: HighwayInput, o: Readonly<DiffusionOptions>): HighwayPlan;
+/**
+ * The spine of a group of edges. With `shared`, the edges of each group go through the router `shared` with the group as their key.
+ * Each stretch that they share is a highway. With `trunk`, each group gets one trunk between two terminals, with a leg from each plug.
+ */
+type GroupSpine = "shared" | "trunk";
+/** The values of `GroupSpine`. */
+export declare const GROUP_SPINES: readonly GroupSpine[];
+/** The group of one edge: its key, and `flip` when the edge goes from the second end of the group to the first end. */
+interface EdgeGroup {
+  readonly key: string;
+  readonly flip: boolean;
+}
+/** The options of `groupedPlan`. */
+interface GroupedOptions extends WayOptions {
+  readonly spine: GroupSpine;
+  /** A group has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /**
+   * With the spine `trunk`, an edge rides the trunk only when each of its legs is this share of the span or shorter.
+   * The span is the distance between the two terminals. `Infinity` sets no limit.
+   */
+  readonly legMax?: number;
+}
+/**
+ * This function gives the geometric median of points (the Weber point), with the iterations of Weiszfeld.
+ * The point has the least sum of the distances to the points.
+ */
+export declare function weberPoint(points: readonly Point[], iterations?: number): Point;
+/**
+ * This function gives the highways of the groups of edges. Only the edges in `groups` ride a highway, and each group needs `minSize` edges.
+ * The spine `shared` gives the shared stretches of the router `shared` with the group as the key.
+ * The spine `trunk` gives one trunk for each group, through the corner graph between two terminals.
+ * A terminal is the Weber point of the points out of the plugs at one end of the group. A terminal in a box moves to the nearest of those points.
+ */
+export declare function groupedPlan(input: HighwayInput, groups: ReadonlyMap<string, EdgeGroup>, o: Readonly<GroupedOptions>): HighwayPlan;
+/** The linkage of the hierarchical clustering: the distance of two clusters from the distances of their edges. */
+type Linkage = "average" | "complete" | "single";
+/** The values of `Linkage`. */
+export declare const LINKAGES: readonly Linkage[];
+/** The options of the highway strategy `flow-clusters` (HWY-023 of the note on highways). */
+interface FlowClusterOptions {
+  /** Two clusters join while their distance is this value or less. The distance is a share of the length of the shorter edge. The default is 0.3. */
+  readonly tau: number;
+  /** The linkage. The default is `average`. */
+  readonly linkage: Linkage;
+  /** With `true`, the source of one edge only compares with the source of the other edge. The default is `false`. */
+  readonly directed: boolean;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `trunk`: one flow line from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `flow-clusters`. */
+export declare const FLOW_CLUSTER_DEFAULTS: Readonly<FlowClusterOptions>;
+/**
+ * This function gives the flow distance of two edges (Zhu and Guo 2014): `max(|s_e - s_f|, |t_e - t_f|) / min(len e, len f)`.
+ * Without `directed`, it is the smaller value of the two directions of `f`, and `flip` is `true` when the opposite direction is smaller.
+ */
+export declare function flowDistance(s1: Point, t1: Point, s2: Point, t2: Point, directed: boolean): {
+  d: number;
+  flip: boolean;
+};
+/**
+ * This function clusters the points of a distance matrix with the chain of nearest neighbours. The linkage is reducible, so the chain gives the same tree as the greedy order.
+ * The clusters join while their distance is `tau` or less. The function gives the cluster of each point, as the index of a point of the cluster.
+ */
+export declare function chainClusters(n: number, d: Float64Array, tau: number, linkage: Linkage): Int32Array;
+/**
+ * This function gives the flow clusters of the edges (HWY-023). It clusters the edges as points in 4D, with the cut at `tau`.
+ * Each edge of a cluster gets the key of the cluster. It gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export declare function flowClusters(input: HighwayInput, o: Readonly<FlowClusterOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the flow clusters (HWY-023). The clusters of `flowClusters` with `minSize` edges or more get highways.
+ * With the spine `trunk`, each cluster gets one trunk from one area to the other area. With `shared`, the edges of a cluster share their ways.
+ */
+export declare function flowClusterPlan(input: HighwayInput, o: Readonly<FlowClusterOptions>): HighwayPlan;
+/** The options of the highway strategy `edge-paths` (HWY-012 of the note on highways). */
+interface EdgePathOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** An edge takes a path of other edges only when the path is this many times its own length or less. The default is 2. */
+  readonly distortion: number;
+  /** The weight of a link in the search is its length to this power. A larger power prefers paths of many short links. The default is 2. */
+  readonly power: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `edge-paths`. */
+export declare const EDGE_PATH_DEFAULTS: Readonly<Required<Omit<EdgePathOptions, "margin" | "k">>>;
+/** One step of the path of an edge: the edge of the step and `true` when the path goes from its target to its source. */
+interface PathStep {
+  readonly edge: string;
+  readonly back: boolean;
+}
+/**
+ * This function gives the edge paths of the graph (Wallinger and others 2022). The edges go in the order of their lengths, the longest first.
+ * An edge looks for the shortest path of other edges between its nodes, with the weight `length ^ power`. A path is good when its length is `distortion` times the length of the edge or less.
+ * The edges of a good path lock: they keep their own ways. An edge with a good path leaves the graph of the search. The map holds the path of each such edge.
+ */
+export declare function edgePaths(input: HighwayInput, o: Readonly<Pick<EdgePathOptions, "distortion" | "power">>): Map<string, PathStep[]>;
+/**
+ * This function gives the highways of the edge paths (HWY-012). An edge with a good path follows the ways of the edges of its path.
+ * Each edge of the path keeps its own way through the corner graph. So the ways share their links, and each shared stretch is a highway.
+ */
+export declare function edgePathPlan(input: HighwayInput, o: Readonly<EdgePathOptions>): HighwayPlan;
+/** The distance of two edges: 1 less their compatibility of FDEB, or the flow distance in 4D of HWY-023. */
+type EdgeDistance = "compatibility" | "flow";
+/** The values of `EdgeDistance`. */
+export declare const EDGE_DISTANCES: readonly EdgeDistance[];
+/** The options of the highway strategy `hdbscan` (HWY-028 of the note on highways). */
+interface HdbscanOptions {
+  /** A cluster has this number of edges or more. The default is 3. */
+  readonly minClusterSize: number;
+  /** The core distance of an edge is the distance to its neighbour of this rank. The default is 3. */
+  readonly minSamples: number;
+  /** The distance of two edges. The default is `compatibility`. */
+  readonly distance: EdgeDistance;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `hdbscan`. */
+export declare const HDBSCAN_DEFAULTS: Readonly<HdbscanOptions>;
+/**
+ * This function gives the compatibility of two edges of FDEB (Holten and van Wijk 2009): `Ca Cs Cp Cv`, from 0 to 1.
+ * `Ca` is the angle, `Cs` the scale, `Cp` the position and `Cv` the visibility. The direction of an edge does not change the value.
+ */
+export declare function compatibility(p0: Point, p1: Point, q0: Point, q1: Point): number;
+/**
+ * This function gives the HDBSCAN clusters of the points of a distance matrix (Campello, Moulavi and Sander 2013). The value -1 is noise.
+ * The core distance of a point is the distance to its `minSamples`-th nearest point. The mutual reachability is `max(core(a), core(b), d(a, b))`.
+ * The minimum spanning tree of the mutual reachability gives the tree of the clusters. A split with two parts of `minClusterSize` or more gives two clusters.
+ * The selection keeps the clusters with the largest stability, `sum (lambda_leave - lambda_birth)`, with `lambda = 1 / distance`. The root is not a cluster.
+ */
+export declare function hdbscanLabels(n: number, d: Float64Array, minClusterSize: number, minSamples: number): Int32Array;
+/**
+ * This function gives the HDBSCAN clusters of the edges (HWY-028). The edges that are noise get no group.
+ * Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export declare function hdbscanClusters(input: HighwayInput, o: Readonly<HdbscanOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the HDBSCAN clusters (HWY-028). The clusters that live over a long range of densities are the highways.
+ * The number of highways is not fixed, and the noise edges stay alone.
+ */
+export declare function hdbscanPlan(input: HighwayInput, o: Readonly<HdbscanOptions>): HighwayPlan;
+/** One edge that snaps to a line: the points where it joins and leaves the line, and its place along its own way. */
+interface SnapMember {
+  readonly edge: string;
+  /** The point on the line where the edge joins it. */
+  readonly from: Point;
+  /** The point on the line where the edge leaves it. */
+  readonly to: Point;
+  /** The place of the join along the edge, from 0 at the source to 1 at the target. It orders the highways of one edge. */
+  readonly at: number;
+}
+/** A straight line that a finder gives as the place of a highway, with the edges that snap to it. */
+interface SnapLine {
+  readonly key: string;
+  readonly a: Point;
+  readonly b: Point;
+  readonly members: readonly SnapMember[];
+}
+/** The options of `snapPlan`. */
+interface SnapOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+}
+/** This function gives the line `u d + rho n` of the direction angle `theta`, with `d = (cos, sin)` and the normal `n = (-sin, cos)`. */
+export declare function linePoint(theta: number, rho: number, u: number): Point;
+/**
+ * This function gives the highways of straight lines in the free space. Each line becomes a spine through the corner graph between its two ends.
+ * An end inside a box moves to the nearest corner of the graph.
+ * Each member joins the spine at the place nearest to its point `from`, and leaves it at the place nearest to its point `to`.
+ * A member whose part of the spine is shorter than the margin does not ride. A spine with fewer than `minSize` members is not a highway.
+ * An edge on several highways takes them in the order of `at`.
+ */
+export declare function snapPlan(input: HighwayInput, lines: readonly SnapLine[], o: Readonly<SnapOptions>): HighwayPlan;
+/** This function gives the points of a spine from the place `on` to the place `off`, backward when `on` is larger. */
+export declare function spinePart(spine: readonly Point[], on: number, off: number): Point[];
+/** The options of the highway strategy `hough` (HWY-024 of the note on highways). */
+interface HoughOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The width of the votes in the angle, in degrees. An edge joins a peak within this angle. The default is 8. */
+  readonly dTheta: number;
+  /** The width of the votes in the offset, in units of the board. An edge joins a peak when its middle is this near to the line. The default is 12. */
+  readonly dRho: number;
+  /** A peak with fewer edges than this number is not a corridor. The default is 3. */
+  readonly minVotes: number;
+  /** With `true`, the peaks are only horizontal or vertical lines. The default is `false`. */
+  readonly orthogonal: boolean;
+}
+/** The default options of the strategy `hough`. */
+export declare const HOUGH_DEFAULTS: Readonly<Required<Omit<HoughOptions, "margin" | "k">>>;
+/** A peak of the votes: its angle, its offset and the sum of its votes. */
+interface HoughPeak {
+  readonly theta: number;
+  readonly rho: number;
+  readonly votes: number;
+}
+/**
+ * This function gives the peaks of the votes of the lines (Duda and Hart 1972). Each line votes for its angle and its offset, with a weight of its length.
+ * A vote spreads as a Gaussian with the widths `dTheta / 2` and `dRho / 2`. The accumulator has bins of 1 degree and of `dRho / 4`.
+ * A peak is a bin with a larger sum than each other bin within `dTheta` and `dRho`. The peaks come in the order of their votes.
+ */
+export declare function houghPeaks(lines: readonly {
+  theta: number;
+  mid: Point;
+  len: number;
+}[], o: Readonly<Pick<HoughOptions, "dTheta" | "dRho" | "orthogonal">>): HoughPeak[];
+/**
+ * This function gives the corridors of the votes (HWY-024). Each edge joins the first peak with an angle within `dTheta` and its middle within `dRho` of the line.
+ * The corridor runs over the common span of the projections of its edges on the line. Each edge snaps to the ends of that span.
+ * A member that makes the span shorter than four margins leaves, while the peak keeps `minVotes` edges.
+ */
+export declare function houghLines(input: HighwayInput, o: Readonly<HoughOptions>): SnapLine[];
+/**
+ * This function gives the highways of the Hough votes (HWY-024). The peaks of the votes of the straight lines of the edges are corridors.
+ * Each corridor is a spine through the corner graph, and its edges ride it over their common span.
+ */
+export declare function houghPlan(input: HighwayInput, o: Readonly<HoughOptions>): HighwayPlan;
+/** A generator of candidate highways: a highway strategy with its defaults. */
+type CandidateSource = "corridors" | "quickbundles" | "wspd" | "road-classes" | "flow-field" | "od-cells" | "shared-ways";
+/** The values of `CandidateSource`. */
+export declare const CANDIDATE_SOURCES: readonly CandidateSource[];
+/** The options of the highway strategy `select` (HWY-045 of the note on highways). */
+interface SelectOptions {
+  /** The generators of the candidates. The default is `corridors`, `quickbundles`, `wspd` and `road-classes`. */
+  readonly generators: readonly CandidateSource[];
+  /** The weight of the added length of the edges against the ink that a highway saves (lambda 3 of the note). The default is 1. */
+  readonly lambda: number;
+  /** The number of passes of the local search with one swap. The default is 2. */
+  readonly swaps: number;
+}
+/** The default options of the strategy `select`. */
+export declare const SELECT_DEFAULTS: Readonly<SelectOptions>;
+/** This function gives the plan of a generator, with its defaults. */
+export declare function candidatePlan(input: HighwayInput, source: CandidateSource): HighwayPlan;
+/**
+ * This function gives the ink that a highway saves. It is the sum of the spine lengths of the members, less the length of their union.
+ * The extra length of a member is its detour from its first route. The detour goes to the merge point, along the spine and back from the split point.
+ */
+export declare function candidateScore(h: Highway, routes: ReadonlyMap<string, readonly Point[]>): {
+  gain: number;
+  extra: number;
+};
+/**
+ * This function gives the highways of the candidate generation and selection (HWY-045). Each generator proposes its highways as candidates.
+ * The net gain of a candidate is the ink that it saves, less `lambda` times the length that it adds to its edges.
+ * Two candidates of two generators conflict when they share an edge. The highways of one generator do not conflict.
+ *
+ * The selection takes the candidates by net gain for each edge, without a conflict. Then each pass of the local search
+ * swaps in a candidate. The swap occurs when the net gain of the candidate is more than the sum of the selected candidates in conflict with it.
+ */
+export declare function selectPlan(input: HighwayInput, o: Readonly<SelectOptions>): HighwayPlan;
+/** A generator of candidate arcs: `runs` (the shared stretches of the first ways of all edges) or a generator of the strategy `select`. */
+type ArcSource = "runs" | CandidateSource;
+/** The values of `ArcSource`. */
+export declare const ARC_SOURCES: readonly ArcSource[];
+/** The options of the highway strategy `hub-arcs` (HWY-042 of the note on highways). */
+interface HubArcOptions {
+  /** The largest number of arcs (highways). The default is 12. */
+  readonly q: number;
+  /** The cost of a length on an arc against a length off the arcs, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** An edge rides an arc only when its legs plus its part of the arc are this many times its first route or less. The default is 1.25. */
+  readonly stretch: number;
+  /** The number of passes of the local search with one swap. The default is 1. */
+  readonly swaps: number;
+  /** An arc with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The generators of the candidate arcs. The default is `runs`, `corridors` and `road-classes`. */
+  readonly generators: readonly ArcSource[];
+}
+/** The default options of the strategy `hub-arcs`. */
+export declare const HUB_ARC_DEFAULTS: Readonly<HubArcOptions>;
+/** This function gives the candidate arcs: the spines of the plans of the generators, without the copies, with the longest first. */
+export declare function candidateArcs(input: HighwayInput, generators: readonly ArcSource[]): Point[][];
+/**
+ * This function gives the highways of the hub arc location (Campbell, Ernst and Krishnamoorthy 2005). It chooses at most `q` arcs from the candidates.
+ * An edge on an arc costs its two legs plus `alpha` times its part of the arc. An edge off the arcs costs its first route.
+ * The greedy step adds the arc that saves the most cost. Then each swap pass changes one chosen arc for one other arc while the saving grows.
+ * Each edge rides the arc that saves the most for it.
+ */
+export declare function hubArcPlan(input: HighwayInput, o: Readonly<HubArcOptions>): HighwayPlan;
+/** The lines that make the density: the straight lines of the edges, or their first routes. */
+type RidgeSource = "lines" | "routes";
+/** The options of the highway strategy `ridges` (HWY-032 of the note on highways). */
+interface RidgeOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The lines of the density. The default is `lines`. */
+  readonly source: RidgeSource;
+  /** The side of a cell of the density image, in units of the board. The default is 8. A large board gets larger cells, up to 1024 cells on a side. */
+  readonly cell: number;
+  /** The width of the blur, in units of the board. The default is 16. */
+  readonly bandwidth: number;
+  /** A ridge cell has this share of the largest strength or more. The default is 0.15. */
+  readonly strength: number;
+  /** A ridge has this length or more, in units of the board. The default is 60. */
+  readonly minLength: number;
+  /** An edge snaps to a ridge when its line is this near to the ridge, in units of the board. The default is 16. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `ridges`. */
+export declare const RIDGE_DEFAULTS: Readonly<Required<Omit<RidgeOptions, "margin" | "k">>>;
+/** The density image: the cells, its size, and the place of its first cell. */
+interface DensityImage {
+  readonly w: number;
+  readonly h: number;
+  readonly cell: number;
+  readonly x0: number;
+  readonly y0: number;
+  readonly rho: Float64Array;
+}
+/**
+ * This function gives the density of the polylines on a grid of cells, after a Gaussian blur of the width `bandwidth`.
+ * Each polyline adds 1 to each cell that it goes through, one time for each polyline.
+ */
+export declare function lineDensity(lines: readonly (readonly Point[])[], box: {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}, cellSize: number, bandwidth: number): DensityImage;
+/** One ridge: its two ends and the length between them. */
+interface Ridge {
+  readonly a: Point;
+  readonly b: Point;
+}
+/**
+ * This function gives the ridges of a density image (Lindeberg 1998). A ridge cell has a negative eigenvalue of the Hessian with the larger size.
+ * Its density is a maximum along the eigenvector of that eigenvalue. Its strength is the density times the size of that eigenvalue.
+ * The cells with `strength` times the largest strength or more join their neighbours with a direction within 30 degrees.
+ * Each group of cells gives the segment of its main axis. A segment of `minLength` or more is a ridge. The ridges come in the order of their total strength.
+ */
+export declare function densityRidges(img: DensityImage, strength: number, minLength: number): Ridge[];
+/**
+ * This function gives the lines of the ridges (HWY-032), each with the edges that snap to it.
+ * An edge snaps to a ridge when the part of its line near the ridge is half of `minLength` or longer.
+ * The angle between the edge and the ridge is 30 degrees or less.
+ * The edge joins and leaves the ridge at the ends of that part. When two ridges hold one part of an edge, only the longer part rides.
+ */
+export declare function ridgeLines(input: HighwayInput, o: Readonly<RidgeOptions>): SnapLine[];
+/**
+ * This function gives the highways of the ridges of the line density (HWY-032). One pass draws the density, with no advection.
+ * The ridges of the density are the spines, and the edges near a ridge snap to it between their nearest entry and exit points.
+ */
+export declare function ridgePlan(input: HighwayInput, o: Readonly<RidgeOptions>): HighwayPlan;
+/** The options of the highway strategy `soft-keys` (HWY-019 of the note on highways). */
+interface SoftKeyOptions {
+  /** The rule that gives the key of each edge. The default is `byCollection`: the string `data.collection`. */
+  readonly rule: GroupRule;
+  /** The distance that two different keys add. `Infinity` keeps the edges of two keys apart, as the hard keys do. The default is 0.25. */
+  readonly lambda: number;
+  /** Two clusters join while their distance is this value or less. The default is 0.5. */
+  readonly tau: number;
+  /** The names of number fields of `data` that add a distance. The default is no field. */
+  readonly attributes: readonly string[];
+  /** The weight of each field of `attributes`. The distance of a field is its difference over its range. The default is 1. */
+  readonly weight: number;
+  /** The linkage of the clustering. The default is `average`. */
+  readonly linkage: Linkage;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`: the router `shared` with the cluster as the key. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `soft-keys`. */
+export declare const SOFT_KEY_DEFAULTS: Readonly<SoftKeyOptions>;
+/**
+ * This function gives the soft-key distance of two edges (Peysakhovich, Hurter and Telea 2015): `d = d_geom + lambda [key(e) != key(f)] + sum_a w |a(e) - a(f)| / range(a)`.
+ * `d_geom` is the flow distance of HWY-023. The key term is 0 when an edge has no key.
+ */
+export declare function softDistance(geom: number, keyA: string | undefined, keyB: string | undefined, lambda: number, attributes: number): number;
+/**
+ * This function gives the soft-key clusters of the edges (HWY-019). It clusters the edges with `softDistance`, with the cut at `tau`.
+ * Each edge of a cluster gets the key of the cluster. It gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export declare function softKeyClusters(input: HighwayInput, o: Readonly<SoftKeyOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the soft keys (HWY-019). The key of an edge is one more term of the distance, not a hard split.
+ * Edges of two keys still share a highway when they are very near, and edges of one key do not bundle when they are far.
+ */
+export declare function softKeyPlan(input: HighwayInput, o: Readonly<SoftKeyOptions>): HighwayPlan;
 /** The end of the edges that gets a field: the target of a fan-in, or the source of a fan-out. */
 type FieldEnd = "target" | "source";
 /** The options of the highway strategy `flow-field` (EDA-046 with HWY-037 of the notes). */
@@ -3299,41 +3833,36 @@ export declare function meetMember(spine: readonly Point[], member: HighwayMembe
  * 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. */
+/** The options of the highway strategy `mingle` (HWY-003 of the note on highways). */
+interface MingleOptions {
+  /** Each bundle looks for a merge among this number of nearest bundles in 4D. The default is 8. */
+  readonly k: number;
+  /** The largest turn of an edge at a meeting point, in degrees. A larger turn moves the meeting point along the trunk. The default is 40. */
+  readonly maxTurn: number;
+  /** The number of levels of merges. The default is 6. */
+  readonly levels: number;
+  /** The weight of the trunk in the ink. With 1, the trunk costs its length one time. The default is 1. */
+  readonly weight: number;
+  /** A bundle with this number of edges or more gets highways. The default is 2. */
   readonly minSize: number;
-  /**
-   * 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;
+  /** The spine of each bundle. The default is `trunk`: one trunk between the two meeting points. */
+  readonly spine: GroupSpine;
 }
+/** The default options of the strategy `mingle`. */
+export declare const MINGLE_DEFAULTS: Readonly<MingleOptions>;
 /**
- * This function gives the geometric median of points (the Weber point), with the iterations of Weiszfeld.
- * The point has the least sum of the distances to the points.
+ * This function gives the bundles of MINGLE (Gansner, Hu, North and Scheidegger 2011) as groups of edges.
+ * Each edge is a point in 4D: its two plugs. At each level, each bundle examines its `k` nearest bundles in 4D.
+ * A merge saves ink when the ink of the joint bundle is less than the sum of the two inks. The merges with the largest gain go first.
+ * A bundle merges one time at most in a level. The levels stop after `levels` levels, or when no merge saves ink.
  */
-export declare function weberPoint(points: readonly Point[], iterations?: number): Point;
+export declare function mingleBundles(input: HighwayInput, o: Readonly<MingleOptions>): Map<string, EdgeGroup>;
 /**
- * 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.
+ * This function gives the highways of MINGLE (HWY-003). The bundles of `mingleBundles` with `minSize` edges or more get highways.
+ * With the spine `trunk`, each bundle gets one trunk between its two meeting points, through the corner graph.
+ * With `shared`, the edges of each bundle share their ways through the corner graph.
  */
-export declare function groupedPlan(input: HighwayInput, groups: ReadonlyMap<string, EdgeGroup>, o: Readonly<GroupedOptions>): HighwayPlan;
+export declare function minglePlan(input: HighwayInput, o: Readonly<MingleOptions>): HighwayPlan;
 /** The options of the highway strategy `od-cells` (EDA-033 with WILD-032 of the notes). */
 interface OdCellOptions {
   /** The depth of the cells in the tree of sections. Depth 1 is the level below the root. The default is 2. */
@@ -3402,6 +3931,104 @@ export declare function quickBundles(input: HighwayInput, o: Readonly<QuickBundl
  * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
  */
 export declare function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan;
+/** The options of the highway strategy `nested` (HWY-052 of the note on highways). */
+interface NestedOptions {
+  /** The scale of the closest level, in units of the board. An edge joins a cluster when its distance to the centroid is this value or less. The default is 3. */
+  readonly theta: number;
+  /** The scale of each level is this value times the scale of the next closer level. The default is 2. */
+  readonly ratio: number;
+  /** The number of levels. The default is 3. */
+  readonly levels: number;
+  /** The level of the plan. Level 0 is the closest level, and level `levels - 1` is the far level. The default is 0. */
+  readonly level: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `nested`. */
+export declare const NESTED_DEFAULTS: Readonly<NestedOptions>;
+/**
+ * This function gives the groups of edges of each level, from the closest level (index 0) to the far level.
+ * The far level puts all the edges in clusters at the scale `theta × ratio^(levels - 1)`.
+ * Each closer level puts the edges of each cluster of the level above in clusters, at its own scale. Thus each group of a level is in one group of the level above.
+ */
+export declare function nestedGroups(input: HighwayInput, o: Readonly<NestedOptions>): Map<string, EdgeGroup>[];
+/**
+ * This function gives the number of groups of the closer level `fine` with edges in two groups or more of the level `coarse`.
+ * An edge that is not in `coarse` does not count. The groups of `nestedGroups` give 0.
+ */
+export declare function nestingViolations(coarse: ReadonlyMap<string, EdgeGroup>, fine: ReadonlyMap<string, EdgeGroup>): number;
+/**
+ * This function gives the highways of one level of the nested clusters (HWY-052). The level is `o.level`, with 0 as the closest level.
+ * The clusters of that level with `minSize` edges or more get highways, as in the strategy `quickbundles`.
+ */
+export declare function nestedPlan(input: HighwayInput, o: Readonly<NestedOptions>): HighwayPlan;
+/** The options of the highway strategy `lanes` (HWY-051 of the note on highways). */
+interface LanesOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The plan that the strategy changes. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The gap between two lanes. The default is 4. */
+  readonly laneGap: number;
+  /** The largest width of a highway. The default is 32. */
+  readonly maxWidth: number;
+  /** The number of times that a highway can split, one half after the other. The default is 3. */
+  readonly depth: number;
+}
+/** The default options of the strategy `lanes`. */
+export declare const LANES_DEFAULTS: Readonly<LanesOptions>;
+/**
+ * This function gives the number of legs of the spines of a plan where the lanes do not fit in the channel.
+ * A leg with two lanes or more needs `min(maxWidth, lanes × laneGap)`. The channel is the free space across the leg (`channelWidth`).
+ */
+export declare function channelOverflows(graph: Graph, plan: HighwayPlan, o: Readonly<Pick<LanesOptions, "laneGap" | "maxWidth" | "margin" | "k">>): number;
+/**
+ * This function gives the plan of `from`, with each highway that does not fit in its channels split in two (HWY-051).
+ * The lanes split into two halves by lane order. The first half keeps the spine. The second half gets a new spine through the corners, where the narrow links cost more.
+ * A highway with fewer than four lanes moves as one to the new spine.
+ * A half that still does not fit splits again, up to `depth` times. A new spine needs a shorter length of narrow legs than the old spine.
+ */
+export declare function lanesPlan(input: HighwayInput, o: Readonly<LanesOptions>): HighwayPlan;
+/** The order of the edges in the growth: the longest first route first, or the order of the graph. */
+type GrowthOrder = "length" | "input";
+/** The options of the highway strategy `growth` (HWY-055 of the note on highways). */
+interface GrowthOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The order of the edges. The default is `length`. */
+  readonly order: GrowthOrder;
+  /** The cost of the part on a spine, as a share of its length. The ramps cost their full length. The default is 0.5. */
+  readonly share: number;
+  /** An edge joins a highway only when its way along it is this value times its first route or shorter. The default is 1.3. */
+  readonly stretch: number;
+  /** A spine end extends when this number of its lanes or more go on together. The default is 3. */
+  readonly extendLanes: number;
+  /** The lanes go on together when their ends are this distance from their center or nearer, in units of the board. The default is 2. */
+  readonly extendRadius: number;
+  /** A highway with this number of edges or more stays in the plan. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `growth`. */
+export declare const GROWTH_DEFAULTS: Readonly<GrowthOptions>;
+/**
+ * This function gives the highways of local growth (HWY-055). The edges come one by one, by default the longest first route first.
+ * Each edge joins the highway with the largest saving: its first route less its ramps and `share` of its part on the spine. Without a saving, the edge starts a highway on its own way.
+ * After the growth, a spine end can go on to the center of the far ends of its lanes.
+ * This occurs when `extendLanes` of them or more are near that center and the line is clear.
+ */
+export declare function growthPlan(input: HighwayInput, o: Readonly<GrowthOptions>): HighwayPlan;
 /** The options of the highway strategy `road-classes` (HWY-034 with EDA-050 of the notes). */
 interface RoadClassOptions extends Pick<WayOptions, "margin" | "k"> {
   /** A link is a highway link when its use is at this quantile of the use of the links, or higher. The default is 0.9. */
@@ -3421,40 +4048,6 @@ export declare const ROAD_CLASS_DEFAULTS: Readonly<Required<Omit<RoadClassOption
  * 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">;
 /**
@@ -3463,6 +4056,51 @@ type SharedWaysOptions = Omit<SharedOptions, "name" | "maxNodes">;
  * The function does not change the router: it reads its runs.
  */
 export declare function sharedWaysPlan(input: HighwayInput, options: SharedWaysOptions): HighwayPlan;
+/** The options of the highway strategy `spiral` (HWY-017 with EDA-035 of the notes). */
+interface SpiralOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The spiral angle, in degrees: the largest angle between a branch and the line to the root. The default is 25. */
+  readonly alpha: number;
+  /** A node with this number of edges or more gets a spiral tree. The default is 4. */
+  readonly minTargets: number;
+  /** The number of points of the arc of each branch. The default is 4. */
+  readonly arc: number;
+}
+/** The default options of the strategy `spiral`. */
+export declare const SPIRAL_DEFAULTS: Readonly<Required<Omit<SpiralOptions, "margin" | "k">>>;
+/** One node of a spiral tree, in polar coordinates around the root. A leaf has an edge, and a join has two children. */
+interface SpiralNode {
+  readonly r: number;
+  readonly theta: number;
+  readonly point: Point;
+  /** A join with this node is this distance or more nearer to the root than the node. A leaf keeps its box clear so. A join has 0. */
+  readonly clear: number;
+  readonly edge?: string;
+  readonly children: readonly SpiralNode[];
+}
+/**
+ * This function gives the join of the nodes `p` and `q` of a spiral tree with the angle `alpha`. It gives `undefined` when no join is possible.
+ * Each node can reach the points inside its two spirals toward the root: `|theta - theta_p| <= tan(alpha) ln(r_p / r)`.
+ * The join is the point farthest from the root that both nodes reach, and that is `clear` nearer to the root than each node.
+ * At that radius, the join is at the middle of the angles that both nodes reach.
+ */
+export declare function spiralJoin(p: SpiralNode, q: SpiralNode, alpha: number, root: Point): {
+  r: number;
+  theta: number;
+  point: Point;
+} | undefined;
+/**
+ * This function gives the spiral tree of the leaves around the root (Buchin, Speckmann and Verbeek 2011), with the greedy sweep.
+ * The sweep goes from the far leaves to the root. A leaf joins the wavefront at its radius. Two nodes that are next to each other in angle join at their join point.
+ * The join with the largest radius goes first. No join occurs below the radius `rMin`. The function gives the nodes of the wavefront at the end.
+ */
+export declare function spiralTree(leaves: readonly SpiralNode[], alpha: number, root: Point, rMin: number): SpiralNode[];
+/**
+ * This function gives the highways of the spiral trees (HWY-017, EDA-035). Each node with `minTargets` edges or more is the root of a fan.
+ * The nodes with more edges go first, and each edge is in one fan at most. The far plug of each edge is a leaf of the tree of its fan.
+ * Each branch of a tree with two leaves or more is a highway. Its spine is an arc of a logarithmic spiral, or a way through the corner graph where the arc hits a box.
+ * An edge rides the branches from the root to its leaf, or from its leaf to the root when the root is its target.
+ */
+export declare function spiralPlan(input: HighwayInput, o: Readonly<SpiralOptions>): HighwayPlan;
 /** The ends of the edges that get stubs: the source ends, the target ends, or both. */
 type StubEnds = "source" | "target" | "both";
 /** The options of the highway strategy `stubs` (HWY-015 with WILD-005 of the notes). */
@@ -3490,6 +4128,78 @@ export declare const STUB_DEFAULTS: Readonly<StubOptions>;
  * An end with a fixed plug or a side of its own gets no stub. An end whose first highway starts on its box, or near it, keeps the plan.
  */
 export declare function stubPlan(input: HighwayInput, o: Readonly<StubOptions>): HighwayPlan;
+/** The options of the highway strategy `traclus` (HWY-025 of the note on highways). */
+interface TraclusOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two segments are neighbours when their distance is this value or less, in units of the board. The default is 2. */
+  readonly eps: number;
+  /** A cluster has segments of this number of edges or more, and a core segment has this number of neighbours or more. The default is 3. */
+  readonly minLns: number;
+  /** The weight of the perpendicular distance. The default is 1. */
+  readonly wPerp: number;
+  /** The weight of the parallel distance. The default is 1. */
+  readonly wPar: number;
+  /** The weight of the angle distance. The default is 1. */
+  readonly wTheta: number;
+  /** A route keeps a corner when the cost of the line without it is more than this value times the cost with it. The default is 1. */
+  readonly mdl: number;
+}
+/** The default options of the strategy `traclus`. */
+export declare const TRACLUS_DEFAULTS: Readonly<Required<Omit<TraclusOptions, "margin" | "k">>>;
+/** One segment of a partitioned route: the edge, the index of the segment in the route, and its two ends. */
+interface RouteSegment {
+  readonly edge: string;
+  readonly index: number;
+  readonly a: Point;
+  readonly b: Point;
+}
+/**
+ * This function gives the TRACLUS distance of two segments (Lee, Han and Whang 2007): `w_perp d_perp + w_par d_par + w_theta d_theta`.
+ * `d_perp` is `(l1² + l2²) / (l1 + l2)` with the distances of the ends of the shorter segment to the line of the longer segment.
+ * `d_par` is the gap along the longer segment between the two segments, 0 when they overlap. `d_theta` is `|shorter| sin(theta)`.
+ * The segments have no direction, so the angle is 90 degrees or less.
+ */
+export declare function segmentDistance(p: {
+  a: Point;
+  b: Point;
+}, q: {
+  a: Point;
+  b: Point;
+}, w: {
+  perp: number;
+  par: number;
+  theta: number;
+}): number;
+/**
+ * This function gives the characteristic points of a route by the rule of the minimum description length (MDL) of TRACLUS.
+ * A partition from point `i` to point `j` costs `L(H) + L(D|H)`. `L(H)` is the log of its length, and `L(D|H)` the logs of the perpendicular and angle distances of the route parts.
+ * The route keeps the point before `j` when that cost is more than `ratio` times the cost of the route parts. The lengths are in units of the board.
+ */
+export declare function characteristicPoints(route: readonly Point[], unit: number, ratio: number): Point[];
+/**
+ * This function gives the clusters of segments of DBSCAN. A segment with `minLns` neighbours or more within `eps` (itself included) is a core segment.
+ * A cluster grows from each core segment through its neighbours. A cluster with segments of fewer than `minLns` edges is dropped.
+ */
+export declare function segmentClusters(segments: readonly RouteSegment[], eps: number, minLns: number, w: {
+  perp: number;
+  par: number;
+  theta: number;
+}): RouteSegment[][];
+/**
+ * This function gives the representative line of a cluster of segments. The line goes along the mean direction of the segments.
+ * A sweep along that direction stops at each end of a segment. Where `minLns` segments or more cover the stop, the point is the mean of their points there.
+ * Two points of the line are at least `gap` apart.
+ */
+export declare function representative(cluster: readonly RouteSegment[], minLns: number, gap: number): Point[];
+/**
+ * This function gives the highways of TRACLUS (HWY-025). Each first route breaks into a few long segments by the rule of MDL.
+ * DBSCAN puts the segments that are near in distance and angle into clusters. Each cluster with segments of `minLns` edges or more is one highway.
+ * The spine is the representative line of the cluster, or a way through the corner graph between its ends when the line hits a box.
+ * Each edge of the cluster joins the spine nearest to the first end of its segments. It leaves the spine nearest to the last end.
+ * An edge rides only when both ends of its part are within `eps` of the spine.
+ * Its length on the spine is also at most 1.25 times the length of its own route there.
+ * Each edge rides one highway at most: the highway where it rides the longest length.
+ */
+export declare function traclusPlan(input: HighwayInput, o: Readonly<TraclusOptions>): HighwayPlan;
 /** The options of the highway strategy `weiszfeld` (HWY-043 of the note on highways). */
 interface WeiszfeldOptions {
   /** The plan whose highways get new meeting points. The default is `shared-ways`. */
@@ -3718,6 +4428,20 @@ export declare const highwayStrategies: {
   readonly wspd: Strategy<"highway", WspdOptions>;
   readonly "od-cells": Strategy<"highway", OdCellOptions>;
   readonly select: Strategy<"highway", SelectOptions>;
+  readonly mingle: Strategy<"highway", MingleOptions>;
+  readonly spiral: Strategy<"highway", SpiralOptions>;
+  readonly "flow-clusters": Strategy<"highway", FlowClusterOptions>;
+  readonly traclus: Strategy<"highway", TraclusOptions>;
+  readonly diffusion: Strategy<"highway", DiffusionOptions>;
+  readonly nested: Strategy<"highway", NestedOptions>;
+  readonly lanes: Strategy<"highway", LanesOptions>;
+  readonly growth: Strategy<"highway", GrowthOptions>;
+  readonly "edge-paths": Strategy<"highway", EdgePathOptions>;
+  readonly "soft-keys": Strategy<"highway", SoftKeyOptions>;
+  readonly hough: Strategy<"highway", HoughOptions>;
+  readonly ridges: Strategy<"highway", RidgeOptions>;
+  readonly hdbscan: Strategy<"highway", HdbscanOptions>;
+  readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -3884,8 +4608,8 @@ export interface LayoutBox {
   readonly parent?: string;
   /** The group of the box. */
   readonly group?: string;
-  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
-  readonly locked?: true;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. `false` is the same as no value. The router ignores it. */
+  readonly locked?: boolean;
   /** The reading order that the caller wants. The router ignores it. */
   readonly rank?: number;
   readonly ports?: readonly LayoutPort[];
@@ -3919,7 +4643,7 @@ export interface LayoutGenerator {
  * The packer reads the first six dimensions. The router reads the last four.
  */
 export interface LayoutCell {
-  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
   readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
   readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
   readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
@@ -4045,13 +4769,20 @@ export declare function regionBounds(region: Region): {
   w: number;
   h: number;
 };
+/**
+ * The fields of an input that `inputGraph` reads. A contract input, for example the result of `applyPack`, has these fields.
+ * Without `edges`, the input has no edges.
+ */
+export type RouteInput = Pick<LayoutInput, "id" | "boxes" | "obstacles"> & {
+  readonly edges?: LayoutInput["edges"];
+};
 /**
  * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
  * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
  * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
  * A box without `x` and `y` is an error.
  */
-export declare function inputGraph(input: LayoutInput): Graph;
+export declare function inputGraph(input: RouteInput): Graph;
 /**
  * This function writes an input file as text: the keys in sorted order, and one box or one edge on each line.
  * `JSON.parse` of the text gives the input again.
@@ -4486,5 +5217,5 @@ export declare function withRepair(router: Router, options?: RepairOptions): Rou
  * The new strategy has the name `<name>+repair`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
  */
 export declare function repairStrategy<O extends object>(strategy: Strategy<"router", O>, repair?: RepairOptions): Strategy<"router", O>;
-export type { 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 };
+export type { AmbiguityGuardOptions, ArcOptions, ArcSource, BreakEvenOptions, BundleLine, BundleOrder, CandidateSource, ClothoidOptions, CornersOptions, CorridorOptions, CurveSpace, CutObjective, CutOptions, DensityImage, DiffusionOptions, EdgeDistance, EdgeGroup, EdgeLengths, EdgePathOptions, EdgePlugs, FieldEnd, FlowClusterOptions, FlowFieldOptions, FollowOptions, Gate, GroupSpine, GroupedOptions, GrowthOptions, GrowthOrder, HdbscanOptions, Highway, HighwayBase, HighwayInput, HighwayMember, HighwayOptions, HighwayPlan, HoughOptions, HoughPeak, HubArcOptions, HysteresisOptions, JogStyle, KdAxis, KdLine, KdOptions, KeyOptions, KeyedWay, KeysOptions, LaneCurve, LanesOptions, LevelHighwayOptions, Linkage, MeetOptions, MingleOptions, NestedOptions, NodeKey, OdCellOptions, PathStep, QuickBundlesOptions, Ridge, RidgeOptions, RidgeSource, RoadClassOptions, RoomBends, RoundedOptions, RouteSegment, SectionsOptions, SelectOptions, ShareCost, ShareMerge, ShareOrder, SharedOptions, SharedStretchOptions, SharedWaysOptions, SmoothOptions, SnapLine, SnapMember, SnapOptions, SoftKeyOptions, SpiralNode, SpiralOptions, SplineOptions, SplitCell, StableIdOptions, StretchOptions, StubEnds, StubOptions, TraclusOptions, TrunkFan, TrunkSplit, TrunksOptions, WeiszfeldOptions, WspdOptions, Zip, ZipLimits, ZipperOptions };
 //# sourceMappingURL=index.d.ts.map