@mark1russell7/highways 0.5.0 → 0.5.1

package/build/index.d.ts

@@ -1,3 +1,4 @@
+import { ExerciseEvidence, HashOptions, MeasureSpec, Member, MemberStatus, MemberTrace, OutputGroup, PickSpec, Portfolio, PortfolioKey, PortfolioLevel, PortfolioOptions, PortfolioPick, PortfolioTrace, RECORD_EPS, SelectCandidate, SelectLevel, Selection, Verdict, canonicalJson, compareMeasure, exercised, minEffectOf, outputGroups, outputHash, pickMoves, portfolio, selectBest, sha256Hex } from "@mark1russell7/layout-contract";
 /** A point in the plane. */
 export interface Point {
   readonly x: number;
@@ -3645,6 +3646,925 @@ export declare function candidateArcs(input: HighwayInput, generators: readonly
  * Each edge rides the arc that saves the most for it.
  */
 export declare function hubArcPlan(input: HighwayInput, o: Readonly<HubArcOptions>): HighwayPlan;
+/**
+ * The plan that a post step changes. `none` is the empty plan: `follow` then routes each edge as the router `corners` does.
+ * `shared-ways` and `corridors` are the plans of those highway strategies, with their defaults.
+ */
+type HighwayBase = "none" | "shared-ways" | "corridors";
+/** The values of `HighwayBase`. */
+export declare const HIGHWAY_BASES: readonly HighwayBase[];
+/** This function gives the plan of a base. */
+export declare function basePlan(input: HighwayInput, base: HighwayBase): HighwayPlan;
+/** The side of the road that the traffic keeps to. */
+type TrafficRule = "right" | "left";
+/** The values of `TrafficRule`. */
+export declare const TRAFFIC_RULES: readonly TrafficRule[];
+/** The options of the highway strategy `divided` (HWY-011 of the notes). */
+interface DividedOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that the strategy divides. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The side of the road of the traffic. With `right`, the edges of each direction keep to the right of the spine. The default is `right`. */
+  readonly rule: TrafficRule;
+  /** The gap between the two carriageways, in lanes. The default is 1. */
+  readonly gap: number;
+  /** The width of one lane, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** A highway divides only when each direction has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `divided`. */
+export declare const DIVIDED_DEFAULTS: Readonly<Required<Omit<DividedOptions, "margin" | "k">>>;
+/**
+ * This function gives the polyline at the distance `offset` from `line`, with the same number of points. A positive offset is on the right of the line.
+ * The y axis points down, so the right of the direction `(dx, dy)` is `(-dy, dx)`. Each inner point moves along the bisector of its two legs (a miter join).
+ */
+export declare function offsetLine(line: readonly Point[], offset: number): Point[];
+/**
+ * This function divides one highway into two carriageways, one for each direction (HWY-011, divided edge bundling of Selassie, Heller and Heer 2011).
+ * Each carriageway is a copy of the spine at an offset to the side of its traffic. The offset is half the lanes of that side plus half the gap.
+ * When an offset spine is not clear of the boxes, the function tries one half and one quarter of the offset. It gives `undefined` when none fits.
+ */
+export declare function divideHighway(h: Highway, finder: WayFinder, o: Readonly<Omit<DividedOptions, "from" | "margin" | "k">>): Highway[] | undefined;
+/**
+ * This function gives the highways of the plan `from`, with each highway of two-way traffic divided into two carriageways (HWY-011).
+ * The edges of each direction get their own spine on the side of the rule `rule`. Thus the two directions do not cross in the lanes.
+ * A highway with fewer than `minSize` edges in one direction, or without the room for the offsets, stays as it is.
+ */
+export declare function dividedPlan(input: HighwayInput, o: Readonly<DividedOptions>): HighwayPlan;
+/** The trees of sections that the strategy `hierarchy` can use. */
+type HierarchyGroups = "quadtree" | "kd" | "cut";
+/** The values of `HierarchyGroups`. */
+export declare const HIERARCHY_GROUPS: readonly HierarchyGroups[];
+/** The options of the highway strategy `hierarchy` (HWY-001 of the notes). */
+interface HierarchyOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The tree of sections. The default is `quadtree`. */
+  readonly group: HierarchyGroups;
+  /** A section with more nodes splits. The default is 8. */
+  readonly cap: number;
+  /** The pull of the hubs, from 0 to 1 (Holten 2006). The value 0 gives the straight line, and 1 goes through each hub. The default is 0.85. */
+  readonly beta: number;
+  /** The largest number of hubs on each side of the lowest common section. `Infinity` uses all of them. The default is `Infinity`. */
+  readonly hubs: number;
+  /** The side of the grid that the hubs snap to, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `hierarchy`. */
+export declare const HIERARCHY_DEFAULTS: Readonly<Required<Omit<HierarchyOptions, "margin" | "k">>>;
+/**
+ * This function gives the control points of one edge. They are the sections from the leaf of the source up to the lowest common section, then down to the target leaf.
+ * The lowest common section is not in the chain (Holten 2006), so the edges do not all meet at the hub of the root.
+ * `hubs` limits the sections on each side. The sections nearest to the common section stay.
+ */
+export declare function controlChain(from: readonly Section[], to: readonly Section[], hubs: number): Section[];
+/**
+ * This function gives the highways of the hierarchical edge bundling (HWY-001, Holten 2006).
+ * The tree of sections gives a hub to each section. Each edge goes near the hubs of the sections between its two leaves.
+ * The waypoint of a hub is `beta hub + (1 - beta) p`, with `p` the point of the straight line at the same share of the chain.
+ * The waypoints snap to a grid of side `snap`, and the ways go through the corner graph. The stretches that `minSize` ways share become highways.
+ */
+export declare function hierarchyPlan(input: HighwayInput, o: Readonly<HierarchyOptions>): HighwayPlan;
+/** The options of the highway strategy `fdeb` (HWY-002 with RULE-002 of the notes). */
+interface FdebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two edges attract each other when their compatibility is this value or more. The default is 0.6. */
+  readonly compatibility: number;
+  /** The spring constant that keeps each edge smooth. The default is 0.1. */
+  readonly spring: number;
+  /** The number of cycles. Each cycle doubles the points of each edge and halves the step. The default is 5. */
+  readonly cycles: number;
+  /** The number of steps of the first cycle. Each later cycle has two thirds of the steps of the cycle before it. The default is 50. */
+  readonly iterations: number;
+  /** The weight of the push of the boxes (RULE-002). The value 0 turns it off. The default is 1. */
+  readonly repulsion: number;
+  /**
+   * The stretch budget of each edge (RULE-002). An edge whose polyline is longer than this value times its straight line gets no pull.
+   * `Infinity` sets no budget. The default is 1.25.
+   */
+  readonly pullLimit: number;
+  /** The side of the grid that the points of the edges snap to after the cycles, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `fdeb`. */
+export declare const FDEB_DEFAULTS: Readonly<Required<Omit<FdebOptions, "margin" | "k">>>;
+/**
+ * This function gives the polylines of the force-directed edge bundling (HWY-002, Holten and van Wijk 2009), with the box field of RULE-002.
+ * Each edge starts as the straight line between its two points out of the plugs. Each cycle doubles its points.
+ * In each step, a point moves by `step` times the mean pull to the matching points of its partners. The springs to its two neighbours also move it.
+ * The boxes push the points, and after each cycle a point in a box moves out of it. An edge over its stretch budget gets no pull in that step.
+ */
+export declare function fdebLines(input: HighwayInput, finder: WayFinder, o: Readonly<FdebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the force-directed edge bundling (HWY-002 with RULE-002).
+ * The points of the bundled polylines snap to a grid of side `snap`, so the points of one bundle come together.
+ * Each edge then goes through its points along the corner graph, and the stretches that `minSize` edges share become highways.
+ */
+export declare function fdebPlan(input: HighwayInput, o: Readonly<FdebOptions>): HighwayPlan;
+/** The options of the highway strategy `mesh` (HWY-004 of the notes). */
+interface MeshOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The side of a cell of the mesh, in units of the boxes: the median of the smaller side of each box. The default is 4. */
+  readonly cell: number;
+  /** A cluster of crossings on one segment of the mesh has at most about this number of edges. The default is 8. */
+  readonly capacity: number;
+  /** Two clusters nearer than this value, in units of the boxes, become one. The default is 1. */
+  readonly merge: number;
+  /** The largest angle in degrees between a line and the main direction of a cell. A line with a larger angle does not cross the mesh there. The default is 45. */
+  readonly angle: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `mesh`. */
+export declare const MESH_DEFAULTS: Readonly<Required<Omit<MeshOptions, "margin" | "k">>>;
+/** This function gives the median of the smaller side of each box of the graph, or 1 for a graph without boxes. */
+export declare function boxUnit(graph: Graph): number;
+/** This function gives the clusters of the values by a 1D k-means with `k` centres, then joins the centres nearer than `merge`. The result gives the centre of each value. */
+export declare function clusters1d(values: readonly number[], k: number, merge: number): number[];
+/**
+ * This function gives the waypoints of the control mesh (HWY-004, GBEC of Cui, Zhou, Qu, Wong and Li 2008).
+ * A grid of cells covers the board. The main direction of each cell is the peak of a histogram of the angles of the straight lines through it.
+ * The segment of the mesh in a cell goes through its middle, across that direction. The crossings of the lines with the segment form clusters by a 1D k-means.
+ * The centre of the cluster of each crossing is a waypoint of its edge. The waypoints of an edge are in the order of the edge.
+ */
+export declare function meshWaypoints(input: HighwayInput, finder: WayFinder, o: Readonly<MeshOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the control mesh (HWY-004). Each edge goes through the centres of its clusters on the mesh, along the corner graph.
+ * The centres of one cluster are one point, so the edges of a cluster share the ways between them. The stretches that `minSize` ways share become highways.
+ */
+export declare function meshPlan(input: HighwayInput, o: Readonly<MeshOptions>): HighwayPlan;
+/**
+ * The way to compute the density from the sample points. `direct` adds a Gaussian at each sample point (KDEEB).
+ * `separable` counts the points in the cells and blurs the counts along x, then along y (CUBu). `fft` blurs the counts with a product of Fourier transforms (FFTEB).
+ */
+type DensityKernel = "direct" | "separable" | "fft";
+/** The values of `DensityKernel`. */
+export declare const DENSITY_KERNELS: readonly DensityKernel[];
+/** The lines that make the first density: the straight lines of the edges, or their first routes. */
+type DensitySource = "lines" | "routes";
+/** The options of the highway strategy `kdeeb` (RULE-028 with HWY-006 of the notes). */
+interface KdeebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The lines of the first density. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The side of a cell of the density image, in units of the board. The default is 8. A large board gets larger cells, up to 512 cells on a side. */
+  readonly cell: number;
+  /** The width of the kernel at the first step, in units of the board. The default is 24. */
+  readonly bandwidth: number;
+  /** Each step multiplies the width of the kernel by this value. The default is 0.7. */
+  readonly decay: number;
+  /** The number of steps. The default is 10. */
+  readonly steps: number;
+  /** The share of the Laplacian smoothing of each polyline after each step, from 0 to 1. The default is 0.5. */
+  readonly smoothing: number;
+  /** With this option, the density is 0 in the boxes, so no ridge forms over a box (RULE-028). The default is `true`. */
+  readonly mask: boolean;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `kdeeb`. */
+export declare const KDEEB_DEFAULTS: Readonly<Required<Omit<KdeebOptions, "margin" | "k">>>;
+/** The settings of the advection that the strategies `kdeeb` and `cubu` share. */
+interface AdvectionSettings {
+  /** The way to compute the density. */
+  readonly kernel: DensityKernel;
+  /** The spacing of the sample points after each step, in units of the board. The value 0 keeps the points where they are. */
+  readonly resample: number;
+}
+/** A grid of cells over the board: its size, the side of a cell, and the place of its first cell. */
+interface DensityGrid {
+  readonly w: number;
+  readonly h: number;
+  readonly cell: number;
+  readonly x0: number;
+  readonly y0: number;
+}
+/** This function gives the fast Fourier transform of a row of `n` complex values in place, with `n` a power of 2. `inverse` gives the inverse without the division by `n`. */
+export declare function fft(re: Float64Array, im: Float64Array, inverse?: boolean): void;
+/** This function gives the density of the points on the grid with the kernel `kernel` of the width `bandwidth` in units of the board. */
+export declare function pointDensity(points: readonly Point[], g: DensityGrid, bandwidth: number, kernel: DensityKernel): Float64Array;
+/**
+ * This function gives the polylines of the density bundling (KDEEB, Hurter, Ersoy and Telea 2012). The ends of each polyline stay.
+ * In each step, the sample points of all edges make a density. Each inner point moves `h / 4` up the gradient of the density, with `h` the width of the kernel.
+ * The width then shrinks by `decay`, so the edges gather into ridges. A Laplacian smoothing keeps each polyline smooth.
+ * With `mask`, the density is 0 in the boxes (RULE-028), and a point in a box moves out of it.
+ */
+export declare function kdeebLines(input: HighwayInput, finder: WayFinder, o: Readonly<KdeebOptions>, settings: Readonly<AdvectionSettings>): Map<string, Point[]>;
+/** This function gives the highways of the bundled polylines of `kdeebLines`. The points snap to a grid of side `snap`, and the ways go through the corner graph. */
+export declare function densityPlan(input: HighwayInput, o: Readonly<KdeebOptions>, settings: Readonly<AdvectionSettings>, key: string): HighwayPlan;
+/**
+ * This function gives the highways of the density bundling with a mask of the free space (RULE-028 with HWY-006).
+ * The kernel is direct: each sample point adds a Gaussian. The final ridges of the polylines become the highways.
+ */
+export declare function kdeebPlan(input: HighwayInput, o: Readonly<KdeebOptions>): HighwayPlan;
+/** The options of the highway strategy `cubu` (HWY-007 of the notes). */
+interface CubuOptions extends KdeebOptions {
+  /** The way to compute the density: `separable` (CUBu) or `fft` (FFTEB). The default is `separable`. */
+  readonly kernel: Exclude<DensityKernel, "direct">;
+  /** The spacing of the sample points after each step, in units of the board. The value 0 keeps the points. The default is 8. */
+  readonly resample: number;
+}
+/** The default options of the strategy `cubu`. */
+export declare const CUBU_DEFAULTS: Readonly<Required<Omit<CubuOptions, "margin" | "k">>>;
+/**
+ * This function gives the highways of the fast density bundling (HWY-007: CUBu of van der Zwan, Codreanu and Telea 2016, and FFTEB of Lhuillier, Hurter and Telea 2017).
+ * The steps are those of `kdeeb`, with the mask of the boxes. The density comes from the counts of the cells, blurred by a separable kernel or by a Fourier transform.
+ * The sample points of each edge are spaced again after each step.
+ */
+export declare function cubuPlan(input: HighwayInput, o: Readonly<CubuOptions>): HighwayPlan;
+/** The local fit of the moving least squares: a line, or a parabola in the frame of the line. */
+type MlsFit = "line" | "parabola";
+/** The values of `MlsFit`. */
+export declare const MLS_FITS: readonly MlsFit[];
+/** The options of the highway strategy `mlseb` (HWY-008 of the notes). */
+interface MlsebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the fit at the first step, as a multiple of `boardUnit`: the median short side of the boxes. The default is 2. */
+  readonly radius: number;
+  /** Each step multiplies the radius by this value. The default is 0.8. */
+  readonly decay: number;
+  /** The number of steps. The default is 6. */
+  readonly steps: number;
+  /** The local fit. The default is `line`. */
+  readonly fit: MlsFit;
+  /** The weight of the angle, from 0 to 1. With 1, a sample at a right angle to the point has no weight. The default is 1. */
+  readonly angleWeight: number;
+  /** The spacing of the sample points of each edge, in units of the board. The default is 8. */
+  readonly spacing: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `mlseb`. */
+export declare const MLSEB_DEFAULTS: Readonly<Required<Omit<MlsebOptions, "margin" | "k">>>;
+/** One sample point of an edge, with the unit tangent of its edge there. */
+interface Sample {
+  readonly p: Point;
+  readonly tx: number;
+  readonly ty: number;
+}
+/**
+ * This function gives the point of the moving least squares fit at the point `p`. The weight of a sample `q` is `exp(-|q-p|^2 / r^2)`.
+ * The angle term multiplies it by `1 - a + a |cos|`, with `cos` the cosine of the angle between the two tangents.
+ * The fit `line` gives the projection of `p` on the weighted line of the samples. The fit `parabola` fits `s = c0 + c1 t + c2 t^2` in the frame of that line.
+ * Without weight, the function gives `p`.
+ */
+export declare function mlsPoint(p: Point, t: {
+  tx: number;
+  ty: number;
+}, near: readonly Sample[], r: number, angleWeight: number, fit: MlsFit): Point;
+/**
+ * This function gives the polylines of the moving least squares bundling (MLSEB, Wu, Zeng, Zhu and Yu 2017). The ends of each polyline stay.
+ * In each step, each inner point moves to the local fit of the samples of all edges within the radius. Then the radius shrinks by `decay`.
+ * A move is at most the radius. A point in a box moves out of it.
+ */
+export declare function mlsebLines(input: HighwayInput, finder: WayFinder, o: Readonly<MlsebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the moving least squares bundling (HWY-008). The points of `mlsebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export declare function mlsebPlan(input: HighwayInput, o: Readonly<MlsebOptions>): HighwayPlan;
+/** The clusterer that gives the groups of edges: QuickBundles (HWY-026) with its defaults, or the collection of each edge. */
+type SkeletonGroups = "quickbundles" | "keys";
+/** The values of `SkeletonGroups`. */
+export declare const SKELETON_GROUPS: readonly SkeletonGroups[];
+/** The point that each sample point moves toward: the nearest point of the skeleton of its group, or of the mean polyline of its group. */
+type SkeletonTarget = "skeleton" | "mean";
+/** The values of `SkeletonTarget`. */
+export declare const SKELETON_TARGETS: readonly SkeletonTarget[];
+/** The options of the highway strategy `sbeb` (HWY-009 of the notes). */
+interface SbebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The share of the distance to the target that a point moves in one step, from 0 to 1. The default is 0.5. */
+  readonly attraction: number;
+  /** The number of steps. The default is 4. */
+  readonly steps: number;
+  /** The share of the Laplacian smoothing of each polyline after each step, from 0 to 1. The default is 0.5. */
+  readonly smoothing: number;
+  /** The target of the points. The default is `skeleton`. */
+  readonly target: SkeletonTarget;
+  /** The side of a cell of the image of the shape, in units of the board. A large shape gets larger cells, up to 256 cells on a side. The default is 4. */
+  readonly cell: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A group with this number of edges or more moves, and a highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `sbeb`. */
+export declare const SBEB_DEFAULTS: Readonly<Required<Omit<SbebOptions, "margin" | "k">>>;
+/** This function gives the group of each edge: the clusters of QuickBundles, or the collection of the edge. An edge without a collection has no group with `keys`. */
+export declare function skeletonGroups(input: HighwayInput, group: SkeletonGroups): Map<string, EdgeGroup>;
+/** This function gives the first line of each edge. The line goes from a point at `margin` out of the source plug to a point at `margin` out of the target plug. */
+export declare function firstLines(input: HighwayInput, finder: WayFinder, source: DensitySource, spacing: number): Map<string, Point[]>;
+/** The image of the shape of a group and its skeleton. */
+interface ShapeSkeleton {
+  readonly grid: DensityGrid;
+  /** The distance of each cell to the nearest cell outside the shape, in cells. A cell outside the shape has 0. */
+  readonly depth: Float64Array;
+  /** The value is 1 for each cell of the skeleton. */
+  readonly skeleton: Uint8Array;
+}
+/**
+ * This function gives the shape of a group and its skeleton (its medial axis). The shape is the union of the disks of radius `radius` along the lines, minus the boxes.
+ * The depth is a chamfer distance transform with the steps 1 and √2. A cell is on the skeleton when two conditions are true.
+ * Its depth is half of `radius` or more. Its depth is a ridge along one of the four pairs of opposite neighbours.
+ * A ridge is not lower than the two neighbours, and it is higher than one of them.
+ */
+export declare function shapeSkeleton(lines: readonly (readonly Point[])[], finder: WayFinder, radius: number, cell: number): ShapeSkeleton;
+/** This function gives the middle of the skeleton cell nearest to `p`, within `reach` in units of the board, or `undefined`. */
+export declare function nearestSkeleton(s: ShapeSkeleton, p: Point, reach: number): Point | undefined;
+/** This function gives the mean polyline of lines in one direction, with `k` points. */
+export declare function meanLine(lines: readonly (readonly Point[])[], k: number): Point[];
+/** This function gives the point of a polyline nearest to `p`. */
+export declare function nearestOnLine(line: readonly Point[], p: Point): Point;
+/** This function gives the groups with `min` edges or more, as lists of edges. The groups are in the order of their first edges. */
+export declare function bigGroups(groups: ReadonlyMap<string, EdgeGroup>, min: number): {
+  key: string;
+  edges: {
+    edge: string;
+    flip: boolean;
+  }[];
+}[];
+/**
+ * This function gives the polylines of the skeleton-based edge bundling (SBEB, Ersoy, Hurter, Paulovich, Cantareiro and Telea 2011). The ends of each polyline stay.
+ * In each step, each group of `minSize` edges or more draws its shape, and each inner point moves the share `attraction` toward its target.
+ * The share falls to 0 at the distance `2 radius`. A Laplacian smoothing keeps each polyline smooth, and a point in a box moves out of it.
+ * The edges outside such a group do not move.
+ */
+export declare function sbebLines(input: HighwayInput, finder: WayFinder, o: Readonly<SbebOptions>): Map<string, Point[]>;
+/**
+ * This function gives the highways of the skeleton-based edge bundling (HWY-009). The points of `sbebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export declare function sbebPlan(input: HighwayInput, o: Readonly<SbebOptions>): HighwayPlan;
+/** The rule of the half width of an area: the spread of the edges of the group, or the number of its lanes. */
+type AreaWidth = "spread" | "count";
+/** The values of `AreaWidth`. */
+export declare const AREA_WIDTHS: readonly AreaWidth[];
+/** The options of the highway strategy `areas` (HWY-010 of the notes). */
+interface AreaOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The lines of the edges that make the shape: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The rule of the half width of the area. The default is `spread`. */
+  readonly width: AreaWidth;
+  /** The width of one lane for the rule `count`, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** The side of a cell of the image of the shape, in units of the board. The default is 4. */
+  readonly cell: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `areas`. */
+export declare const AREA_DEFAULTS: Readonly<Required<Omit<AreaOptions, "margin" | "k">>>;
+/**
+ * This function gives the longest path of the largest part of a skeleton, as the middles of its cells. The neighbours of a cell are its 8 neighbours.
+ * The function finds the cell farthest from a first cell, then the cell farthest from that cell. A skeleton without cells gives an empty list.
+ */
+export declare function skeletonPath(s: ShapeSkeleton): Point[];
+/**
+ * This function gives the highways of the image-based edge bundles (HWY-010, Telea and Ersoy 2010). Each group of edges is one area with one spine.
+ * The spine goes through the corner graph between the two ends of the longest path of the skeleton of the shape of the group.
+ * The area is the skeleton path with a half width. With `spread`, the half width is the 90th percentile of the distances of the points to the path.
+ * With `count`, it is the number of lanes times half of `laneWidth`. The half width is at least the margin.
+ * An edge joins the spine where its line first goes into the area. It leaves the spine where its line last comes out of the area.
+ */
+export declare function areaPlan(input: HighwayInput, o: Readonly<AreaOptions>): HighwayPlan;
+/** The edges that one group can hold: the edges of one collection, or each edge. */
+type GroupScope = "collection" | "all";
+/** The values of `GroupScope`. */
+export declare const GROUP_SCOPES: readonly GroupScope[];
+/** The options of the highway strategy `confluent` (HWY-013 of the notes). */
+interface ConfluentOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A biclique `K(A, B)` becomes a track when `|A| |B|` is this value or more. The default is 4. */
+  readonly minBiclique: number;
+  /** The edges of one track. With `collection`, a track holds the edges of one collection, and an edge without a collection is on no track. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each track. The default is `trunk`: one trunk from the merge junction to the split junction. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+/** The default options of the strategy `confluent`. */
+export declare const CONFLUENT_DEFAULTS: Readonly<Required<Omit<ConfluentOptions, "margin" | "k">>>;
+/** The edges between pairs of nodes of one scope: for each node, its neighbours and the edges to each of them. */
+interface NodeLinks {
+  /** The key of the scope. */
+  readonly key: string;
+  /** For each node, the edges to each neighbour, by the id of the neighbour. */
+  readonly links: Map<string, Map<string, string[]>>;
+}
+/** This function gives the links of each scope. A loop (an edge from a node to itself) is not a link. The order of the maps follows the order of the edges. */
+export declare function nodeLinks(graph: Graph, scope: GroupScope): NodeLinks[];
+/** A biclique: the two sets of nodes, with a link from each node of `a` to each node of `b`. */
+interface Biclique {
+  readonly a: readonly string[];
+  readonly b: readonly string[];
+}
+/**
+ * This function gives the bicliques of a greedy search (HWY-013). Each search starts at one node `x` with `A = {x}` and `B` its neighbours.
+ * It then adds to `A` the node that gives the largest `|A| |B|`, with `B` cut to the common neighbours, while the product grows.
+ * The best biclique of all starts with `|A| |B| >= min` becomes a track, its links go away, and the search repeats.
+ * The nodes of `A` and `B` are apart. The largest set is `b`.
+ */
+export declare function greedyBicliques(links: Map<string, Map<string, string[]>>, min: number): Biclique[];
+/**
+ * This function gives the group of each edge of a set of bicliques. The edges of one biclique are one group, with the key `<prefix><scope>/<index>`.
+ * An edge from a node of `b` to a node of `a` has `flip`. Thus each trunk goes from the side `a` to the side `b`.
+ */
+export declare function bicliqueGroups(graph: Graph, scope: NodeLinks, bicliques: readonly Biclique[], prefix: string, into: Map<string, EdgeGroup>): void;
+/**
+ * This function gives the highways of the confluent drawing (HWY-013, Dickerson, Eppstein, Goodrich and Meng 2005).
+ * Each biclique `K(A, B)` of the greedy search is one track. The track merges the edges near the side `A` and splits them near the side `B`.
+ * The junctions are the Weber points of the ends, as in the spine `trunk` of `groupedPlan`.
+ */
+export declare function confluentPlan(input: HighwayInput, o: Readonly<ConfluentOptions>): HighwayPlan;
+/** The rule of a module: the nodes with the same neighbours (`exact`), or with near neighbours by the Jaccard index (`near`). */
+type ModuleRule = "exact" | "near";
+/** The values of `ModuleRule`. */
+export declare const MODULE_RULES: readonly ModuleRule[];
+/** The options of the highway strategy `power` (HWY-014 of the notes). */
+interface PowerOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The rule of the modules. The default is `exact`. */
+  readonly modules: ModuleRule;
+  /** With the rule `near`, a node joins a module at this Jaccard index or more with the first node of the module. The default is 0.8. */
+  readonly jaccard: number;
+  /** A power edge saves the number of its edges less 1. It becomes a highway when it saves this number of edges or more. The default is 2. */
+  readonly minSaved: number;
+  /** The edges of one power edge. With `collection`, a power edge holds the edges of one collection. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each power edge. The default is `trunk`. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+/** The default options of the strategy `power`. */
+export declare const POWER_DEFAULTS: Readonly<Required<Omit<PowerOptions, "margin" | "k">>>;
+/** This function gives the Jaccard index of two sets: the size of their common part over the size of their union. Two empty sets give 1. */
+export declare function jaccardIndex(a: ReadonlySet<string>, b: ReadonlySet<string>): number;
+/**
+ * This function gives the module of each node. With `exact`, the nodes with the same set of neighbours are one module.
+ * With `near`, the nodes go in the order of their degree, the largest first. A node joins the first module whose first node has a Jaccard index of `jaccard` or more with it.
+ * The function gives the modules as lists of nodes, each in the order of the ids.
+ */
+export declare function modulesOf(links: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>, rule: ModuleRule, jaccard: number): string[][];
+/**
+ * This function gives the highways of the edge compression with modules and power graphs (HWY-014, Dwyer, Henry Riche, Marriott and Mears 2013).
+ * The edges between two modules are one power edge. With modules of the rule `exact`, each node of one module links to each node of the other.
+ * A power edge that saves `minSaved` edges or more is one highway from module to module.
+ * Its trunk goes between the Weber points of the two ends.
+ * The search does not nest modules, so it finds no power edge inside a power edge.
+ */
+export declare function powerPlan(input: HighwayInput, o: Readonly<PowerOptions>): HighwayPlan;
+/** The options of the highway strategy `crossbars` (HWY-022 of the notes). */
+interface CrossbarOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that gets the bundled crossings. Only the edges outside its highways can be on a crossbar. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two segments are parallel when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly tolerance: number;
+  /** Each side of a crossbar has this number of edges or more. The default is 2. */
+  readonly minBar: number;
+  /** The crossings of one crossbar are this distance or nearer to its first crossing, as a multiple of `boardUnit`. The default is 3. */
+  readonly reach: number;
+}
+/** The default options of the strategy `crossbars`. */
+export declare const CROSSBAR_DEFAULTS: Readonly<Required<Omit<CrossbarOptions, "margin" | "k">>>;
+/** One crossing of two routes: the edges, the point and the unit directions of the two segments there. */
+interface RouteCrossing {
+  readonly e: string;
+  readonly f: string;
+  readonly p: Point;
+  readonly de: Point;
+  readonly df: Point;
+}
+/** This function gives each crossing of two routes of the list, in the order of the list. */
+export declare function routeCrossings(routes: readonly {
+  readonly edge: string;
+  readonly points: readonly Point[];
+}[]): RouteCrossing[];
+/** A crossbar: two sets of edges, with a crossing of each edge of `p` with each edge of `q` near one place. */
+interface Crossbar {
+  readonly p: readonly string[];
+  readonly q: readonly string[];
+  /** The mean point of the crossings of the crossbar. */
+  readonly at: Point;
+  /** The mean direction of the side `p`, and of the side `q`. */
+  readonly dp: Point;
+  readonly dq: Point;
+}
+/**
+ * This function gives the crossbars of a greedy search (HWY-022, after Fink, Hershberger, Suri and Verbeek 2016).
+ * The search starts at each crossing in order. It grows the two sides while each new edge crosses each edge of the other side near the start, at the same angles.
+ * A crossbar with `minBar` edges or more on each side is kept. Each edge is on one crossbar at most.
+ */
+export declare function greedyCrossbars(crossings: readonly RouteCrossing[], reach: number, tolDeg: number, minBar: number): Crossbar[];
+/**
+ * This function gives the highways of the bundled crossings (HWY-022). The edges outside the highways of the plan `from` keep their routes after `follow`.
+ * Each crossbar of those routes gives two highways, one for each side. Each spine is a line through the mean crossing, along the mean direction of its side.
+ * It is `2 reach` long, and it goes through the corner graph. So each side crosses the other side at one place, as a bundle.
+ * An edge joins the spine near the point of its route nearest to one end of the line. It leaves the spine near the other end.
+ */
+export declare function crossbarPlan(input: HighwayInput, o: Readonly<CrossbarOptions>): HighwayPlan;
+/** The options of the highway strategy `frechet` (HWY-027 of the notes). */
+interface FrechetOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two parts of routes are one bundle when their discrete Fréchet distance is this value or less, as a multiple of `boardUnit`. The default is 1. */
+  readonly eps: number;
+  /** A bundle has this number of edges or more, with the reference edge. The default is 2. */
+  readonly minSize: number;
+  /** The reference part of a bundle is this length or longer, as a multiple of `boardUnit`. The default is 2. */
+  readonly minLength: number;
+  /** The distance between two samples of a route, as a multiple of `boardUnit`. The default is 0.5. */
+  readonly step: number;
+  /** A search starts at each sample of this number along each route. The default is 2. */
+  readonly stride: number;
+}
+/** The default options of the strategy `frechet`. */
+export declare const FRECHET_DEFAULTS: Readonly<Required<Omit<FrechetOptions, "margin" | "k">>>;
+/** This function gives the points of a polyline at equal distances of `step` or less, with its first and its last point. */
+export declare function samplesOf(line: readonly Point[], step: number): Point[];
+/** The cells of one row of the free space that a monotone path reaches. Each cell is a sorted index of the other curve. */
+type Row = readonly number[];
+/**
+ * This function gives the next row of the free space of the discrete Fréchet distance. The curve `q` has a free start and a free end.
+ * A cell `(j, b)` is free when the distance of `p[j]` to `q[b]` is `eps` or less.
+ * A path reaches a free cell from `(j - 1, b)`, `(j - 1, b - 1)` or `(j, b - 1)`.
+ */
+export declare function nextRow(prev: Row, pj: Point, q: readonly Point[], eps: number): number[];
+/**
+ * This function tells if a part of `q` has a discrete Fréchet distance of `eps` or less to the whole of `p`. The part of `q` is free to start and to end anywhere.
+ * It uses the rows of `nextRow`.
+ */
+export declare function partWithin(p: readonly Point[], q: readonly Point[], eps: number): boolean;
+/** One bundle of the search: the reference edge, the part of its samples, and the other edges with their sense. */
+interface FrechetBundle {
+  readonly edge: string;
+  readonly from: number;
+  readonly to: number;
+  readonly length: number;
+  /** The other edges. `back` is true when the edge goes along the reference part in the reverse sense. */
+  readonly members: readonly {
+    readonly edge: string;
+    readonly back: boolean;
+  }[];
+}
+/**
+ * This function gives the bundles of the search (HWY-027, after Buchin, Buchin, Gudmundsson, Löffler and Luo 2011, in a simple exact form).
+ * For each reference route and each start sample (at each `stride`), it grows the reference part one sample at a time.
+ * It keeps the other routes, in both senses, with a part at a discrete Fréchet distance of `eps` or less.
+ * It stops when fewer than `minSize - 1` routes remain.
+ * Each start gives the part with the best score: the number of edges times the length.
+ * The search uses the discrete distance on samples only. It does not use the continuous distance or the full free space diagram.
+ */
+export declare function frechetBundles(samples: ReadonlyMap<string, readonly Point[]>, eps: number, minSize: number, minLength: number, stride: number): FrechetBundle[];
+/**
+ * This function gives the highways of the subtrajectory clusters of the first routes (HWY-027). The samples of each route leave out its two end points.
+ * The bundles go in the order of their score, the best first. A bundle keeps the members whose part of the route is not on a bundle already.
+ * The spine of a highway is the reference part. Each member rides the whole spine, in its own sense.
+ */
+export declare function frechetPlan(input: HighwayInput, o: Readonly<FrechetOptions>): HighwayPlan;
+/** The options of the highway strategy `spectral` (HWY-029 of the note on highways). */
+interface SpectralOptions {
+  /** Two edges are a pair of the graph only when their compatibility is this value or more. The default is 0.5. */
+  readonly c0: number;
+  /** The number of clusters of each part of the graph. The value 0 lets the largest eigengap choose it. The default is 0. */
+  readonly clusters: number;
+  /** The eigengap chooses at most this number of clusters in each part of the graph. The default is 16. */
+  readonly kMax: number;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `spectral`. */
+export declare const SPECTRAL_DEFAULTS: Readonly<SpectralOptions>;
+/** The ends of one edge of the board. */
+interface EdgeEnds {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+}
+/** This function gives the ends of each edge of the input: the points of its two plugs. */
+export declare function edgeEnds(input: HighwayInput): EdgeEnds[];
+/**
+ * This function gives the eigenvalues and the eigenvectors of a symmetric matrix of `n` rows (the Householder steps and the QL steps of JAMA).
+ * The values are in increasing order. The column `j` of `vectors` (the values `vectors[i * n + j]`) is the unit vector of the value `j`.
+ */
+export declare function symmetricEigen(n: number, a: Float64Array): {
+  values: Float64Array;
+  vectors: Float64Array;
+};
+/**
+ * This function puts the rows of a matrix of `n` rows and `k` columns into `k` clusters (the steps of Lloyd).
+ * The first centre is row 0. Each next centre is the row farthest from the centres that exist. The result is the cluster of each row.
+ */
+export declare function kMeans(n: number, k: number, rows: Float64Array, iterations?: number): Int32Array;
+/**
+ * This function gives the spectral clusters of the points of a weight matrix (von Luxburg 2007, with the normalization of Ng, Jordan and Weiss).
+ * Each connected part of the graph is one problem. `L_sym = I - D^-1/2 W D^-1/2`.
+ * The number of clusters `k` of a part is `clusters`, or the place of the largest gap of the first `kMax + 1` eigenvalues.
+ * The first `k` eigenvectors, with each row at the length 1, go into `kMeans`. The result is the cluster of each point, and -1 for a point with no pair.
+ */
+export declare function spectralLabels(n: number, w: Float64Array, o: Readonly<Pick<SpectralOptions, "clusters" | "kMax">>): Int32Array;
+/** This function gives the matrix of the compatibility of the pairs of edges, with 0 for a pair below `c0`. Then a `scale` changes the value of each pair that stays. */
+export declare function compatibilityMatrix(ends: readonly EdgeEnds[], c0: number, scale?: (i: number, j: number) => number): Float64Array;
+/**
+ * This function gives the edge groups of the clusters of the edges of one matrix. Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ * An edge with the label -1 gets no group.
+ */
+export declare function labelGroups(ends: readonly EdgeEnds[], labels: Int32Array, prefix: string, groups: Map<string, EdgeGroup>): void;
+/** This function splits the edges into blocks of at most `BLOCK` edges, in the order of their sources. A small graph is one block. */
+export declare function edgeBlocks<T extends EdgeEnds>(ends: readonly T[]): T[][];
+/** This function gives the spectral clusters of the edges (HWY-029). A pair of edges is in the graph when its compatibility of FDEB is `c0` or more. */
+export declare function spectralClusters(input: HighwayInput, o: Readonly<SpectralOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph (HWY-029). The eigengap gives the number of highways of each part.
+ * The clusters with `minSize` edges or more get highways.
+ */
+export declare function spectralPlan(input: HighwayInput, o: Readonly<SpectralOptions>): HighwayPlan;
+/** The options of the highway strategy `resistance` (HWY-021 of the note on highways). */
+interface ResistanceOptions extends SpectralOptions {
+  /** The number of random projections of the estimate of the resistance. The default is 16. */
+  readonly projections: number;
+  /** The weight of the resistance, from 0 to 1. A pair with `C >= c0` gets the weight `C (1 - weight R_e R_f)`. The default is 0.5. */
+  readonly weight: number;
+  /** With `true`, an edge with a resistance of 0.99 or more (a bridge) gets no pair. The default is `false`. */
+  readonly sparsify: boolean;
+}
+/** The default options of the strategy `resistance`. */
+export declare const RESISTANCE_DEFAULTS: Readonly<ResistanceOptions>;
+/**
+ * This function gives an estimate of the effective resistance of each edge of the graph (Spielman and Srivastava 2011).
+ * It takes `k` random vectors `q` of the values `±1/√k` on the edges. It solves `L z = Bᵀ q` for each vector. Then `R(u, v) ≈ Σ (z_u - z_v)²`.
+ * The value is from 0 to 1. A loop and an edge with an unknown node get 0. Parallel edges share the current, so each gets a lower value.
+ */
+export declare function edgeResistance(graph: Graph, projections: number): Map<string, number>;
+/**
+ * This function gives the clusters of the edges with the compatibility scaled by the resistance (HWY-021).
+ * The compatibility of a pair is `C (1 - weight R_e R_f)`. A pair of two bridges thus gets a lower value. Then the spectral clusters of `spectral` apply.
+ */
+export declare function resistanceClusters(input: HighwayInput, o: Readonly<ResistanceOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph with the weights of the effective resistance (HWY-021).
+ * The clusters with `minSize` edges or more get highways.
+ */
+export declare function resistancePlan(input: HighwayInput, o: Readonly<ResistanceOptions>): HighwayPlan;
+/** The options of the highway strategy `link-communities` (HWY-030 of the note on highways). */
+interface LinkCommunityOptions {
+  /** The cut of the tree of the edges. The value 0 cuts at the best partition density. A value above 0 keeps the joins with this similarity or more. The default is 0. */
+  readonly threshold: number;
+  /** A community with this number of edges or more gets highways, after the check of the geometry. The default is 2. */
+  readonly minSize: number;
+  /** The largest distance of an end of an edge to the Weber point of its end of the community, in units of the board. The default is 6. */
+  readonly spread: number;
+  /** The spine of each community. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `link-communities`. */
+export declare const LINK_COMMUNITY_DEFAULTS: Readonly<LinkCommunityOptions>;
+/** The ends of one edge as node indices. */
+interface LinkEdge {
+  readonly u: number;
+  readonly v: number;
+}
+/**
+ * This function gives the link communities of the edges: the single linkage of the edges by their similarity.
+ * With `threshold` 0, the cut is at the level of the best partition density `D = (2/M) Σ m_c (m_c - n_c + 1) / ((n_c - 2)(n_c - 1))`.
+ * When the best `D` is above 0, the first level with it applies. When it is 0 (a forest), the last level applies.
+ * The result is the community of each edge, as the index of an edge of the community. A loop is alone.
+ */
+export declare function linkCommunities(n: number, edges: readonly LinkEdge[], threshold: number): Int32Array;
+/**
+ * This function gives the edge groups of the link communities (HWY-030). The hub of a community is its node with the most edges.
+ * Each edge goes from its end at the hub, or else in the direction of the hub edges. The check of the geometry removes each edge with an end
+ * farther than `spread` units from the Weber point of that end of the community. A community with fewer than `minSize` edges after the check gets no group.
+ */
+export declare function linkCommunityGroups(input: HighwayInput, o: Readonly<LinkCommunityOptions>): Map<string, EdgeGroup>;
+/** This function gives the highways of the link communities of the line graph (HWY-030). Each community that passes the check of the geometry gets highways. */
+export declare function linkCommunityPlan(input: HighwayInput, o: Readonly<LinkCommunityOptions>): HighwayPlan;
+/** The characteristic points of the territories: the plugs, the bends of the first routes, or both. */
+type TerritoryPoints = "plugs" | "bends" | "both";
+/** The values of `TerritoryPoints`. */
+export declare const TERRITORY_POINTS: readonly TerritoryPoints[];
+/** The options of the highway strategy `territories` (HWY-033 of the note on highways). */
+interface TerritoryOptions {
+  /** The radius of a group of points, in units of the board. The default is 4. */
+  readonly radius: number;
+  /** A flow between two cells becomes a highway when this number of edges or more cross it. The default is 2. */
+  readonly minSize: number;
+  /** The characteristic points. The default is `both`. */
+  readonly points: TerritoryPoints;
+}
+/** The default options of the strategy `territories`. */
+export declare const TERRITORY_DEFAULTS: Readonly<TerritoryOptions>;
+/**
+ * This function puts points into groups of the radius `r` (Andrienko and Andrienko 2011). Each point joins the group with the nearest centre within `r`.
+ * Else it starts a new group. The centre of a group is the mean of its points. A second pass puts each point into the group of its nearest centre.
+ * The result is the centres of the groups that keep points.
+ */
+export declare function pointGroups(points: readonly Point[], r: number): Point[];
+/** This function gives the index of the centre nearest to `p`. The first of two equal centres wins. */
+export declare function nearestCentre(centres: readonly Point[], p: Point): number;
+/** One crossing of a route from the cell `from` into the cell `to`, at the share `at` of the length of the route. */
+interface CellStep {
+  readonly from: number;
+  readonly to: number;
+  readonly at: number;
+}
+/**
+ * This function gives the crossings of the cells of a polyline. The cells are the Voronoi cells of the centres.
+ * It samples the polyline at the spacing `step`, and gives each change of the nearest centre.
+ */
+export declare function cellSteps(line: readonly Point[], centres: readonly Point[], step: number): CellStep[];
+/**
+ * This function gives the highways of the territories of the flows (HWY-033, Andrienko and Andrienko 2011).
+ * The characteristic points form groups of the radius `radius`. The centres of the groups make Voronoi cells.
+ * Each first route becomes a list of crossings between neighbour cells.
+ *
+ * A pair of cells with `minSize` crossings or more is a line from centre to centre. The edges that cross it snap to it. The centres of the cells are the interchanges.
+ */
+export declare function territoryPlan(input: HighwayInput, o: Readonly<TerritoryOptions>): HighwayPlan;
+/** The linkage of the clusters of the vote matrix: `average` (the mean distance of the pairs) or `single` (the nearest pair). */
+type ConsensusLinkage = "average" | "single";
+/** The values of `ConsensusLinkage`. */
+export declare const CONSENSUS_LINKAGES: readonly ConsensusLinkage[];
+/** The options of the highway strategy `consensus` (HWY-035 of the note on highways). */
+interface ConsensusOptions {
+  /** The finders that vote. The default is `corridors`, `quickbundles`, `wspd` and `road-classes`. */
+  readonly members: readonly CandidateSource[];
+  /** Two clusters join while their distance `1 - A` is below this value. The default is 0.5: more than half of the votes. */
+  readonly cut: number;
+  /** The linkage of the clusters. The default is `average`. */
+  readonly linkage: ConsensusLinkage;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `consensus`. */
+export declare const CONSENSUS_DEFAULTS: Readonly<ConsensusOptions>;
+/**
+ * This function gives the co-association matrix of the plans (Fred and Jain 2005). `A[e][f]` is the share of the plans with a highway that holds both `e` and `f`.
+ * The edges are in the order of `edges`. An edge of no plan has no pair.
+ */
+export declare function coAssociation(edges: readonly string[], plans: readonly HighwayPlan[]): Float64Array;
+/**
+ * This function gives the clusters of the agglomerative linkage on the distance `1 - A`. Two clusters join while their distance is below `cut`.
+ * The linkage `average` uses the mean of the distances of the pairs, and `single` the smallest distance.
+ * The result is the cluster of each edge, and -1 for an edge that stays alone.
+ */
+export declare function consensusLabels(n: number, a: Float64Array, cut: number, linkage: ConsensusLinkage): Int32Array;
+/** This function gives the edge groups of the consensus of the plans of the finders `members` (HWY-035). */
+export declare function consensusGroups(input: HighwayInput, o: Readonly<ConsensusOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of the consensus of clusterings (HWY-035). Each finder of `members` votes for the pairs of edges that share one of its highways.
+ * The clusters of the vote matrix with `minSize` edges or more get highways. A small edit changes few votes, so the clusters are stable.
+ */
+export declare function consensusPlan(input: HighwayInput, o: Readonly<ConsensusOptions>): HighwayPlan;
+/** The allocation of the edges to the hubs: `single` (each node to its nearest hub) or `multiple` (each edge to its best pair of hubs). */
+type HubAllocation = "single" | "multiple";
+/** The values of `HubAllocation`. */
+export declare const HUB_ALLOCATIONS: readonly HubAllocation[];
+/** The candidate points of the hubs: the corners of the corner graph, or the centres of the cells of the tree of sections. */
+type HubCandidates = "corners" | "sections";
+/** The values of `HubCandidates`. */
+export declare const HUB_CANDIDATES: readonly HubCandidates[];
+/** The options of the highway strategy `p-hub` (HWY-041 of the note on highways). */
+interface PHubOptions {
+  /** The number of hubs. The value 0 gives the root of the number of nodes, rounded. The default is 0. */
+  readonly p: number;
+  /** The cost of a length on a link between two hubs against a length off the links, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** The allocation of the edges to the hubs. The default is `single`. */
+  readonly allocation: HubAllocation;
+  /** The candidate points of the hubs. The default is `corners`. */
+  readonly candidates: HubCandidates;
+  /** An edge rides a link only when its way through the two hubs is this many times its first route or less. The default is 1.25. */
+  readonly detour: number;
+  /** The number of passes of the local search with one swap of a hub. The default is 1. */
+  readonly swaps: number;
+  /** A link with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `p-hub`. */
+export declare const P_HUB_DEFAULTS: Readonly<PHubOptions>;
+/** This function gives the candidate points of the hubs, at most `MAX_CANDIDATES`, without the copies. */
+export declare function hubCandidates(input: HighwayInput, candidates: HubCandidates): Point[];
+/**
+ * This function chooses `p` points of `candidates` as the p-median of `points`. The greedy step adds the candidate that lowers the sum of the distances most.
+ * Then at most 4 passes of swaps lower the sum more. The result is the indices of the chosen candidates.
+ */
+export declare function pMedian(points: readonly Point[], candidates: readonly Point[], p: number): number[];
+/**
+ * This function gives the highways of the hub location (HWY-041, the p-hub median of O'Kelly 1987). The p-median of the plugs chooses `p` hubs from the candidates.
+ * Each swap pass changes one hub for one other candidate while the total cost falls. Each link between two hubs with `minSize` edges or more is a highway.
+ * The edges that ride a link snap to it, from their first hub to their second hub.
+ */
+export declare function pHubPlan(input: HighwayInput, o: Readonly<PHubOptions>): HighwayPlan;
+/** The line of each edge that QuickBundles compares: its first route, or the straight line between its plugs. */
+type BundleLine = "routes" | "lines";
+/** The order of the edges in the one pass: the order of the graph, or the longest line first. */
+type BundleOrder = "input" | "length";
+/** The options of the highway strategy `quickbundles` (HWY-026 of the note on highways). */
+interface QuickBundlesOptions {
+  /** An edge joins a cluster when its distance to the centroid is this value or less, in units of the board. The default is 3. */
+  readonly theta: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`, so an added edge does not change the clusters before it. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `quickbundles`. */
+export declare const QUICKBUNDLES_DEFAULTS: Readonly<QuickBundlesOptions>;
+/** This function gives `k` points at equal steps of length along a polyline, from its first point to its last point. */
+export declare function resample(line: readonly Point[], k: number): Point[];
+/**
+ * This function gives the MDF distance of two lines with the same number of points. It is the mean distance of their points.
+ * The function compares the points in the same direction and in the opposite direction, and keeps the smaller mean.
+ * `flip` is `true` when the opposite direction is smaller.
+ */
+export declare function mdf(p: readonly Point[], q: readonly Point[]): {
+  d: number;
+  flip: boolean;
+};
+/**
+ * This function gives the clusters of QuickBundles (Garyfallidis 2012) as groups of edges.
+ * In one pass, each edge joins the cluster with the nearest centroid when the MDF distance is `theta` units or less. Else it starts a cluster.
+ * The centroid is the running mean of the lines of the cluster, each in the direction of the centroid.
+ */
+export declare function quickBundles(input: HighwayInput, o: Readonly<QuickBundlesOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of QuickBundles (HWY-026). The clusters of `quickBundles` with `minSize` edges or more get highways.
+ * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
+ */
+export declare function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan;
+/** The options of the highway strategy `scale-space` (HWY-053 of the note on highways). */
+interface ScaleSpaceOptions {
+  /** The first scale, in units of the board. The default is 1.5. */
+  readonly theta: number;
+  /** The scale of each next scale is this value times the scale before it. The default is the root of 2. */
+  readonly ratio: number;
+  /** The number of scales. The default is 8. */
+  readonly scales: number;
+  /** The scale of the plan, from 0 (the first scale). With the defaults, the scale 2 is 3 units, as in the level 0 of `nested`. The default is 2. */
+  readonly level: number;
+  /** A cluster gets highways only when its persistence `ln(σ_death / σ_birth)` is this value or more. The default is 0.6: two steps of the root of 2. */
+  readonly p0: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+/** The default options of the strategy `scale-space`. */
+export declare const SCALE_SPACE_DEFAULTS: Readonly<ScaleSpaceOptions>;
+/** One cluster of one scale: its edges (as indices), and the scales of its birth and its death. */
+interface ScaleCluster {
+  readonly members: readonly number[];
+  /** The first scale of the cluster. A cluster of the first scale has the birth 0. */
+  readonly birth: number;
+  /** The first scale where the cluster joins a larger one. A cluster that lives past the last scale has the death `scales`. */
+  readonly death: number;
+}
+/**
+ * This function gives the clusters of the single linkage of `n` items at each scale. The distance `d(i, j)` of each pair is in `pairs`.
+ * At the scale `s`, two items with a distance of `limits[s]` or less are in one cluster. Thus each cluster of a scale is in one cluster of each larger scale.
+ * The result has the clusters of each scale with 2 items or more, with their birth and their death.
+ */
+export declare function scaleClusters(n: number, pairs: readonly {
+  i: number;
+  j: number;
+  d: number;
+}[], limits: readonly number[]): ScaleCluster[][];
+/**
+ * This function gives the groups of the edges at the scale `level` that persist (HWY-053). The scale `s` is `theta × ratio^s` units of the board.
+ * A cluster of the level gets a group when its persistence `(death - birth) × ln(ratio)` is `p0` or more. Each edge of a group gets `flip` against the first edge of the group.
+ */
+export declare function scaleSpaceGroups(input: HighwayInput, o: Readonly<ScaleSpaceOptions>): Map<string, EdgeGroup>;
+/**
+ * This function gives the highways of one scale of the scale space with persistence (HWY-053). Only the clusters that live over `p0` of the log scale get highways.
+ * A short-lived cluster is noise, so a zoom level shows only the stable structure.
+ */
+export declare function scaleSpacePlan(input: HighwayInput, o: Readonly<ScaleSpaceOptions>): HighwayPlan;
 /** The lines that make the density: the straight lines of the edges, or their first routes. */
 type RidgeSource = "lines" | "routes";
 /** The options of the highway strategy `ridges` (HWY-032 of the note on highways). */
@@ -3772,15 +4692,6 @@ 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`. */
@@ -3888,49 +4799,6 @@ export declare function odGroups(input: HighwayInput, o: Readonly<OdCellOptions>
  * The terminals are the Weber points of the plugs in each cell. An edge with a leg longer than `legMax` times the span goes alone.
  */
 export declare function odCellPlan(input: HighwayInput, o: Readonly<OdCellOptions>): HighwayPlan;
-/** The line of each edge that QuickBundles compares: its first route, or the straight line between its plugs. */
-type BundleLine = "routes" | "lines";
-/** The order of the edges in the one pass: the order of the graph, or the longest line first. */
-type BundleOrder = "input" | "length";
-/** The options of the highway strategy `quickbundles` (HWY-026 of the note on highways). */
-interface QuickBundlesOptions {
-  /** An edge joins a cluster when its distance to the centroid is this value or less, in units of the board. The default is 3. */
-  readonly theta: number;
-  /** The number of points of each line after the resampling. The default is 12. */
-  readonly points: number;
-  /** The line of each edge. The default is `routes`. */
-  readonly line: BundleLine;
-  /** The order of the edges. The default is `input`, so an added edge does not change the clusters before it. */
-  readonly order: BundleOrder;
-  /** A cluster with this number of edges or more gets highways. The default is 2. */
-  readonly minSize: number;
-  /** The spine of each cluster. The default is `shared`. */
-  readonly spine: GroupSpine;
-}
-/** The default options of the strategy `quickbundles`. */
-export declare const QUICKBUNDLES_DEFAULTS: Readonly<QuickBundlesOptions>;
-/** This function gives `k` points at equal steps of length along a polyline, from its first point to its last point. */
-export declare function resample(line: readonly Point[], k: number): Point[];
-/**
- * This function gives the MDF distance of two lines with the same number of points. It is the mean distance of their points.
- * The function compares the points in the same direction and in the opposite direction, and keeps the smaller mean.
- * `flip` is `true` when the opposite direction is smaller.
- */
-export declare function mdf(p: readonly Point[], q: readonly Point[]): {
-  d: number;
-  flip: boolean;
-};
-/**
- * This function gives the clusters of QuickBundles (Garyfallidis 2012) as groups of edges.
- * In one pass, each edge joins the cluster with the nearest centroid when the MDF distance is `theta` units or less. Else it starts a cluster.
- * The centroid is the running mean of the lines of the cluster, each in the direction of the centroid.
- */
-export declare function quickBundles(input: HighwayInput, o: Readonly<QuickBundlesOptions>): Map<string, EdgeGroup>;
-/**
- * This function gives the highways of QuickBundles (HWY-026). The clusters of `quickBundles` with `minSize` edges or more get highways.
- * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
- */
-export declare function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan;
 /** The options of the highway strategy `nested` (HWY-052 of the note on highways). */
 interface NestedOptions {
   /** The scale of the closest level, in units of the board. An edge joins a cluster when its distance to the centroid is this value or less. The default is 3. */
@@ -4442,6 +5310,26 @@ export declare const highwayStrategies: {
   readonly ridges: Strategy<"highway", RidgeOptions>;
   readonly hdbscan: Strategy<"highway", HdbscanOptions>;
   readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
+  readonly divided: Strategy<"highway", DividedOptions>;
+  readonly hierarchy: Strategy<"highway", HierarchyOptions>;
+  readonly fdeb: Strategy<"highway", FdebOptions>;
+  readonly mesh: Strategy<"highway", MeshOptions>;
+  readonly kdeeb: Strategy<"highway", KdeebOptions>;
+  readonly cubu: Strategy<"highway", CubuOptions>;
+  readonly mlseb: Strategy<"highway", MlsebOptions>;
+  readonly sbeb: Strategy<"highway", SbebOptions>;
+  readonly areas: Strategy<"highway", AreaOptions>;
+  readonly confluent: Strategy<"highway", ConfluentOptions>;
+  readonly power: Strategy<"highway", PowerOptions>;
+  readonly crossbars: Strategy<"highway", CrossbarOptions>;
+  readonly frechet: Strategy<"highway", FrechetOptions>;
+  readonly spectral: Strategy<"highway", SpectralOptions>;
+  readonly resistance: Strategy<"highway", ResistanceOptions>;
+  readonly "link-communities": Strategy<"highway", LinkCommunityOptions>;
+  readonly territories: Strategy<"highway", TerritoryOptions>;
+  readonly consensus: Strategy<"highway", ConsensusOptions>;
+  readonly "p-hub": Strategy<"highway", PHubOptions>;
+  readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -4526,18 +5414,12 @@ export interface StepComparison {
  * The same graph and the same options give the same measures. Only the times change.
  */
 export declare function compareStep(step: CompareStep, graph: Graph, options?: CompareOptions): StepComparison;
-/** This function gives the bytes of a string in UTF-8. */
+/** This function gives the bytes of a string in UTF-8. The contract does not export its own `utf8`, so the core keeps this function. */
 export declare function utf8(text: string): Uint8Array;
-/** This function gives the SHA-256 digest of a string, as 64 lowercase hex characters. It encodes the string in UTF-8. */
-export declare function sha256Hex(text: string): string;
-/**
- * This function writes a value as canonical JSON: the keys of each object in sorted order, and no whitespace.
- * It drops a key whose value is `undefined`, as `JSON.stringify` does.
- */
-export declare function canonicalJson(value: unknown): string;
 /**
  * This function gives the hash of a JSON document: the first 16 hex characters of the SHA-256 of its canonical JSON.
  * The document does not include its own field `hash`. The function removes that field before it calculates the hash.
+ * The `documentHash` of the contract puts each number on a grid first, so it is not equal to this function. The hashes of the corpus files use this function.
  */
 export declare function documentHash(value: object): string;
 /** This function gives the 32-bit FNV-1a hash of the UTF-8 bytes of a text, as an unsigned integer. */
@@ -4546,7 +5428,7 @@ export declare function fnv1a32(text: string): number;
 export declare function stepSeed(seed: number, step: string): number;
 /** This function gives the generator `mulberry32` for a seed. Each call gives the next number from 0 to below 1. */
 export declare function mulberry32(seed: number): () => number;
-/** This function rounds a number to 3 decimals, as the files of a corpus keep it. The value `-0` becomes `0`. */
+/** This function rounds a number to 3 decimals (a step of `RECORD_EPS`), as the files of a corpus keep it. The value `-0` becomes `0`. */
 export declare function round3(value: number): number;
 /** The side of a port in an input file. The router calls the same sides `north`, `east`, `south` and `west`. */
 export type LayoutSide = "top" | "right" | "bottom" | "left";
@@ -4738,6 +5620,19 @@ export interface LayoutRecord {
   readonly commit?: string;
   /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */
   readonly skipped?: string;
+  /**
+   * The first 16 hex characters of the SHA-256 of the output in the highways form (ACTIVATION). `resultHash` gives it for a router.
+   * Two records with the same hash have the same output, at the precision `RECORD_EPS`.
+   */
+  readonly outputHash?: string;
+  /** The facts of the stages of the run. The trace measures `move.<name>` count the own move of the strategy (ACTIVATION). */
+  readonly trace?: readonly RecordTrace[];
+}
+/** The facts of one stage of a run, as the `StageTrace` of the contract: its id, its time and its trace measures. */
+export interface RecordTrace {
+  readonly id: string;
+  readonly ms?: number;
+  readonly measures?: Readonly<Record<string, number>>;
 }
 /** The comparison of a prediction. Without it, `<=` applies to a measure where lower is better, and `>=` to the other measures. */
 export type PredictionOp = "<" | "<=" | "=" | ">=" | ">";
@@ -4797,6 +5692,21 @@ export declare function parseLines<T>(text: string): T[];
  * A function becomes the text `function:<name>`, and a number that is not finite becomes its text.
  */
 export declare function jsonSafe(value: unknown): unknown;
+/**
+ * The smallest change of a measure that counts as better or worse (WIN-RES).
+ * A number is an absolute change. `{ rel }` is a share of the larger of the two absolute values.
+ * The threshold is not less than `RECORD_EPS` at any time.
+ */
+export type MinEffect = NonNullable<MeasureSpec["minEffect"]>;
+/** The result of a compare of a candidate with a baseline on one measure. A tie is not a win. It is the `Verdict` of the contract. */
+export type MeasureCompare = Verdict;
+/** The part of a measure that a compare reads: the better side and the minimum effect. */
+export type CompareSpec = Pick<MeasureSpec, "direction" | "minEffect">;
+/**
+ * This function applies the wave rule to the compares of one board, for example of `B1` and of the `B3` q95.
+ * The board is a win only when no compare is `worse` and one or more compares are `better`. Thus a board of ties is not a win.
+ */
+export declare function boardWins(compares: readonly MeasureCompare[]): boolean;
 /**
  * One measure of a record. `key` is the key of the measure in the values of `runSuite` and `compareStep`.
  * `name` is the name of the measure in a record of the form `layout-record/1`.
@@ -4815,13 +5725,32 @@ export interface MeasureInfo {
    * Then two values compare only on the same input. The value is `false` when the measure scores the routes or the curves for a fixed placement.
    */
   readonly placementDependent: boolean;
+  /**
+   * The smallest change that counts as better or worse in `compareMeasure` (WIN-RES). `MIN_EFFECTS` gives it by the unit, with its reason.
+   * A measure without this field has the threshold `RECORD_EPS`.
+   */
+  readonly minEffect?: MinEffect;
+}
+/** One rule of `MIN_EFFECTS`: the units, the minimum effect of a measure with one of these units, and the reason. */
+export interface MinEffectRule {
+  readonly units: readonly string[];
+  /** The minimum effect. The value `undefined` gives the threshold `RECORD_EPS`. */
+  readonly minEffect: MinEffect | undefined;
+  readonly reason: string;
 }
+/**
+ * The minimum effect of each measure of `MEASURES`, by the unit of the measure (WIN-RES).
+ * Each unit of `MEASURES` is in one rule. The test of the module checks it.
+ */
+export declare const MIN_EFFECTS: readonly MinEffectRule[];
 /**
  * The measures of the records of the stage `route`, with the placement dependence of each one.
  * A joint harness that moves the boxes and routes the edges reads `placementDependent`.
  * It compares a measure with the value `true` only between runs on the same input.
  */
 export declare const MEASURES: readonly MeasureInfo[];
+/** This function gives the spec of a compare of a measure: its better side and its minimum effect. */
+export declare function compareSpec(info: MeasureInfo): CompareSpec;
 /** This function gives the measure of a key of `runSuite` or `compareStep`, or `undefined` for a key that is not in `MEASURES`. */
 export declare function measureByKey(key: string): MeasureInfo | undefined;
 /** This function gives the measure of a name of a record, or `undefined` for a name that is not in `MEASURES`. */
@@ -4857,7 +5786,7 @@ export interface ScreenSet {
  * This set does not change. The tests compare it with the files in `corpus/screen-v1`.
  */
 export declare const SCREEN_V1: ScreenSet;
-/** The screen sets by id. */
+/** The screen sets by id: `screen-v1`, the small boards with a known optimum `exact-v1` (MEAS2), and the larger boards with bounds `exact-v1-bounds` (EXACT-BOUNDS). */
 export declare const SCREEN_SETS: Readonly<Record<string, ScreenSet>>;
 /** This function gives the id of the member `seed` of a family of a set: `<set>/<family>/s<seed>`. */
 export declare function inputId(set: string, family: string, seed: number): string;
@@ -4883,6 +5812,257 @@ export interface LayoutCorpus {
 }
 /** This function gives the manifest of a list of inputs. The inputs of one generator, version and parameters share one spec. */
 export declare function corpusManifest(corpus: string, inputs: readonly LayoutInput[]): LayoutCorpus;
+/**
+ * This function gives the output hash of a result of a router, in the highways form.
+ * The form holds the routes in the order of the edge ids, and the levels, the bundles and the runs as the router gives them.
+ * Each number goes to the grid `RECORD_EPS`, as `round3` does.
+ */
+export declare function resultHash(result: Result): string;
+/** This function gives the highways form of a result of a router: the value that `resultHash` hashes. */
+export declare function resultForm(result: Result): object;
+/** This function gives the output hash of the curves of the step `curve`, in the order of the edge ids. */
+export declare function curvesHash(edges: readonly string[], curves: readonly (readonly CurveSegment[])[]): string;
+/**
+ * The name of the own move of each built-in highway finder. The trace of a record names the count `move.<name>`.
+ * The count is the number of highways of the plan with 2 edges or more. A finder without an entry counts `move.highway`.
+ */
+export declare const MOVE_NAMES: Readonly<Record<string, string>>;
+/**
+ * The highway strategies that change the plan of another strategy (`from`). Their own move is a change of that plan, so they count no move.
+ * The output against the plan `from` tells if they ran.
+ */
+export declare const PLAN_CHANGERS: readonly string[];
+/**
+ * This function gives the built-in highway strategy of a name: the strategy itself, or the strategy of a variant, for example `power` for `power-near`.
+ * It gives `undefined` for a gate (a name with `+`) and for a name of another step.
+ */
+export declare function finderOf(name: string): string | undefined;
+/**
+ * This function gives the count of the own move of a highway strategy on its plan, for example `{ "move.powerEdge": 3 }`.
+ * It gives `undefined` for a gate and for a strategy of `PLAN_CHANGERS`.
+ */
+export declare function planMoves(name: string, plan: HighwayPlan): Record<string, number> | undefined;
+/** A function that gives the own move counts of a strategy on a graph, or `undefined` for a strategy without a count. */
+export type MoveCounter = (strategy: string, graph: Graph) => Readonly<Record<string, number>> | undefined;
+/** This function gives a `MoveCounter` for highway strategies, by the names of the records. It makes the plan of the strategy again. */
+export declare function highwayMoves(strategies: Readonly<Record<string, Strategy<"highway", object>>>): MoveCounter;
+/**
+ * This function gives the base of a strategy for the fallback test: the strategy that it falls back to or extends.
+ * - A gate `X+G` and a wrapped router `X+W` have the base `X`.
+ * - A highway finder of a module (`hw:power`, `w3e:power-near`) has the base `hw:none`, the empty plan.
+ * - A plan changer has the base of its plan `from`: `hw:shared-ways`, or `hw:corridors` and `hw:none` for a name that ends with `-corridors` and `-none`.
+ * - An option of a router (`shared-cap-3`, `shared-all-p3`, `trunks-tree-bf02`, `corners-side`) has the base `shared`, `shared-all`, `trunks` or `corners`.
+ * The function gives `undefined` when the base is not in `known`.
+ */
+export declare function activationBase(name: string, known: ReadonlySet<string>): string | undefined;
+/** The activation of one strategy over the decision inputs of a screen. */
+export interface ActivationRow {
+  readonly strategy: string;
+  /** The base of the fallback test, or `undefined` when the strategy has none. */
+  readonly base?: string;
+  /** The decision inputs where the strategy ran. */
+  readonly inputs: number;
+  /** The decision inputs where a move count is above 0. */
+  readonly moved: readonly string[];
+  /** The decision inputs where the output differs from the output of the base. */
+  readonly differs: readonly string[];
+  /** The sum of each move count over the decision inputs. */
+  readonly moves: Readonly<Record<string, number>>;
+  readonly verdict: "exercised" | "not-exercised";
+  /** The id of the output group of the strategy on the decision inputs. */
+  readonly group: string;
+}
+/** The groups of the strategies with equal output on each input of one cell (a family of boards). They are diagnostics only. */
+export interface CellGroups {
+  readonly cell: string;
+  readonly groups: readonly OutputGroup[];
+}
+/** The activation report of a screen. */
+export interface ActivationReport {
+  /** The decision inputs, in sorted order. */
+  readonly inputs: readonly string[];
+  readonly rows: readonly ActivationRow[];
+  /** The output groups with more than one strategy: equal output hashes on each decision input. */
+  readonly groups: readonly OutputGroup[];
+  /** The cell groups with more than one strategy, for each family of the decision inputs. */
+  readonly cells: readonly CellGroups[];
+}
+/** This function gives the family of an input id, for example `small-clustered` for `screen-v1/small-clustered/s0`. */
+export declare function familyOf(input: string): string;
+/** This function gives the move counts of a record, from its trace. */
+export declare function recordMoves(record: LayoutRecord): Record<string, number>;
+/**
+ * This function gives the activation report of the records of a screen.
+ * A strategy is exercised when a move count is above 0 on a decision input.
+ * It is also exercised when its output differs from the output of its base on a decision input.
+ * The decision inputs are the inputs of the families `families`, or each input. `bases` gives the base of each strategy, or `activationBase` gives it.
+ */
+export declare function activationReport(records: readonly LayoutRecord[], options?: {
+  readonly families?: readonly string[];
+  readonly bases?: Readonly<Record<string, string>>;
+}): ActivationReport;
+/** This function writes the activation report as Markdown: the strategies that are not exercised, and the output groups. */
+export declare function formatActivation(report: ActivationReport, candidates?: ReadonlySet<string>): string;
+/** The rule of the exact model: `collection` lets only the edges of one collection share a link, and `all` lets each edge share a link. */
+export type GapRule = "collection" | "all";
+/** The rules of the gap closed, in the order of the records. */
+export declare const GAP_RULES: readonly GapRule[];
+/**
+ * A view of the gap closed: one rule, or `chosen`. The view `chosen` takes a rule for each run.
+ * It takes `all` when a shared segment of the run holds edges of two collections. Else it takes `collection`.
+ */
+export type GapView = GapRule | "chosen";
+/** The views of the gap closed, in the order of the tables. */
+export declare const GAP_VIEWS: readonly GapView[];
+/** The stretch caps of the exact optima, from small to large. */
+export declare const GAP_CAPS: readonly number[];
+/** The baseline of each rule: the router `shared` for `collection`, and the plan `shared-ways-all` after `follow` for `all`. */
+export declare const GAP_BASELINES: Readonly<Record<GapRule, string>>;
+/** The parameters of the paired bootstrap of the gap closed, from `docs/PROMOTION.md`. */
+export declare const GAP_BOOTSTRAP: {
+  readonly runs: number;
+  readonly level: number;
+  readonly seed: number;
+};
+/** The optimum of the exact model on one input, for one rule and one stretch cap. The file of the optima of a set holds one for each. */
+export interface ExactOptimum {
+  /** The id of the input. */
+  readonly input: string;
+  /** The hash of the input file. The screen uses the optimum only when the hash matches. */
+  readonly hash: string;
+  /** The class of the input: its family in the set. */
+  readonly class: string;
+  readonly nodes: number;
+  readonly edges: number;
+  readonly rule: GapRule;
+  readonly cap: number;
+  /** The status of HiGHS: `optimal`, `time-limit` or another status. */
+  readonly status: string;
+  /** This value is `true` when HiGHS proved the optimum within the time limit. */
+  readonly proven: boolean;
+  /** The objective of the best solution, the dual bound and the relative MIP gap. Each one is `null` when HiGHS gives none. */
+  readonly objective: number | null;
+  readonly bound: number | null;
+  readonly mipGap: number | null;
+  /** The time of the solve, in seconds. */
+  readonly seconds: number;
+  /** The number of binary variables of the model. */
+  readonly binaries: number;
+  /** The ink saved (B1) of the routes of the best plan after `follow`. The gap closed uses this value. */
+  readonly b1: number | null;
+  /** The ink saved of the model itself, without `follow`. */
+  readonly modelB1: number | null;
+  /** The largest bundle stretch (B3) of the routes of the best plan, against the routes of `corners`. */
+  readonly b3max: number | null;
+  /** The number of highways of the best plan. */
+  readonly highways: number;
+}
+/** The file of the optima of a set (`exact-optima/1`). Later screens read it and do not solve again. */
+export interface ExactOptimaFile {
+  readonly schema: "exact-optima/1";
+  readonly set: string;
+  /** The time limit of each solve, in seconds. */
+  readonly seconds: number;
+  /** The commit of the code and the CI run of the solves. */
+  readonly commit?: string;
+  readonly run?: string;
+  readonly optima: readonly ExactOptimum[];
+}
+/** This function gives the file of the optima of a set, with the rows in the order of the input, the rule and the cap. */
+export declare function optimaFile(set: string, rows: readonly ExactOptimum[], at: {
+  readonly seconds: number;
+  readonly commit?: string;
+  readonly run?: string;
+}): ExactOptimaFile;
+/** This function gives the key of an optimum in a map: the input, the rule and the cap. */
+export declare function optimumKey(input: string, rule: GapRule, cap: number): string;
+/** This function gives the smallest cap that is at least the stretch, or `undefined` when the stretch is above the largest cap. */
+export declare function gapCap(stretch: number, caps?: readonly number[]): number | undefined;
+/**
+ * This function gives the gap closed: `(b1 - base) / (optimum - base)`.
+ * It gives `undefined` when the denominator is 0 or less, because then the baseline is at the optimum or above it.
+ */
+export declare function gapClosed(b1: number, base: number, optimum: number): number | undefined;
+/**
+ * This function gives the largest bundle stretch of routes against base routes: the max of `L(r_e) / L(r*_e)` over the edges, as B3 counts them.
+ * An edge without a base route, or with a base route of 1 unit or less, does not count. Without such an edge, the value is 1.
+ */
+export declare function maxStretch(routes: readonly Route[], base: readonly Route[]): number;
+/** The highway strategy `shared-ways-all`: the plan of the router `shared` without a rule. It is the baseline of the rule `all`. */
+export declare const sharedWaysAll: Strategy<"highway", object>;
+/** This function gives the B1 of the baseline of each rule on a graph. */
+export declare function gapBaselines(graph: Graph): Record<GapRule, number>;
+/** A median with its paired bootstrap interval. */
+export interface BootstrapMedian {
+  readonly median: number;
+  readonly lo: number;
+  readonly hi: number;
+}
+/**
+ * This function gives the median of the values and its bootstrap interval: `runs` samples of the values with replacement, from the seed `seed`.
+ * The interval is the central `level` share of the medians of the samples. Each value is the paired value of one input, so the bootstrap is paired.
+ */
+export declare function bootstrapMedian(values: readonly number[], o?: {
+  readonly runs?: number;
+  readonly level?: number;
+  readonly seed?: number;
+}): BootstrapMedian;
+/** The gap closed of one strategy and one view over the inputs of a screen. */
+export interface GapSummary {
+  readonly strategy: string;
+  readonly rule: GapView;
+  /** The number of runs, and the number of runs with a value. A run has no value above the largest cap, or without a proven optimum. */
+  readonly runs: number;
+  readonly values: number;
+  /** The median over the inputs with a value, and its paired bootstrap interval. */
+  readonly median: number;
+  readonly lo: number;
+  readonly hi: number;
+  /** The median of each class, by the family of the input. */
+  readonly byClass: Readonly<Record<string, number>>;
+  /** The number of values at each cap, by the cap. */
+  readonly caps: Readonly<Record<string, number>>;
+  /** The number of runs with some ink saved (B1 above 0): the runs where the strategy builds a shared segment. */
+  readonly builds: number;
+  /** The number of runs where a shared segment holds edges of two collections. */
+  readonly mixed: number;
+}
+/** The names of the measures of the gap closed in a record, for a view. */
+export declare function gapNames(view: GapView): {
+  readonly gap: string;
+  readonly cap: string;
+};
+/**
+ * This function gives the gap closed of each strategy and view over records.
+ * It sorts them by the view and then by the median, from high to low.
+ * A strategy with a value on fewer than half of its runs comes after the others, because its median shows only a few inputs.
+ */
+export declare function summarizeGap(records: readonly {
+  readonly strategy: string;
+  readonly input: string;
+  readonly skipped?: string;
+  readonly measures: Readonly<Record<string, number>>;
+}[]): GapSummary[];
+/** This function writes the gap closed as Markdown: one table for each view, sorted by the median. */
+export declare function formatGap(rows: readonly GapSummary[]): string;
+/** This function gives the count of the shared segments of a result (the runs and the bundles) that hold edges of two collections or more. */
+export declare function mixedSegments(graph: Graph, result: Result): number;
+/** This function tells if a shared segment of a result (a run or a bundle) holds edges of two collections. */
+export declare function mixesCollections(graph: Graph, result: Result): boolean;
+/**
+ * This function gives the gap measures of the result of one run on an input with optima, by the keys of `MEASURES`.
+ * `B3.max` is the largest stretch against the routes of `corners`. `gap.stretch` is the largest stretch as the exact model counts it (`exactStretch`).
+ * The cap is the smallest cap at or above `gap.stretch`, so both sides of the gap have the same stretch limit.
+ *
+ * `gap.<rule>` is the gap closed at the cap `gap.cap.<rule>`. `gap` is the gap closed of the rule of the run.
+ * That rule is `all` when `gap.mixed` is 1, else `collection`.
+ * A rule has no value above the largest cap or without a proven optimum at the cap.
+ * It also has no value when the hash of the optimum is not the hash of the input.
+ */
+export declare function gapValues(input: {
+  readonly id: string;
+  readonly hash: string;
+}, graph: Graph, result: Result, corners: readonly Route[], baselines: Readonly<Record<GapRule, number>>, optima: ReadonlyMap<string, ExactOptimum>): Record<string, number>;
 /**
  * The steps of the screen: the steps of `compareStep` and the step `highway`.
  * The screen of the step `highway` routes the plan of each strategy with `follow`, and measures the routes as the routes of a router.
@@ -4945,6 +6125,16 @@ export interface ScreenOptions {
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
   readonly predictions?: readonly LayoutPrediction[];
+  /**
+   * The exact optima of the inputs, from the file of the optima of a set (MEAS2). The steps `router` and `highway` read them.
+   * Each run on an input with optima gets the largest B3 and the gap closed of each rule (B10). The summary then gets the gap table.
+   */
+  readonly optima?: readonly ExactOptimum[];
+  /**
+   * This function gives the own move counts of a strategy on an input (ACTIVATION), for example `{ "move.powerEdge": 3 }`.
+   * Each record of a strategy with counts gets them as the trace measures of its step. The default is no counts.
+   */
+  readonly moves?: MoveCounter;
   /** This function gets one line of progress for each input. */
   readonly log?: (line: string) => void;
 }
@@ -4998,6 +6188,8 @@ export interface ScreenSummary {
   /** The strategies with a break over the floor, without a run or with two different outputs of one input. They do not enter the front. */
   readonly excluded: readonly string[];
   readonly predictions: readonly PredictionCheck[];
+  /** The gap closed of each strategy and rule, when the screen has optima. */
+  readonly gap?: readonly GapSummary[];
 }
 /** The result of `screen`: one record for each strategy and input, and the summary. */
 export interface ScreenReport {
@@ -5033,6 +6225,48 @@ export interface RectScatteredParams {
  * The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
  */
 export declare function rectScattered(seed: number, params: RectScatteredParams, set?: string): LayoutInput;
+/** The board classes of the small boards with a known optimum (MEAS2). */
+export type ExactClass = "uniform" | "clustered" | "hubs" | "fanout";
+/** The board classes of `EXACT_V1`, in the order of the set. */
+export declare const EXACT_CLASSES: readonly ExactClass[];
+/** The edges of each node of a small board with a known optimum. */
+export declare const EXACT_EDGES_PER_NODE = 1.5;
+/** This function gives the seed of the fixture of the member `k` of a class: `100 × (the index of the class + 1) + k`. */
+export declare function exactSeed(cls: ExactClass, k: number): number;
+/** This function gives the generator of a small board: the generator `fixture` with the kind of the class, `nodes` and the seed of `exactSeed`. */
+export declare function exactGenerator(cls: ExactClass, nodes: number, k: number): LayoutGenerator;
+/** This function makes the small board of a class with `nodes` nodes and the member `k`. The same values always give the same graph. */
+export declare function exactBoard(cls: ExactClass, nodes: number, k: number): Graph;
+/**
+ * This function gives a family of small boards of one class. The member `k` has `sizes[k mod sizes.length]` nodes.
+ * The count of the cell is `10`, because each board has fewer than 100 nodes.
+ */
+export declare function exactFamily(cls: ExactClass, sizes: readonly number[], seeds: number): ScreenFamily;
+/**
+ * The node counts of the boards of `EXACT_V1`. The member `k` of each class has `EXACT_V1_SIZES[k mod length]` nodes.
+ * The size ladder of MEAS2 (CI run 40613531631) proved each optimum at 10 nodes within 300 s, for each class, both rules and the cap 1.5.
+ * At 14 nodes, 4 of 24 solves stopped at the time limit.
+ */
+export declare const EXACT_V1_SIZES: readonly number[];
+/** The number of seeds of each class of `EXACT_V1`. It is `cellMin` of the promotion rule. */
+export declare const EXACT_V1_SEEDS = 10;
+/**
+ * The screen set `exact-v1` (MEAS2): small boards of made-up data with a known optimum of the exact model.
+ * It has 4 classes of 10 seeds. The file `optima-exact-v1.json` of `bench/exact` keeps the optimum of each input, each rule and each cap.
+ * This set does not change. The tests compare it with the files in `corpus/exact-v1`.
+ */
+export declare const EXACT_V1: ScreenSet;
+/** The node counts of the boards of `EXACT_V1_BOUNDS`. HiGHS proves few optima at these sizes within 300 s, so the set keeps bounds (EXACT-BOUNDS). */
+export declare const EXACT_V1_BOUNDS_SIZES: readonly number[];
+/** This function gives the name of the family of a class at a size in `EXACT_V1_BOUNDS`: `<class>-n<nodes>`. */
+export declare function boundsFamilyName(cls: ExactClass, nodes: number): string;
+/**
+ * The screen set `exact-v1-bounds` (EXACT-BOUNDS): the boards of the classes of `exact-v1` at 18, 24 and 40 nodes, with 10 seeds each.
+ * Each family is one class at one size. The member `k` uses the seed `exactSeed(class, k)`, as in `exact-v1`.
+ * The file `optima-exact-v1-bounds.json` of `bench/exact` keeps the best bound and the best solution of each input, each rule and each cap.
+ * This set does not change. The tests compare it with the files in `corpus/exact-v1-bounds`.
+ */
+export declare const EXACT_V1_BOUNDS: ScreenSet;
 /** The options of `follow`. */
 interface FollowOptions extends WayOptions {
   /**
@@ -5109,6 +6343,41 @@ interface SharedStretchOptions {
  * The `seq` of each member follows the order of the stretches along the way.
  */
 export declare function sharedStretches(ways: readonly KeyedWay[], o: Readonly<SharedStretchOptions>): HighwayPlan;
+/** The options of `tracePlan`. */
+interface TraceOptions {
+  /** The side of the grid that the waypoints snap to, in units of the board. The value 0 keeps each waypoint where it is. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /** The key of the ways. Only the ways with one key share a highway. */
+  readonly key: string;
+}
+/**
+ * This function moves a point out of each box, made larger by `pad`. A point in a box moves to the nearest side of that box.
+ * The function tries four times, so a point between two near boxes can stay in a box.
+ */
+export declare function outOfBoxes(obstacles: Obstacles, p: Point, pad: number): Point;
+/**
+ * This function gives the push of the boxes on a point. Each box nearer than `reach` adds a unit vector away from it, times `(reach - d) / reach`.
+ * The value `d` is the distance from the point to the box. It is the gradient of a field that is 0 at the distance `reach` from each box.
+ */
+export declare function boxPush(obstacles: Obstacles, p: Point, reach: number): Point;
+/** This function gives points at equal steps of `step` or a little less along a polyline, without its two ends. A polyline without length gives no point. */
+export declare function innerPoints(line: readonly Point[], step: number): Point[];
+/**
+ * This function gives the way of one edge through its waypoints. The way starts at `a` and ends at `b`.
+ * Each waypoint snaps to the grid of side `snap`. A waypoint in a box moves to the nearest corner of the corner graph.
+ * From each waypoint to the next one, the way is a straight line when that line is clear. Otherwise it goes through the corner graph.
+ * A waypoint that the graph does not reach is not on the way. When the way cannot reach `b`, the function gives the way of the corner graph from `a` to `b`.
+ */
+export declare function waypointWay(finder: WayFinder, a: Point, b: Point, waypoints: readonly Point[], snap: number): Point[] | undefined;
+/**
+ * This function gives the highways of the waypoints of each edge. The ways go through the corner graph, so they stay out of the boxes.
+ * Each edge goes from the point at `margin` from its source plug, through its waypoints, to the point at `margin` from its target plug.
+ * Each stretch that `minSize` ways or more share is one highway, with the needless corners removed.
+ * An edge without waypoints takes its way of the corner graph.
+ */
+export declare function tracePlan(input: HighwayInput, finder: WayFinder, waypoints: ReadonlyMap<string, readonly Point[]>, o: Readonly<TraceOptions>): HighwayPlan;
 /**
  * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
  * The nodes and the edges do not change. Two orders of the same edges give the same graph.
@@ -5217,5 +6486,145 @@ export declare function withRepair(router: Router, options?: RepairOptions): Rou
  * The new strategy has the name `<name>+repair`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
  */
 export declare function repairStrategy<O extends object>(strategy: Strategy<"router", O>, repair?: RepairOptions): Strategy<"router", O>;
-export type { AmbiguityGuardOptions, ArcOptions, 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 };
+/** The rule of the caller. Under `collection`, a shared segment holds edges of one collection only. Under `all`, collections can mix. */
+export type PortfolioRule = "collection" | "all";
+/** The stretch caps of the portfolio router: the caps of the gap closed (B10). */
+export type PortfolioCap = 1.1 | 1.25 | 1.5;
+/** The rules of the portfolio router. */
+export declare const PORTFOLIO_RULES: readonly PortfolioRule[];
+/** The caps of the portfolio router. */
+export declare const PORTFOLIO_CAPS: readonly PortfolioCap[];
+/** The sizes of the sets of the portfolio router, without the base. */
+export declare const PORTFOLIO_KS_API: readonly (3 | 5 | 8)[];
+/** One size band of the inputs. Each band has its own greedy sets. */
+export interface PortfolioBand {
+  readonly id: string;
+  /** The largest node count of the band. An input with more nodes than the last band uses the last band. */
+  readonly maxNodes: number;
+}
+/** The size bands: up to 12 nodes, 13 to 24 nodes, and 25 to 40 nodes. An input above 40 nodes uses the band `n25-40`. */
+export declare const PORTFOLIO_BANDS: readonly PortfolioBand[];
+/** This function gives the band of a node count: the first band whose `maxNodes` is the count or more, else the last band. */
+export declare function portfolioBand(nodes: number, bands?: readonly PortfolioBand[]): PortfolioBand;
+/**
+ * The fit of each rule, cap and size band, by the key `<rule>|<cap>|<band>`: the members of the default of the portfolio router, in their order.
+ * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 40 ms.
+ * The base `shared` is not in a fit: the portfolio always runs it first.
+ */
+export declare const PORTFOLIO_FIT: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly (readonly [string, number])[]>>;
+/** The id of the B1 level of the key of the portfolio router. */
+export declare const PORTFOLIO_B1 = "B1";
+/** This function gives the spec of the B1 level: higher is better, with the `minEffect` of the row `B1.inkSaved` of the table `MEASURES`. */
+export declare function portfolioB1Spec(): CompareSpec;
+/** The facts of one output that the guard reads. The router takes them from the output, and the script `portfolio.ts` from a record. */
+export interface PortfolioFacts {
+  /** The count of the breaks of each hard rule. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The count of the edges with a stretch above each cap, by the cap. The largest stretch of a record gives 1 or 0. */
+  readonly over: (cap: number) => number;
+  /** The count of the shared segments that hold edges of two collections. */
+  readonly mixed: number;
+}
+/**
+ * This function gives the count of the breaks of the guard of an output against the base, with the rule `rule` and the cap `cap`.
+ * The count is the sum of three parts:
+ * - for each hard rule, the breaks above the breaks of the base
+ * - the edges with a stretch above the cap
+ * - under the rule `collection`, the mixed segments.
+ * An output passes the guard when the count is 0.
+ */
+export declare function guardBreaks(facts: PortfolioFacts, base: PortfolioFacts | undefined, rule: PortfolioRule, cap: number): number;
+/**
+ * This function gives the function of the facts of the outputs on the graph `graph`. It builds the network of the stretch one time for the graph.
+ * The hard rules are the rules of `checkProperties`. The stretch is the stretch of the exact model, as the records of the gap screen give it.
+ */
+export declare function portfolioFacts(graph: Graph): (result: Result) => PortfolioFacts;
+/**
+ * This function gives the key of the portfolio router on the graph `graph`, with the rule `rule` and the cap `cap`.
+ * - `hard` is `guardBreaks` against the output of the base. `base` gives that output after the base runs. The output of the base has 0 breaks.
+ *   Before the base runs, or when the base throws, a member has its own breaks of the hard rules.
+ * - The one level `B1` is the ink saved (higher is better), with the `minEffect` of the table `MEASURES`.
+ * - The hash is `resultHash`.
+ * The winner is the first member with the most B1 of the members with 0 breaks (`selectBest`). The base has 0 breaks, so a member that fails the guard does not win.
+ */
+export declare function portfolioKey(graph: Graph, rule: PortfolioRule, cap: PortfolioCap, base?: () => Result | undefined): PortfolioKey<Graph, Result>;
+/** The name of a built-in highway strategy. */
+type HighwayName = keyof typeof highwayStrategies;
+/**
+ * The form of one member:
+ * - `["shared", options]`, `["trunks", options]` or `["corners", options]`: the router with the options. `shared` and `trunks` use the rule `byCollection`.
+ * - `["highway", name]`: the built-in highway strategy `name`, or `shared-ways-all`, with `follow`.
+ * - `["gate", name, gate, budget?]`: the built-in highway strategy with the gate `stretch`, `breakeven` or `ambiguity`. `budget` sets the budget of the gate `stretch`.
+ * - `["plan", name, options]`: the plan of the built-in highway strategy `name` with other options.
+ */
+export type MemberForm = readonly ["shared", Omit<SharedOptions, "name" | "rule">] | readonly ["trunks", Omit<TrunksOptions, "name" | "rule">] | readonly ["corners", Omit<CornersOptions, "name">] | readonly ["highway", HighwayName | "shared-ways-all"] | readonly ["gate", HighwayName, "stretch" | "breakeven" | "ambiguity", number?] | readonly ["plan", HighwayName, Readonly<Record<string, unknown>>];
+/** The forms of the members, by the names of the records. `shared` is the base. The greedy sets of `sets.ts` name only these members. */
+export declare const MEMBER_FORMS: Readonly<Record<string, MemberForm>>;
+/** This function gives the router strategy of a member form, with the name `name`. */
+export declare function memberStrategy(name: string, form: MemberForm): Strategy<"router", object>;
+/** This function gives the member with the name `name`, or `undefined` for a name without a form in `MEMBER_FORMS`. */
+export declare function portfolioMember(name: string): Strategy<"router", object> | undefined;
+/** The options of the portfolio router. */
+export interface PortfolioRouterOptions {
+  /** The rule of the caller. Under `collection` (the default), a shared segment must hold edges of one collection only. Under `all`, collections can mix. */
+  readonly rule?: PortfolioRule;
+  /** The stretch cap of the caller: 1.1, 1.25 or 1.5 (the default). An output with an edge above the cap does not win. The base is the fallback output. */
+  readonly cap?: PortfolioCap;
+  /**
+   * The count of members after the base: 3, 5 or 8. Without `k` (the default), the router runs the fit of `fit.ts`.
+   * The fit gives a member count for each rule, cap and band, and a node limit for each member. Thus the default is deterministic.
+   */
+  readonly k?: 3 | 5 | 8;
+  /**
+   * A time limit of the pick in milliseconds, as a ceiling that the caller sets. The base always runs. The combinator cuts the members that start after the limit.
+   * A cut by the budget makes the output depend on the speed of the machine. Then the trace has `deterministic: false`.
+   */
+  readonly budgetMs?: number;
+  /** The largest count of members that run, with the base. */
+  readonly maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`. */
+  readonly now?: () => number;
+}
+/** The base member of each portfolio: the router `shared` with the rule `byCollection`. It is the fallback output above the cap. */
+export declare const PORTFOLIO_BASE_MEMBER = "shared";
+/** The result of the portfolio router: the output of the winner, the winner, the trace of the pick, the move counts and the band. */
+export interface PortfolioRoute {
+  readonly result: Result;
+  readonly winner: string;
+  readonly trace: PortfolioTrace;
+  /** The move count of the pick (ACTIVATION): `{ "move.pick": 1 }` when the winner is not the base and has another output. */
+  readonly moves: Readonly<Record<string, number>>;
+  /** The size band of the input, from its node count. */
+  readonly band: string;
+  /** The names of the members, in their order. */
+  readonly members: readonly string[];
+}
+/** This function gives the name of the portfolio router with the options `options`: `portfolio-<rule>-<cap>-k<k>`, or `portfolio-<rule>-<cap>-fit` without `k`. */
+export declare function portfolioName(options?: PortfolioRouterOptions): string;
+/**
+ * This function gives the names of the members for an input with `nodes` nodes. The base comes first.
+ * - With `k`, the first `k` names of the set of the band follow.
+ * - Without `k`, the members of the fit of the band follow, each only when `nodes` is at or below its node limit.
+ */
+export declare function portfolioMembers(nodes: number, options?: PortfolioRouterOptions): string[];
+/**
+ * This function routes the graph `graph` with the portfolio of its size band, rule and cap. The base runs first, then the members in their order.
+ * The key is `portfolioKey`: a member wins only when it passes the guard against the base. Of those members, the winner has the most ink saved.
+ * A tie within the `minEffect` of B1 goes to the first member (`selectBest`). A member that throws does not win.
+ * The result carries the trace of the pick and the move count `move.pick`.
+ */
+export declare function routePortfolio(graph: Graph, options?: PortfolioRouterOptions): PortfolioRoute;
+/** This function gives a router that routes each graph with `routePortfolio` and the options `options`. Its name is `portfolioName(options)`. */
+export declare function portfolioRouter(options?: PortfolioRouterOptions): Router;
+/**
+ * The portfolio router as a router strategy. It is not in the registry `STRATEGIES`, so the benchmark and the site do not race it by default.
+ * A caller adds it to a registry of its own, or calls `routePortfolio` for the trace.
+ */
+export declare const portfolioStrategy: Strategy<"router", PortfolioRouterOptions>;
+/**
+ * The greedy set of each rule, cap and size band, by the key `<rule>|<cap>|<band>`. The set of k strategies is the first k names.
+ * Each set comes from the train seeds (0 to 4) of its band. The base `shared` is not in a set: the portfolio always runs it first.
+ */
+export declare const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly string[]>>;
+export { type AdvectionSettings, type AmbiguityGuardOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type Biclique, type BreakEvenOptions, type BundleLine, type BundleOrder, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrechetBundle, type FrechetOptions, type Gate, type GroupScope, type GroupSpine, type GroupedOptions, type GrowthOptions, type GrowthOrder, type HashOptions, type HdbscanOptions, type HierarchyGroups, type HierarchyOptions, type Highway, type HighwayBase, type HighwayInput, type HighwayMember, type HighwayOptions, type HighwayPlan, type HoughOptions, type HoughPeak, type HubAllocation, type HubArcOptions, type HubCandidates, type HysteresisOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type MeetOptions, type Member, type MemberStatus, type MemberTrace, type MeshOptions, type MingleOptions, type MlsFit, type MlsebOptions, type ModuleRule, type NestedOptions, type NodeKey, type NodeLinks, type OdCellOptions, type OutputGroup, type PHubOptions, type PathStep, type PickSpec, type Portfolio, type PortfolioKey, type PortfolioLevel, type PortfolioOptions, type PortfolioPick, type PortfolioTrace, type PowerOptions, type QuickBundlesOptions, RECORD_EPS, type ResistanceOptions, type Ridge, type RidgeOptions, type RidgeSource, type RoadClassOptions, type RoomBends, type RoundedOptions, type RouteCrossing, type RouteSegment, type SbebOptions, type ScaleCluster, type ScaleSpaceOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedOptions, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SmoothOptions, type SnapLine, type SnapMember, type SnapOptions, type SoftKeyOptions, type SpectralOptions, type SpiralNode, type SpiralOptions, type SplineOptions, type SplitCell, type StableIdOptions, type StretchOptions, type StubEnds, type StubOptions, type TerritoryOptions, type TerritoryPoints, type TraceOptions, type TraclusOptions, type TrafficRule, type TrunkFan, type TrunkSplit, type TrunksOptions, type WeiszfeldOptions, type WspdOptions, type Zip, type ZipLimits, type ZipperOptions, canonicalJson, compareMeasure, exercised, minEffectOf, outputGroups, outputHash, pickMoves, portfolio, selectBest, sha256Hex };
 //# sourceMappingURL=index.d.ts.map