@mark1russell7/highways 0.9.0 → 0.9.1

package/README.md

@@ -26,6 +26,29 @@ const result = cornersRouter({ name: "corners" }).route(graph);
 // Each route is a polyline: result.routes[0].points
 ```
 
+### Plugs
+
+A node can have `ports`, and an end of an edge can name one of them in `port`. Each plug has one of these forms:
+
+| Form | The place of the plug |
+|---|---|
+| `{ id }` | The router picks the side and the point. |
+| `{ id, side }` | The router picks the point on that side. |
+| `{ id, at }` | The plug is fixed at `at`, relative to the top-left corner of the box. |
+| `{ id, side, along }` | The plug is fixed at the side start plus `along` times the side length. |
+
+- `along` goes from 0 to 1. The start of `north` and `south` is the left end. The start of `east` and `west` is the top end.
+- When the box gets taller or wider, a plug with `along` keeps its fraction of the side.
+- `resolvePorts(graph)` gives each plug with `along` a fixed `at`. Each router calls it at the start of `route`.
+- The arithmetic is the arithmetic of `portPoint` of `@mark1russell7/layout-contract`. `portOffset` calls it.
+- `resolvePorts` throws a `RangeError` for a bad `along`. A bad value is not finite or is outside 0 to 1. A plug with `along` also needs a `side` and has no `at`.
+- In an input file, such a plug has `side` and `along`, with no `x` and no `y`.
+
+```ts
+const node = { id: "a", box: { x: 0, y: 0, w: 80, h: 40 }, ports: [{ id: "out", side: "east", along: 0.25 }] };
+// The plug "out" is at (80, 10). With h = 120, it is at (80, 30).
+```
+
 ## Curve types
 
 A router gives polylines. The curve layer turns a polyline into a curve of a type. The polyline can come from any router, from a lane of `laneRoutes` or from a link of a zoom level.
@@ -453,6 +476,11 @@ The step `highway` decides which edges share a way. It gives a plan, not routes.
 | `consensus` | The consensus of HWY-035. The finders vote on the pairs of edges, and the pairs that most finders agree on stay. |
 | `p-hub` | The p-hub median of HWY-041. The p-median of the plugs gives the hubs, and the links between two hubs become highways. |
 | `scale-space` | The scale space of HWY-053. Only the clusters that live over a long range of scales get highways. |
+| `steiner` | The Steiner trees of HWY-036. Each group of edges gets one rectilinear tree around the boxes, and the shared parts of the tree become highways. |
+| `gaps` | The gap highways of HWY-057. A free line in a gap between boxes holds a highway when enough edges can ride it. |
+| `streets` | The orthogonal streets of HWY-058. A greedy set cover picks the free horizontal and vertical lines that carry the most edge length. |
+| `search` | The local search of HWY-059. It adds, drops and changes the highways of a start plan, and it keeps the plan with the best score. |
+| `interchanges` | The interchanges of HWY-060. An edge can change from one highway to another at an interchange, where two spines come near. |
 
 The strategy `corridors` joins two ways when they share a long length. The length is `BREAK_EVEN` times the lane width or more, and the share `rho` of the shorter way or more.
 The strategies `meet`, `weiszfeld`, `stubs`, `zipper`, `level-links`, `lanes`, `divided` and `crossbars` change the plan of the option `from`: `shared-ways` (the default), `corridors` or `none`.
@@ -518,6 +546,16 @@ const shared = stableOrderStrategy(routerStrategies.shared);
 const result = repairStrategy(shared).run(graph); // The router `shared+stable+repair`.
 ```
 
+### The router `attraction`
+
+The router `attraction` is opt-in. It is not in `STRATEGIES`, so the default outputs do not change.
+
+- `attractionRouter(options)` gives the negotiated attraction of HWY-044, and `attractionStrategy` is its router strategy.
+- Each pass after the first routes each edge again. A link that many edges used in the passes before gets a lower cost.
+- The options are `passes` (1 to 10), `attraction` (0 to 1), `capacityWeight` (0 to 10) and `laneWidth` (1 to 12).
+- A capacity term raises the cost of a link when its users are more than its width holds.
+- With 1 pass, `attraction: 0` and `capacityWeight: 0`, the routes are the routes of `shared`.
+
 ### The portfolio router
 
 The router `portfolio` is opt-in. It is not in `STRATEGIES`, so the default outputs do not change. [`PORTFOLIO.md`](../../docs/research/PORTFOLIO.md#the-portfolio-router-portfolio-api) gives its tables.

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 {
@@ -190,7 +197,20 @@ 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;
 /** This function gives a seeded random source with values in [0, 1) (mulberry32). */
 export declare function rng(seed: number): () => number;
@@ -1771,13 +1791,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;
@@ -3844,6 +3909,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 +4947,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 +5921,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>;
@@ -5837,6 +6115,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 +6329,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;
 /**
@@ -6827,7 +7107,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 +7461,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 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 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