@mark1russell7/highways 0.9.0 → 0.9.2

package/build/index.d.ts

@@ -83,7 +83,8 @@ export declare function segmentBounds(a: Point, b: Point): Box;
 export type Side = "north" | "east" | "south" | "west";
 /**
  * A plug of a node: a place where edges go into the node.
- * A plug with `at` is fixed. The router does not move it. A plug without `at` is free: the router places it.
+ * A plug with `at` is fixed. The router does not move it. A plug with `side` and `along` is fixed too.
+ * Another plug is free: the router places it.
  */
 export interface Port {
   readonly id: string;
@@ -91,6 +92,12 @@ export interface Port {
   readonly at?: Point;
   /** This side is where a free plug goes. Without it, the router picks the side. */
   readonly side?: Side;
+  /**
+   * This fraction from 0 to 1 fixes the plug on its `side`. The plug is at the side start plus `along` times the side length.
+   * The start of `north` and `south` is the left end. The start of `east` and `west` is the top end.
+   * A plug with `along` needs a `side` and has no `at`. `resolvePorts` throws a `RangeError` for a bad value.
+   */
+  readonly along?: number;
 }
 /** A node: a box that routes must not go through. */
 export interface Node {
@@ -99,6 +106,12 @@ export interface Node {
   readonly ports?: readonly Port[];
   /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
   readonly data?: Readonly<Record<string, unknown>>;
+  /**
+   * This id names the frame node that holds the node. A frame is a node that another node names as its parent.
+   * An edge from a plug of a frame to a node in the frame is an inner edge (`splitFrames`). The router `corners` routes it inside the frame.
+   * A parent that names no node, or a cycle of parents, makes each router throw a `RangeError`.
+   */
+  readonly parent?: string;
 }
 /** One end of an edge: a node, and optionally one plug of that node. */
 export interface End {
@@ -121,6 +134,8 @@ export interface Graph {
 export interface Route {
   readonly edge: string;
   readonly points: readonly Point[];
+  /** This id names the frame of an inner route: the route stays inside the box of that node. An outer route has no frame. */
+  readonly frame?: string;
 }
 /**
  * One zoom level of a result. Each shown item is a node or a group of nodes.
@@ -190,8 +205,46 @@ export interface Router {
 }
 /** This function gives a map from the id of each node to the node. */
 export declare function nodeIndex(g: Graph): Map<string, Node>;
-/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+/**
+ * This function gives the place of a fixed plug, relative to the top-left corner of the node box, or `undefined` for a free plug.
+ * A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
+ */
+export declare function portOffset(box: Box, port: Port): Point | undefined;
+/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+export declare function checkPort(node: Node, port: Port): void;
+/**
+ * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
+ * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
+ * It throws a `RangeError` for a bad `along` (`checkPort`).
+ */
+export declare function resolvePorts(graph: Graph): Graph;
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
 export declare function fixedPortPoint(node: Node, end: End): Point | undefined;
+/**
+ * An inner edge: an edge from a plug of a frame to a node in that frame, at any depth.
+ * `plug` tells which end of the edge is the plug of the frame.
+ */
+export interface InnerEdge {
+  readonly edge: Edge;
+  readonly frame: string;
+  readonly plug: "source" | "target";
+}
+/** This function throws a `RangeError` when the parent of a node names no node, or when the parents of a node make a cycle. */
+export declare function checkParents(graph: Graph, byId?: ReadonlyMap<string, Node>): void;
+/**
+ * This function checks the parents of a graph (`checkParents`), and takes its inner edges out.
+ * An inner edge of the frame F has a plug of F (`End.port`) at one end. F holds the node at the other end.
+ * The graph that it gives keeps each node and the other edges. A graph without `parent` comes back as the same object, with no inner edge.
+ */
+export declare function splitFrames(graph: Graph): {
+  readonly graph: Graph;
+  readonly inner: readonly InnerEdge[];
+};
+/**
+ * This function gives the graph of a router without frames. It has the plugs of `resolvePorts`, and no inner edges (`splitFrames`).
+ * Each router except `corners` uses it at the start of `route`. So an inner edge gets no route from such a router.
+ */
+export declare function outerGraph(graph: Graph): Graph;
 /** This function gives a seeded random source with values in [0, 1) (mulberry32). */
 export declare function rng(seed: number): () => number;
 /**
@@ -1560,10 +1613,29 @@ export declare function getStrategy<S extends Step>(registry: Registry, step: S,
 export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
 /** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
 export declare function routersOf(registry: Registry): Router[];
+/**
+ * The rule for a node box that is not fully inside the box of its frame.
+ * With `throw`, the router throws a `RangeError`. With `skip`, the node is not an obstacle, and its inner edges get no route.
+ * With `clamp`, the router cuts the box to the bounds of the frame.
+ */
+type Outside = "throw" | "skip" | "clamp";
+/** The options of the inner routes: the options of the way finder, the rule `outside` and the inset `frameInset`. */
+interface FrameOptions extends WayOptions {
+  /** The rule for a node box outside the box of its frame. The default is `throw`. */
+  readonly outside?: Outside;
+  /** The distance from the walls of a frame to the bounds of its inner routes. The default is the margin of the router. */
+  readonly frameInset?: number;
+}
+/**
+ * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
+ * the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
+ * It leaves the plug of the frame into the frame, along the normal of the wall. Each route has the id of its frame in `frame`.
+ */
+export declare function frameRoutes(graph: Graph, inner: readonly InnerEdge[], options: FrameOptions): Route[];
 /** The ways to place a free plug of the corner router. */
 type PlugPlace = "facing" | "side";
 /** The options of the corner router. */
-interface CornersOptions extends WayOptions {
+interface CornersOptions extends FrameOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /** The benchmark skips a fixture with more nodes. */
@@ -1590,6 +1662,7 @@ interface CornersOptions extends WayOptions {
  * This function makes a router that goes around the nodes.
  * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
  * of the box corners, without the needless corners. It enters the target plug along its normal.
+ * An inner edge (`splitFrames`) gets an inner route in the bounds of its frame (`frameRoutes`), after the outer routes.
  */
 export declare function cornersRouter(options: CornersOptions): Router;
 /**
@@ -1771,13 +1844,58 @@ interface SharedOptions extends WayOptions {
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
+/**
+ * The negotiation of the router `attraction` (HWY-044, PathFinder turned around). Each pass routes each edge again from no ways.
+ * A link costs `len (1 - attraction h) (1 + weight max(0, use - cap))` more than in `shared`, with `h` the history of the link.
+ */
+interface SharedNegotiation {
+  /** The number of passes, 1 or more. */
+  readonly passes: number;
+  /** The pull of the history of a link, from 0 to 1. */
+  readonly attraction: number;
+  /** The cost weight of each edge over the capacity of a link, 0 or more. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width, and 1 or more. */
+  readonly laneWidth: number;
+}
 /**
  * This function makes a router where edges share their ways (after Pupyrev, Nachmanson, Bereg and Holroyd, "Edge routing with ordered bundles").
  * The edges go one by one through the corner graph. A link that an edge with the same key uses already costs less.
  * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
  * The result gives each stretch as a run, with the order of its lanes.
  */
-export declare function sharedRouter(options: SharedOptions): Router;
+export declare function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation): Router;
+/** The options of the router `attraction` (HWY-044 of the note on highways: negotiated attraction, PathFinder turned around). */
+interface AttractionOptions {
+  /** The number of passes, from 1 to 10. Each pass after the first routes each edge again from no ways. The default is 3. */
+  readonly passes: number;
+  /** The pull `a` of the history of a link, from 0 to 1. A link then costs `1 - a h` times more. The default is 0.5. */
+  readonly attraction: number;
+  /** The cost weight `b` of each edge over the capacity of a link, from 0 to 10. The default is 1. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width. The default is 4. */
+  readonly laneWidth: number;
+}
+/** The default options of the router `attraction`. */
+export declare const ATTRACTION_DEFAULTS: Readonly<AttractionOptions>;
+/** The declarations of the options of the router `attraction` (HWY-044). */
+export declare const ATTRACTION_SCHEMA: OptionSchema<AttractionOptions>;
+/**
+ * This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+ * After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+ * In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+ * The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+ */
+export declare function attractionRouter(options: Partial<AttractionOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `attraction` (HWY-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export declare const attractionStrategy: Strategy<"router", AttractionOptions>;
 /** Two items of a level that a link joins, and the count of the edges between them. */
 interface ItemPair {
   readonly source: string;
@@ -2865,6 +2983,22 @@ export declare function g2Defect(segments: readonly CurveSegment[], u: number):
  * The value has no unit, and lower is better. A full circle gives `4π^2`. The cost is linear.
  */
 export declare function bendingEnergy(points: readonly Point[], tolerance?: number): number;
+/**
+ * This function gives the curvature variation of a sampled curve (C4 of MEAS0, Moreton 1993): `V = L^3 · ∫ (dκ/ds)^2 ds`.
+ * Each inner sample gets the curvature `κ = φ / l` of `bendingEnergy`, with its sign. `L` is the length of the curve.
+ * The sum is `L^3 · Σ (κ_(i+1) - κ_i)^2 / d_i`, with `d_i` the distance of two inner samples in sequence.
+ *
+ * The value has no unit, and lower is better. A straight line and an arc of a circle give 0. Fewer than 4 points give 0. The cost is linear.
+ */
+export declare function curvatureVariation(points: readonly Point[], tolerance?: number): number;
+/**
+ * This function gives the deviation of a curve from its route (C8 of MEAS0).
+ * The value is the Fréchet distance of the samples of the curve and the polyline of the route.
+ * Each list gets points with no leg longer than `step`, or longer when a list has more than 400 points. Then the discrete Fréchet distance is near the true distance.
+ *
+ * The value is in units of the board, and lower is better. The caller divides it by the unit of the board. The cost is quadratic for each route.
+ */
+export declare function curveDeviation(samples: readonly Point[], polyline: readonly Point[], step: number): number;
 /** This function tells if a polyline crosses itself. Two legs next to each other do not count. The cost is `n log n`. */
 export declare function crossesItself(p: readonly Point[]): boolean;
 /** This function tells if a polyline turns back on itself at a vertex: a turn of more than 179 degrees, as at a cusp. */
@@ -2927,6 +3061,18 @@ export declare function orderStability(graph: Graph, levels: readonly Level[]):
  * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
  */
 export declare function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined;
+/** The level ratio of a result (Z5 of MEAS0): the largest step and the spread of the steps from level to level. */
+export interface LevelRatio {
+  /** The largest `lr_d = items_(d+1) / items_d`. */
+  readonly max: number;
+  /** The standard deviation of `log(lr_d)` over the steps. A value of 0 is steps of equal ratio. */
+  readonly spread: number;
+}
+/**
+ * This function gives the level ratio of the levels (Z5 of MEAS0, Mondal 2018): `lr_d = items_(d+1) / items_d`, in the order of depth.
+ * A level without items does not count. Fewer than 2 levels give `undefined`. Lower is better for both values. The cost is linear.
+ */
+export declare function levelRatio(levels: readonly Level[]): LevelRatio | undefined;
 /** A grouping of the nodes: a map from the id of each node to the id of its group. */
 export type Grouping = ReadonlyMap<string, string>;
 /** This function gives the grouping of one level: each node goes to the id of its item. */
@@ -2962,6 +3108,26 @@ export declare function leafGroups(root: Section, count: number): string[];
  * The second tree comes from the graph after a small change (`changeGraph`). The scale is -1 to 1, and higher is better.
  */
 export declare function groupStability(before: Section, after: Section, count: number): number;
+/**
+ * This function gives the fill of the groups of one level (G4 of MEAS0): the mean of `fill(c) = Σ_(v in c) area(box(v)) / area(box(c))`.
+ * `box(c)` is the box of the item. Only an item with 2 or more nodes counts, and a fill above 1 counts as 1.
+ * The scale is 0 to 1, and higher is better. A level without such an item gives `undefined`. The cost is linear.
+ */
+export declare function groupFill(graph: Graph, level: Level): number | undefined;
+/**
+ * This function counts the overlaps of the items of the levels (G5 of MEAS0).
+ * An overlap is a pair of items of one level whose boxes overlap by more than `TOLERANCE`.
+ * It is the sum over the levels of `countOverlaps`. Lower is better. The cost is `n log n` for each level.
+ */
+export declare function itemOverlaps(levels: readonly Level[]): number;
+/**
+ * This function gives the silhouette of the groups of one level (G7 of MEAS0, Rousseeuw 1987): the mean of `s(v) = (b_v - a_v) / max(a_v, b_v)`.
+ * `a_v` is the mean distance from the center of `v` to the centers of the other nodes of its item. `b_v` is the smallest mean distance to the nodes of another item.
+ * A node alone in its item gets `s(v) = 0`. The scale is -1 to 1, and higher is better.
+ * A level with fewer than 2 items gives `undefined`. The cost is quadratic up to 2000 nodes.
+ * Above 2000 nodes, a seeded sample of 2000 nodes gets `s(v)`, against a second seeded sample of 2000 nodes. Thus the value is an estimate.
+ */
+export declare function silhouette(graph: Graph, level: Level): number | undefined;
 /** A small change of a graph, for the stability measures Z10 and G9 of MEAS0. */
 export interface GraphChange {
   /** The graph after the change. It keeps the order of the nodes. */
@@ -3005,6 +3171,21 @@ export declare function routeStability(graph: Graph, before: Result, after: Resu
  * Two values nearer than `snap` are equal. Lower is better, and 0 is correct. Above 2000 boxes, a seeded sample of pairs gives an estimate.
  */
 export declare function roomOrderFaults(before: readonly Boxed[], after: readonly Boxed[], snap?: number): number;
+/**
+ * This function gives the displacement of the boxes (M3 of MEAS0, Bridgeman 2000): `mean_v dist(box_open(v), box_packed(v)) / u`.
+ * The distance is between the centers of the two boxes of a node, and `u` is the unit of the packed board.
+ * The value has no unit, and lower is better. A board where no box moves gives 0. The cost is linear.
+ */
+export declare function boxDisplacement(before: readonly Boxed[], after: readonly Boxed[], unit: number): number;
+/** The number of nearest boxes of each box that make the neighbour pairs of `distanceDistortion`. */
+export declare const DISTORTION_NEIGHBOURS = 4;
+/**
+ * This function gives the distance distortion of the boxes (M5 of MEAS0): the Kruskal stress of the centers.
+ * `σ = sqrt(Σ (α d'_ij - d_ij)^2 / Σ d_ij^2)`, with `d` the distance on the packed board, `d'` the distance on the open board, and `α = Σ d d' / Σ d'^2` the best scale.
+ * The pairs are each box and its 4 nearest boxes on the packed board. The scale is 0 to 1, and lower is better.
+ * A board that only changes its scale gives 0. The cost is `n log n` for an even density.
+ */
+export declare function distanceDistortion(before: readonly Boxed[], after: readonly Boxed[]): number;
 /** One axis of a Pareto front: the key of a measure and the direction that is better. */
 export interface Objective {
   readonly key: string;
@@ -3181,6 +3362,17 @@ export declare function lanesThrough(graph: Graph, open: OpenLanes): number;
  * A board without area gives 1. The cost is linear.
  */
 export declare function laneArea(graph: Graph, open: OpenLanes): number;
+/**
+ * This function gives the symmetry of the drawing (H3 of MEAS0). The value is the share of the routes that the best map of the board sends onto a route.
+ * The maps are the two mirrors on the axes and the half turn. Each one goes through the center of the boxes.
+ *
+ * A route of the edge `(s, t)` maps when two things are true. The map sends the centers of `s` and `t` to the centers of the nodes `s'` and `t'`, within `u / 4`.
+ * A route of an edge between `s'` and `t'` has the same corners as the mapped route, within `u / 4`. `u` is the unit of the board.
+ *
+ * The scale is 0 to 1, and higher is better. A router keeps the symmetry that the boxes have, or loses it. Routes without points give `undefined`.
+ * The cost is linear in the points of the routes.
+ */
+export declare function routeSymmetry(graph: Graph, routes: readonly Route[]): number | undefined;
 /** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
 export declare const PROPOSED_RULES: readonly string[];
 /** The options of `runSuite`. */
@@ -3375,7 +3567,7 @@ export interface CurveRun {
   /** The edge of each curve of `drawn`. */
   readonly edges: readonly string[];
 }
-/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C6 and the curve rules). */
+/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C4, C6, C8 and the curve rules). */
 export declare function curveRuns(graph: Graph, result: Result, curves: readonly Strategy<"curve">[], options: CurveRunOptions): CurveRun[];
 /** One grouping rule on one graph: the row of the suite, the tree of the rule and the result of `sections` on that tree. */
 export interface GroupRun {
@@ -3844,6 +4036,8 @@ interface SnapLine {
 interface SnapOptions extends Pick<WayOptions, "margin" | "k"> {
   /** A highway has this number of edges or more. The value is 2 or more. */
   readonly minSize: number;
+  /** With `true`, a line in clear view is its own spine, with no path through the corner graph. The default is `false`. */
+  readonly direct?: boolean;
 }
 /** This function gives the line `u d + rho n` of the direction angle `theta`, with `d = (cos, sin)` and the normal `n = (-sin, cos)`. */
 export declare function linePoint(theta: number, rho: number, u: number): Point;
@@ -4880,6 +5074,212 @@ export declare function scaleSpaceGroups(input: HighwayInput, o: Readonly<ScaleS
  * 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 source of the candidate streets: the middle lines of the gaps of the room step, or the lines through the corners. */
+type StreetSource = "room" | "corners";
+/** The values of `StreetSource`. */
+export declare const STREET_SOURCES: readonly StreetSource[];
+/** One axis-parallel street in the free space, from `a` to `b`. */
+interface FreeLine {
+  readonly a: Point;
+  readonly b: Point;
+}
+/** One edge for the streets: its two points out of its plugs, and the length of its first route. */
+interface StreetEdge {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+  readonly base: number;
+}
+/** The ride of one edge on one street. It has the points where the edge joins and leaves the street, and two lengths. */
+interface StreetRide {
+  readonly on: Point;
+  readonly off: Point;
+  /** The length on the street. */
+  readonly ride: number;
+  /** The length of the two ramps, to the street and from it. */
+  readonly ramps: number;
+}
+/**
+ * This function gives the candidate streets of a board. Each street is an axis-parallel piece of free space.
+ * The source `room` takes the middle line of each gap of `boardGaps` that is two margins wide or more.
+ * The source `corners` takes the lines one margin out from each side of each box.
+ * A street is two margins long or more. The list has no copies, and its order is the same each time.
+ */
+export declare function freeLines(graph: Graph, finder: WayFinder, source: StreetSource): FreeLine[];
+/** This function gives the edges of the input for the streets, with the points out of their plugs and the lengths of their first routes. */
+export declare function streetEdges(input: HighwayInput, finder: WayFinder): StreetEdge[];
+/** This function gives the point of the street nearest to `p`. */
+export declare function streetPoint(line: FreeLine, p: Point): Point;
+/** This function gives the ride of an edge on a street. The edge joins the street at the point nearest to `s`, and leaves it at the point nearest to `t`. */
+export declare function streetRide(line: FreeLine, e: StreetEdge): StreetRide;
+/** The options of the highway strategy `gaps` (HWY-057 of the note on highways). */
+interface GapOptions {
+  /** A street with fewer edges than this number (the demand `k`) is not a highway. The default is 3. */
+  readonly minSize: number;
+  /** The cost of a length on a street against a length off the streets, from 0.1 to 0.8. The default is 0.5. */
+  readonly discount: number;
+  /** An edge rides a street only when its way along the street is this many times its first route or less. The default is 1.3. */
+  readonly detour: number;
+  /** The source of the streets: the gaps of the room step, or the lines through the corners. The default is `room`. */
+  readonly source: StreetSource;
+}
+/** The default options of the strategy `gaps`. */
+export declare const GAP_DEFAULTS: Readonly<GapOptions>;
+/**
+ * This function gives the highways on the gaps of the board (HWY-057). The streets are the free middle lines of the gaps.
+ * Each edge takes the street that saves it the most cost, when a length on a street costs `discount` times its length.
+ * A street with `minSize` edges or more becomes a highway. The edges of the other streets then choose again among the highways, two times.
+ */
+export declare function gapPlan(input: HighwayInput, o: Readonly<GapOptions>): HighwayPlan;
+/** The plan that gives the highways of the network: the plan of `corridors` or of `shared-ways`, with their defaults. */
+type InterchangeBase = "corridors" | "shared-ways";
+/** The values of `InterchangeBase`. */
+export declare const INTERCHANGE_BASES: readonly InterchangeBase[];
+/** The options of the highway strategy `interchanges` (HWY-060 of the note on highways). */
+interface InterchangeOptions {
+  /** The plan that gives the highways. The default is `corridors`. */
+  readonly from: InterchangeBase;
+  /** The cost of a change between two highways, in units of the board, from 0 to 8. The default is 2. */
+  readonly changeCost: number;
+  /** The largest number of interchanges, from 1 to 32. The default is 16. */
+  readonly interchanges: number;
+  /** The largest number of highways on the way of one edge, from 1 to 3. The default is 2. */
+  readonly perEdge: number;
+  /** Two highways get an interchange where they come this near, in units of the board. The default is 2. */
+  readonly radius: number;
+  /** The cost of a length on a highway against a length off the highways, from 0.1 to 1. The default is 0.5. */
+  readonly discount: number;
+  /** An edge rides the network only when its way is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+}
+/** The default options of the strategy `interchanges`. */
+export declare const INTERCHANGE_DEFAULTS: Readonly<InterchangeOptions>;
+/** One interchange: a place on the highway `h`, a place on the highway `g`, and the length of the link between the two places. */
+interface Interchange {
+  readonly h: number;
+  readonly hAt: number;
+  readonly g: number;
+  readonly gAt: number;
+  readonly gap: number;
+}
+/** This function gives the candidate interchanges: the nearest places of each pair of spines that come within `radius`, with a link in clear view. */
+export declare function interchangeCandidates(spines: readonly (readonly Point[])[], radius: number, clear: (a: Point, b: Point) => boolean): Interchange[];
+/**
+ * This function gives the highways of a network with interchanges (HWY-060). The highways come from a plan. Two highways that come near get an interchange.
+ * Each edge takes its cheapest way: a ride on one highway, or on up to `perEdge` highways with a change at an interchange.
+ * A change costs `changeCost` units. The interchanges that the most edges use stay, up to `interchanges`.
+ */
+export declare function interchangePlan(input: HighwayInput, o: Readonly<InterchangeOptions>): HighwayPlan;
+/** The options of the highway strategy `search` (HWY-059 of the note on highways). */
+interface SearchOptions {
+  /** The plan where the search starts. The default is `corridors`. */
+  readonly from: CandidateSource;
+  /** The generators of the highways that the move `add` takes. The default is `quickbundles` and `road-classes`. */
+  readonly pool: readonly CandidateSource[];
+  /** The number of plans that the search measures, from 0 to 400. The value 0 gives the start plan. The default is 16. */
+  readonly evaluations: number;
+  /** The first temperature of the annealing, on the scale of the score. Each sweep of 4 moves multiplies it by 0.95. The default is 0.02. */
+  readonly temperature: number;
+  /** The weight of the ink that the routes save (B1). The default is 1. */
+  readonly inkWeight: number;
+  /** The weight of the 0.95 quantile of the stretch against the first routes (B3). The default is 0.5. */
+  readonly stretchWeight: number;
+  /** The weight of the ambiguity (B4). The default is 0.5. */
+  readonly ambiguityWeight: number;
+  /** The weight of the largest merge angle (B6), divided by 180 degrees. The default is 0.25. */
+  readonly angleWeight: number;
+  /** The seed of the moves. The default is 1. */
+  readonly seed: number;
+}
+/** The default options of the strategy `search`. */
+export declare const SEARCH_DEFAULTS: Readonly<SearchOptions>;
+/** The moves of the search. */
+type SearchMove = "add" | "drop" | "edge" | "point";
+/** The values of `SearchMove`, in the order of the draw. */
+export declare const SEARCH_MOVES: readonly SearchMove[];
+/**
+ * This function gives the score of the routes of a plan: `w1 B1 - w3 B3 - w4 B4 - w6 B6 / 180`. Higher is better.
+ * B3 is the 0.95 quantile of the stretch against the first routes. The score reads only the graph and the routes of the plan.
+ */
+export declare function searchScore(graph: Graph, routes: readonly Route[], first: readonly Route[], o: Readonly<SearchOptions>): number;
+/**
+ * This function gives the highways of a local search over the set of highways (HWY-059). The search starts at the plan of `from`.
+ * Each move adds a highway of the pool, drops a highway, moves one edge to another highway, or moves one point of a spine.
+ * The annealing keeps a worse plan with the chance `acceptance(-delta / T)`. The best plan that the search measures is the result.
+ *
+ * The score reads only this graph and its routes. Thus the search does not fit to the inputs of a screen.
+ */
+export declare function searchPlan(input: HighwayInput, o: Readonly<SearchOptions>): HighwayPlan;
+/** The groups of the trees: the edges from one source node, or the edges of one collection. */
+type SteinerGroup = "source" | "key";
+/** The values of `SteinerGroup`. */
+export declare const STEINER_GROUPS: readonly SteinerGroup[];
+/** The method of the tree: the iterated 1-Steiner method on the Hanan grid, or the spanning tree of the terminals alone. */
+type SteinerMethod = "one-steiner" | "spanning";
+/** The values of `SteinerMethod`. */
+export declare const STEINER_METHODS: readonly SteinerMethod[];
+/** The metric of the tree: rectilinear (two directions) or octilinear (four directions). */
+type SteinerMetric = "rectilinear" | "octilinear";
+/** The values of `SteinerMetric`. */
+export declare const STEINER_METRICS: readonly SteinerMetric[];
+/** The options of the highway strategy `steiner` (HWY-036 of the note on highways, with EDA-015). */
+interface SteinerOptions {
+  /** The groups of the trees. The default is `source`. */
+  readonly group: SteinerGroup;
+  /** The method of the tree. The default is `one-steiner`. */
+  readonly method: SteinerMethod;
+  /** A group with more terminals than this number gets the spanning tree alone. The default is 12. */
+  readonly maxGroup: number;
+  /** The metric of the tree. The default is `rectilinear`. */
+  readonly metric: SteinerMetric;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+/** The default options of the strategy `steiner`. */
+export declare const STEINER_DEFAULTS: Readonly<SteinerOptions>;
+/** This function gives the links of the spanning tree of the points (Prim), as pairs of indices, and the sum of their lengths. */
+export declare function spanningTree(points: readonly Point[], metric: SteinerMetric): {
+  links: [number, number][];
+  cost: number;
+};
+/**
+ * This function gives a Steiner tree of the terminals by the iterated 1-Steiner method (Kahng and Robins). The candidates are the points of the Hanan grid.
+ * Each round adds the candidate that makes the spanning tree shortest, and drops each added point with two links or fewer.
+ * The test `free` removes the candidates in the boxes. The result has the terminals first, then the added points.
+ */
+export declare function oneSteiner(terminals: readonly Point[], metric: SteinerMetric, free: (p: Point) => boolean): {
+  points: Point[];
+  links: [number, number][];
+};
+/**
+ * This function gives the highways of obstacle-avoiding Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree over the points out of its plugs.
+ * The links of the tree are rectilinear or octilinear, and they go around the boxes. Each edge takes its path in the tree, when that path is short enough.
+ * The stretches of the tree that two edges or more share become highways.
+ */
+export declare function steinerPlan(input: HighwayInput, o: Readonly<SteinerOptions>): HighwayPlan;
+/** The options of the highway strategy `streets` (HWY-058 of the note on highways). */
+interface StreetOptions {
+  /** A street covers an edge when the way of the edge along the street is this many times its first route or less (the limit `s`). The default is 1.2. */
+  readonly detour: number;
+  /** The greedy cover stops when the best street gives less than this gain: the length that its edges ride over the length of the street. The default is 2. */
+  readonly minGain: number;
+  /** The largest number of streets. The default is 32. */
+  readonly maxStreets: number;
+  /** A street with fewer new edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The source of the streets: the gaps of the room step, or the lines through the corners. The default is `corners`. */
+  readonly source: StreetSource;
+}
+/** The default options of the strategy `streets`. */
+export declare const STREET_DEFAULTS: Readonly<StreetOptions>;
+/**
+ * This function gives orthogonal streets by a greedy set cover (HWY-058). A street covers each edge whose way along it is at most `detour` times its first route.
+ * Each step takes the street with the largest gain: the length that its new edges ride, over the length of the street that they use.
+ * The cover stops at `maxStreets` streets, or when the best gain is below `minGain`. Each edge rides one street at most.
+ */
+export declare function streetPlan(input: HighwayInput, o: Readonly<StreetOptions>): 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). */
@@ -5648,6 +6048,11 @@ export declare const highwayStrategies: {
   readonly consensus: Strategy<"highway", ConsensusOptions>;
   readonly "p-hub": Strategy<"highway", PHubOptions>;
   readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
+  readonly steiner: Strategy<"highway", SteinerOptions>;
+  readonly gaps: Strategy<"highway", GapOptions>;
+  readonly streets: Strategy<"highway", StreetOptions>;
+  readonly search: Strategy<"highway", SearchOptions>;
+  readonly interchanges: Strategy<"highway", InterchangeOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -5773,6 +6178,8 @@ export declare function highwayRouters(registry: Registry): Strategy<"router">[]
  * - A whole strategy gives the routes of its output. A room strategy in its options can change the board, but the measures read the input graph.
  */
 export declare function stepRouterStrategy(strategy: Strategy<RoutedStep>): Strategy<"router">;
+/** This function gives the board of the output of a whole strategy that `stepRouterStrategy` ran, or `undefined` for another result. A room strategy can move the boxes of this board. */
+export declare function wholeBoard(result: Result): Graph | undefined;
 /** This function gives a router for each strategy of one step of `RoutedStep` in a registry, in the order of the registry (`stepRouterStrategy`). */
 export declare function stepRouters(registry: Registry, step: RoutedStep): Strategy<"router">[];
 /** One strategy of any step on one graph: a row of `compareStep`, or a row of the steps `highway` and `room`. */
@@ -5837,6 +6244,8 @@ export interface LayoutPort {
   /** The fixed place of the port, from the top-left corner of the box. The router does not move a port with `x` and `y`. */
   readonly x?: number;
   readonly y?: number;
+  /** The fixed place of the port on its `side`: a fraction from 0 to 1. The start is the top end or the left end of the side. */
+  readonly along?: number;
 }
 /** A point of a region: `[x, y]`. The y axis points down. */
 export type RegionPoint = readonly [number, number];
@@ -6049,7 +6458,7 @@ export interface LayoutPrediction {
 }
 /**
  * This function writes a graph as an input file of the form `layout-input/1`, with its hash.
- * A fixed plug gets `x`, `y` and the side that holds it. `inputGraph` reads the file back.
+ * A fixed plug gets `x`, `y` and the side that holds it. A plug with `along` keeps its `side` and `along`. `inputGraph` reads the file back.
  */
 export declare function graphInput(graph: Graph, head: LayoutInputHead): LayoutInput;
 /**
@@ -6069,7 +6478,7 @@ export type RouteInput = Pick<LayoutInput, "id" | "boxes" | "obstacles"> & {
   readonly edges?: LayoutInput["edges"];
 };
 /**
- * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
+ * This function reads the graph of the router from an input file. The router reads the positions, the ports, the parents, the edges and the data.
  * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
  * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
  * A box without `x` and `y` is an error.
@@ -6127,6 +6536,8 @@ export interface MeasureInfo {
    * A measure without this field has the threshold `RECORD_EPS`.
    */
   readonly minEffect?: MinEffect;
+  /** The definition of the measure in one or two sentences: what it counts, and when its value is good. The site shows it. */
+  readonly definition?: string;
 }
 /** One rule of `MIN_EFFECTS`: the units, the minimum effect of a measure with one of these units, and the reason. */
 export interface MinEffectRule {
@@ -6827,7 +7238,7 @@ interface FollowOptions extends WayOptions {
  * The result has a shared run for each stretch of a spine where the same two edges or more go. Each run holds the points of its routes in a row.
  * The same graph, plan and options give the same result.
  */
-export declare function follow(graph: Graph, plan: HighwayPlan, options?: FollowOptions): Result;
+export declare function follow(input: Graph, plan: HighwayPlan, options?: FollowOptions): Result;
 /**
  * This function gives the highways of a result of a router: one highway for each shared run and for each trunk of a bundle.
  * The spine is the points of the run or of the trunk. Each edge of the run is a member, from one end of the spine to the other end, in the way of its route.
@@ -7181,5 +7592,5 @@ export declare const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${Portfol
  * The default stretch order is `sifting`, the best order of the screen. The option `stretchOrder` selects `consensus` or `periphery`.
  */
 export declare const sharedStretchStrategy: Strategy<"router", RouterPreset<SharedOptions>>;
-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 CorpusDimension, type CorpusFamily, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, DEFAULT_RNG, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DimensionValues, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FamilyRegistry, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrechetBundle, type FrechetOptions, type Gate, type GenerateContext, 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 ParamValue, 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, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex };
+export { type AdvectionSettings, type AmbiguityGuardOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type Biclique, type BreakEvenOptions, type BundleLine, type BundleOrder, type CandidateSource, type CellStep, type ClothoidOptions, type ConfluentOptions, type ConsensusLinkage, type ConsensusOptions, type CornersOptions, type CorpusDimension, type CorpusFamily, type CorridorOptions, type Crossbar, type CrossbarOptions, type CubuOptions, type CurveSpace, type CutObjective, type CutOptions, DEFAULT_RNG, type DensityGrid, type DensityImage, type DensityKernel, type DensitySource, type DiffusionOptions, type DimensionValues, type DividedOptions, type EdgeDistance, type EdgeEnds, type EdgeGroup, type EdgeLengths, type EdgePathOptions, type EdgePlugs, type ExerciseEvidence, type FamilyRegistry, type FdebOptions, type FieldEnd, type FlowClusterOptions, type FlowFieldOptions, type FollowOptions, type FrameOptions, type FrechetBundle, type FrechetOptions, type FreeLine, type GapOptions, type Gate, type GenerateContext, 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 Interchange, type InterchangeBase, type InterchangeOptions, 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 Outside, type PHubOptions, type ParamValue, 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 SearchMove, type SearchOptions, type SectionsOptions, type SelectCandidate, type SelectLevel, type SelectOptions, type Selection, type ShapeSkeleton, type ShareCost, type ShareMerge, type ShareOrder, type SharedNegotiation, 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 SteinerGroup, type SteinerMethod, type SteinerMetric, type SteinerOptions, type StreetEdge, type StreetOptions, type StreetRide, type StreetSource, 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, createFamilyRegistry, dimensionAt, dimensionUnit, exercised, familyKind, levelsOf, minEffectOf, outputGroups, outputHash, paramProblem, pickMoves, portfolio, randomInt, selectBest, sha256Hex };
 //# sourceMappingURL=index.d.ts.map