@mark1russell7/highways 0.9.3 → 0.9.5

package/build/index.d.ts

@@ -1619,12 +1619,21 @@ export declare function routersOf(registry: Registry): Router[];
  * 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`. */
+/**
+ * The mode of the inner routes. With `corners`, the corner graph gives each route, in the box of the frame smaller by `frameInset`.
+ * With `gutter`, each route is orthogonal in the free room of the frame box: the gaps between the nodes and the strips at the walls.
+ */
+type InnerMode = "corners" | "gutter";
+/** The options of the inner routes: the options of the way finder, the rule `outside`, the inset `frameInset`, the mode `inner` and `bendCost`. */
 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. */
+  /** The distance from the walls of a frame to the bounds of its inner routes. The default is the margin of the router. The mode `gutter` does not use it. */
   readonly frameInset?: number;
+  /** The mode of the inner routes. The default is `corners`. */
+  readonly inner?: InnerMode;
+  /** The cost of one bend of an inner route of the mode `gutter`, in units of length. The default is 16. */
+  readonly bendCost?: number;
 }
 /**
  * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
@@ -1665,6 +1674,34 @@ interface CornersOptions extends FrameOptions {
  * 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;
+/**
+ * One inner edge of a frame for the gutter mode. `plug` is the plug of the wall, with the outward normal of the wall.
+ * `end` is the node at the other end. `port` is the fixed plug of that node, if it has one. `side` limits the entry to one side of the node.
+ */
+interface GutterEdge {
+  readonly plug: Plug;
+  readonly end: Node;
+  readonly port?: Plug;
+  readonly side?: Side;
+}
+/** The options of the gutter mode. */
+interface GutterOptions {
+  /** The cost of one bend, in units of length. The default is 16. */
+  readonly bendCost?: number;
+  /** The largest space between two lanes of one gap. A narrow gap gets a smaller, even space. The default is 5. */
+  readonly laneGap?: number;
+}
+/** The default cost of one bend of the gutter mode. */
+export declare const GUTTER_BEND_COST = 16;
+/**
+ * This function gives the orthogonal route of each edge in the free room of a frame: the box `frame` minus the boxes of `nodes`.
+ * Each route starts at the plug of the wall, and goes along the normal of the wall into the frame. It ends on a side of its end node.
+ *
+ * The route goes on a grid of lines. A line goes through the middle of each free band between the box edges, each plug and each entry.
+ * A shortest path with a cost for each bend (`bendCost`) gives the route. Then the routes that share one gap get a lane each.
+ * An edge without a path through the free room gets `undefined`.
+ */
+export declare function gutterRoutes(frame: Box, nodes: readonly Node[], edges: readonly GutterEdge[], options?: GutterOptions): (Point[] | undefined)[];
 /**
  * The lane order of the stretches (LANE-STRETCH).
  *
@@ -1858,13 +1895,282 @@ interface SharedNegotiation {
   /** 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;
 }
+/**
+ * The search of the corner graph of one route of `shared`, for the hooks of `SharedHooks`.
+ * An index below `corners` is a corner of the graph. Each end of a way gets an index from `corners`, one for each place.
+ */
+interface SharedSearch {
+  /** The graph of the route, without the inner edges of a frame. */
+  readonly graph: Graph;
+  /** The number of corners of the corner graph. */
+  readonly corners: number;
+  /** This function gives the key of the link between the indices `i` and `j`, for each order of the two. */
+  link(i: number, j: number): number;
+  /**
+   * This function gives a shortest way of `w` through the corner graph, with its points and their indices, or `undefined`.
+   * The function `cost` can change the cost of the link from corner `i` to corner `j`, of length `d`. It must give at least `floor` × `d`.
+   */
+  find(w: Way, cost?: (i: number, j: number, d: number) => number, floor?: number): {
+    seq: Point[];
+    ids: number[];
+  } | undefined;
+  /** This function gives the free space across the link from corner `i` to corner `j` (`channelWidth`). The router keeps each width that it finds. */
+  width(i: number, j: number): number;
+}
+/**
+ * The hooks of a router that `shared` runs (WILD-023, RULE-021). The router `shared` itself has no hooks.
+ * `order` gives the order of the ways before the first pass. `refine` changes the ways after the passes, before the runs.
+ */
+interface SharedHooks {
+  readonly order?: (ways: readonly Way[], search: SharedSearch) => Way[];
+  readonly refine?: (ways: readonly Way[], search: SharedSearch) => void;
+}
+/** A way of one edge through the corner graph. */
+interface Way {
+  readonly edge: Edge;
+  readonly key: string;
+  readonly ps: Plug;
+  readonly pt: Plug;
+  /** The way through the corner graph, from the point out of the source plug to the point out of the target plug. */
+  seq: Point[];
+  /** The index of each point of `seq` in the corner graph. The two ends get an index after the corners, one for each place. */
+  ids: number[];
+  found: boolean;
+}
 /**
  * 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, negotiation?: SharedNegotiation): Router;
+export declare function sharedRouter(options: SharedOptions, negotiation?: SharedNegotiation, hooks?: SharedHooks): Router;
+/** The options of the router `annealing` (RULE-021: simulated annealing over candidate routes, with its rider WILD-028). */
+interface AnnealingOptions {
+  /** The number of candidate ways of each edge, from 3 to 8. The default is 4. */
+  readonly candidates: number;
+  /** The cost of one crossing, in units of the median box side, from 0 to 20. The default is 4. */
+  readonly crossing: number;
+  /** The start temperature, in units of the median box side, from 0.1 to 10. The default is 1. */
+  readonly temperature: number;
+  /** The factor of the temperature after each sweep of the edges, from 0.9 to 0.99. The default is 0.95. */
+  readonly cooling: number;
+  /** The budget: the number of changes for each edge, from 20 to 200. The default is 50. */
+  readonly budget: number;
+  /** The seed of the random choices, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+}
+/** The default options of the router `annealing`. */
+export declare const ANNEALING_DEFAULTS: Readonly<AnnealingOptions>;
+/** The declarations of the options of the router `annealing` (RULE-021). */
+export declare const ANNEALING_SCHEMA: OptionSchema<AnnealingOptions>;
+/**
+ * This function anneals the choice of one candidate way for each edge (RULE-021, after Davidson and Harel, 1996).
+ * The candidates of an edge are its way in `shared` and its shortest way. Other candidates are the shortest ways when the links of earlier candidates cost 3 times more.
+ * The energy is `(1 - 0.5) ink + 0.5 Σ L + crossing u X`: the cost of `shared` plus a cost for each crossing `X` between the ways of two edges.
+ * A change takes one edge to another candidate. A worse change stays with the rational chance `1 / (1 + y + y^2 / 2)`, with `y = ΔE / T`.
+ * The temperature falls by `cooling` after each sweep. The ways at the end are the ways of the lowest energy of the run.
+ */
+export declare function annealWays(ways: readonly Way[], search: SharedSearch, o: Readonly<AnnealingOptions>): void;
+/**
+ * This function makes the router `annealing` (RULE-021 with its rider WILD-028). It is the router `shared`, then the annealing of `annealWays`.
+ * Each candidate is a way through the corner graph, as in `shared`, so each one keeps the hard rules.
+ */
+export declare function annealingRouter(options: Partial<AnnealingOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `annealing` (RULE-021), 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 annealingStrategy: Strategy<"router", AnnealingOptions>;
+/** The options of the router `canals` (NAT-004: canalization feeder trees to hubs). */
+interface CanalOptions {
+  /** The exponent `mu` of the flux in the growth of a conductance, from 1 to 3 in steps of 0.5. A value above 1 gives a tree. The default is 2. */
+  readonly mu: number;
+  /** The largest number of updates of the conductances, from 30 to 150. The updates stop when the ways do not change for 3 updates. The default is 60. */
+  readonly steps: number;
+  /** The decay `r` of a conductance, from 0.5 to 2. The default is 1. */
+  readonly decay: number;
+  /** A hub has this number of edges of one key or more, from 2 to 8. The default is 3. */
+  readonly minMembers: number;
+}
+/** The default options of the router `canals`. */
+export declare const CANAL_DEFAULTS: Readonly<CanalOptions>;
+/** The declarations of the options of the router `canals` (NAT-004). */
+export declare const CANAL_SCHEMA: OptionSchema<CanalOptions>;
+/**
+ * This function gives `x^mu` for `x` from 0 to 1 and `mu` in steps of 0.5, with only `*` and `Math.sqrt`.
+ * These operations are exact to the last bit on each platform, so a decision does not depend on the engine.
+ */
+export declare function halfPower(x: number, mu: number): number;
+/** A hub: a node, the key of its edges, and the ways of those edges. */
+interface CanalHub {
+  readonly node: string;
+  readonly key: string;
+  readonly ways: readonly Way[];
+}
+/**
+ * This function gives the hubs of the ways. In each key, the node with the most ends is a hub when it has `minMembers` edges or more.
+ * Its edges leave the key, and the next hub of the key comes from the edges that stay. A tie goes to the smaller node id.
+ * An edge with no key is in no hub.
+ */
+export declare function canalHubs(ways: readonly Way[], minMembers: number): CanalHub[];
+/**
+ * This function grows a feeder tree to each hub (NAT-004, after the canalization of Sachs 1981 and Mitchison 1980).
+ * Each member edge is a source of one unit of flux, and the hub is the sink. The flux of a link is the share of the members whose ways use it.
+ * At each update, each conductance changes by `DT × (flux^mu - decay × D)`, and each member finds its way again with the cost `d / (1 + GAIN × D)`.
+ * A link that another way of the key uses costs half, as in `shared`.
+ * With `mu` above 1, a link with more flux grows faster, so the ways gather into one tree. The updates stop after `steps`, or when no way changes for 3 updates.
+ */
+export declare function canalWays(ways: readonly Way[], search: SharedSearch, options?: Partial<CanalOptions>): void;
+/**
+ * This function makes the router `canals` (NAT-004). It is the router `shared`, then the feeder trees of `canalWays` to the hubs of each key.
+ * The runs and the bundles come from the ways after the trees.
+ */
+export declare function canalRouter(options: Partial<CanalOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `canals` (NAT-004), 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 canalStrategy: Strategy<"router", CanalOptions>;
+/** The options of the router `adam` (RULE-020: Adam with a seeded sample of pairs). */
+interface AdamOptions {
+  /** The first step size `eta0`, in units of `clearance`, from 0.01 to 1. The step size falls to a tenth of it at the last step. The default is 0.1. */
+  readonly eta: number;
+  /** The number of other legs that each leg samples at each step, from 4 to 32. The default is 8. */
+  readonly samples: number;
+  /** The number of steps: the budget of the search, from 100 to 2000. The default is 200. */
+  readonly steps: number;
+  /** The seed of the samples, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+  /** A leg nearer than this distance to another leg or to a box gets a push, from 4 to 32. The default is 8. */
+  readonly clearance: number;
+}
+/** The default options of the router `adam`. */
+export declare const ADAM_DEFAULTS: Readonly<AdamOptions>;
+/** The declarations of the options of the router `adam` (RULE-020). */
+export declare const ADAM_SCHEMA: OptionSchema<AdamOptions>;
+/**
+ * This function moves the free legs of the routes of `result` with Adam (RULE-020, after Kingma and Ba 2015, and the SGD layouts of Zheng, Pawar and Goodman 2019).
+ * A leg is free when its two points are inside its route, and no other route, run or trunk holds them. The variable of a leg is a shift along its normal.
+ * The energy of a leg is `Σ (1 - d / c)²` over a seeded sample of `samples` other legs nearer than `c`. The near boxes add the same term times 4.
+ * A term `0.05 × (t / c)²` holds each leg near its first place. The step size falls from `eta` to a tenth of it, with only `+`, `*` and `/`.
+ * A moved route goes back to its first points when it has more crossings than before, or a break of a hard rule.
+ * When the output still has more crossings than the routes of `shared`, it is the routes of `shared`.
+ */
+export declare function adamRoutes(input: Graph, result: Result, options?: Partial<AdamOptions>): Result;
+/**
+ * This function makes the router `adam` (RULE-020). It is the router `shared`, then the steps of Adam of `adamRoutes`.
+ * The runs and the bundles of `shared` stay, because no point of a run or of a trunk moves.
+ */
+export declare function adamRouter(options: Partial<AdamOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `adam` (RULE-020), 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 adamStrategy: Strategy<"router", AdamOptions>;
+/** The options of the router `reroute` (RULE-044: a corner graph with the prices of the rules, and rounds of rip-up and reroute). */
+interface RerouteOptions {
+  /** The price of a link in a narrow channel, from 0 to 2. The default is 1. */
+  readonly alpha: number;
+  /** The price of each edge of another key on a link, from 0 to 2. The default is 0.5. */
+  readonly beta: number;
+  /** The discount of a link that an edge of the same key uses, from 0 to 2. The default is 0.5. */
+  readonly gamma: number;
+  /** The price of a turn, in units of `clearance`, from 0 to 2. The default is 0.25. */
+  readonly tau: number;
+  /** The number of rounds of rip-up and reroute, from 1 to 5. The default is 2. */
+  readonly rounds: number;
+  /** The share of the edges that each round rips up: the edges with the largest price over their direct length, from 0.05 to 0.3. The default is 0.15. */
+  readonly q: number;
+  /** A channel narrower than this width gets the price `alpha`, from 4 to 64. The default is 16. */
+  readonly clearance: number;
+}
+/** The default options of the router `reroute`. */
+export declare const REROUTE_DEFAULTS: Readonly<RerouteOptions>;
+/** The declarations of the options of the router `reroute` (RULE-044). */
+export declare const REROUTE_SCHEMA: OptionSchema<RerouteOptions>;
+/** This function gives the number of turns of a way: the points where the direction changes by more than 1 degree. */
+export declare function turnsOf(seq: readonly Point[]): number;
+/**
+ * This function rips up and reroutes the ways of `shared` (RULE-044, after the rip-up and reroute of PathFinder, McMurchie 1995).
+ * The price factor of a link is `max(0.05, 1 + alpha × narrow + beta × others - gamma × same)`.
+ * `narrow` is `max(0, 1 - width / clearance)`. `others` counts the edges of the other keys on the link.
+ * `same` is 1 when an edge of the same key uses the link.
+ * The price of a way is the sum of the price factor times the length of each link, plus `tau × clearance` for each turn.
+ * Each round takes the share `q` of the ways with the largest price over their direct length. Each one gets a new search with the prices of the links.
+ * The new way stays only when its price is lower. The search has no state for the turns, so only the comparison reads `tau`.
+ */
+export declare function rerouteWays(ways: readonly Way[], search: SharedSearch, options?: Partial<RerouteOptions>): void;
+/**
+ * This function makes the router `reroute` (RULE-044). It is the router `shared`, then the rounds of rip-up and reroute of `rerouteWays`.
+ * The runs and the bundles come from the ways after the rounds.
+ */
+export declare function rerouteRouter(options: Partial<RerouteOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `reroute` (RULE-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 rerouteStrategy: Strategy<"router", RerouteOptions>;
+/** The edges that go first: the edges with few good ways (`tight`), or the edges with many good ways (`loose`). */
+type TightFirst = "tight" | "loose";
+/** The values of `TightFirst`. */
+export declare const TIGHT_FIRSTS: readonly TightFirst[];
+/** The order of two edges with the same slack: by the edge id, or the longer edge first. */
+type TightTies = "id" | "length";
+/** The values of `TightTies`. */
+export declare const TIGHT_TIES: readonly TightTies[];
+/** The options of the router `tight` (WILD-023: tight edges first, after list scheduling by slack). */
+interface TightOptions {
+  /** The cost factor of the links of the first way in the search of the second way, from 2 to 10. The default is 3. */
+  readonly penalty: number;
+  /**
+   * The edges that go first. With `tight`, the default, an edge whose second way costs much more than its first way goes first.
+   * With `loose`, the order turns around: the formula of the record, with the rising slack.
+   */
+  readonly first: TightFirst;
+  /** The order of two edges with the same slack. The default is `length`: the longer edge first, as in `shared`. */
+  readonly ties: TightTies;
+}
+/** The default options of the router `tight`. */
+export declare const TIGHT_DEFAULTS: Readonly<TightOptions>;
+/** The declarations of the options of the router `tight` (WILD-023). */
+export declare const TIGHT_SCHEMA: OptionSchema<TightOptions>;
+/**
+ * This function gives the slack of each way (WILD-023): `L2 / L1 - 1`. `L1` is the length of the shortest way.
+ * `L2` is the cost of the shortest way when each link of the first way costs `penalty` times its length.
+ * A way with no second way has the slack `penalty - 1`. A way with a second way of near-equal length has a slack near 0.
+ */
+export declare function waySlacks(ways: readonly Way[], search: SharedSearch, penalty: number): Map<Way, number>;
+/**
+ * This function makes the router `tight` (WILD-023). It is the router `shared` with another order of the edges of each key.
+ * With `first: tight`, the edges with the largest slack value go first: their second way costs much more, so they have few good ways.
+ * The edges with many ways of near-equal cost go last. The keys keep the order of `shared`.
+ */
+export declare function tightRouter(options: Partial<TightOptions> & {
+  readonly name: string;
+  readonly rule?: GroupRule;
+  readonly maxNodes?: number;
+}): Router;
+/**
+ * The router strategy `tight` (WILD-023), 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 tightStrategy: Strategy<"router", TightOptions>;
 /** 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. */
@@ -2112,6 +2418,44 @@ export declare const SPREAD_DEFAULTS: Required<SpreadOptions>;
  * The output has one entry for each edge with two known nodes, in the order of the edges.
  */
 export declare function spreadEnds(input: PlugInput, options?: SpreadOptions): PlugPair[];
+/**
+ * The order and the places of the plugs of one wall in the strategy `leaders` (EDA-041).
+ * With `po`, the sort key of a far end in front of the wall is its place on the axis along the wall.
+ * With `opo`, the plugs of a wall go at even places in the order of the keys of `spread`.
+ */
+export type WallLeader = "po" | "opo";
+/**
+ * This function does the work of `spreadEnds`, and of the strategy `leaders` with the argument `leader`.
+ * Without `leader`, it gives the plugs of `spread`.
+ */
+export declare function spreadWith(input: PlugInput, options?: SpreadOptions, leader?: WallLeader): PlugPair[];
+/**
+ * The type of leader of a plug. With `s`, the order of a wall is the order of the angles of the far ends, as in `spread`.
+ * With `po`, the stub leaves along the normal and turns once, so the order is the order of the far ends along the wall.
+ * With `opo`, the plugs of a wall go at even places, in the order of the angles.
+ */
+export type LeaderType = "s" | "po" | "opo";
+/** The values of `LeaderType`. */
+export declare const LEADER_TYPES: readonly LeaderType[];
+/** The options of the plug strategy `leaders`. */
+export interface LeaderOptions {
+  /** The type of leader. The default is `po`. */
+  readonly leader: LeaderType;
+  /** The least gap between two plugs of one wall, from 2 to 8. The default is 8. */
+  readonly slotSpacing: number;
+  /** The distance from a plug to a corner of its box, or a quarter of the wall when the wall is short. The default is 6. */
+  readonly inset: number;
+  /** The number of passes that sort each wall again by the new places of the far ends, from 0 to 4. The default is 2. */
+  readonly rounds: number;
+}
+/** The defaults of the plug strategy `leaders`. */
+export declare const LEADER_DEFAULTS: Readonly<LeaderOptions>;
+/**
+ * This function gives the plugs of the plug strategy `leaders` (EDA-041, after Bekos 2007). A fixed plug stays at its point, and a plug with a side stays on that side.
+ * Each free plug goes on the side that faces the other end. The plugs of each wall keep at least `slotSpacing` between two of them.
+ * The type of leader sets their order and their places. The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export declare function leaderEnds(input: PlugInput, options?: Partial<LeaderOptions>): PlugPair[];
 /** The options of `fixPorts`. */
 export interface FixPortsOptions {
   /** The options of the plug rule. The rule gets its `defaults` for each option that this object does not give. */
@@ -2195,6 +2539,346 @@ export declare function strategyKey(router: Strategy<"router">, step: Step): str
  * The output has the board and the routes. The function does not examine the `maxNodes` of the router.
  */
 export declare function runPipeline(graph: Graph, options: PipelineOptions): WholeOutput;
+/** The graph of the backbone of a level: the relative neighbourhood graph, or the Gabriel graph of the centers of the items. */
+export type VenationBackbone = "rng" | "gabriel";
+/** The values of `VenationBackbone`. */
+export declare const VENATION_BACKBONES: readonly VenationBackbone[];
+/** The options of the level strategy `venation` (NAT-016 of the nature notes): the options of `depths`, and the options of the backbone. */
+export interface VenationOptions extends DepthLevelOptions {
+  /** The graph of the backbone. The relative neighbourhood graph has fewer links than the Gabriel graph. The default is `rng`. */
+  readonly backbone: VenationBackbone;
+  /** A later level link saves this share of the cost of a backbone link that an earlier level link uses, from 0 to 0.8. The default is 0.4. */
+  readonly discount: number;
+  /** A level link takes its way on the backbone only when that way is this many times its direct link or less. The default is 1.5. */
+  readonly detour: number;
+  /** A level with more items than this number keeps the links of `depths`. The default is 400. */
+  readonly maxItems: number;
+}
+/** The default options of the level strategy `venation`. */
+export declare const VENATION_DEFAULTS: Readonly<VenationOptions>;
+/**
+ * This function gives the links of the backbone of the points, as pairs of indices `i < j` (NAT-016).
+ * With `rng`, the link `p q` exists when no third point `r` has `max(d(p, r), d(q, r)) < d(p, q)`.
+ * With `gabriel`, the link exists when no third point is inside the circle with the diameter `p q`.
+ */
+export declare function backboneLinks(points: readonly Point[], backbone: VenationBackbone): [number, number][];
+/**
+ * This function gives a way around the box `b`, inflated by `m`, from the point `a` to the point `c` of its boundary.
+ * The way goes along the shorter side of the inflated box. It holds the two points at `m` out from `a` and `c`, and the corners between them.
+ */
+export declare function aroundBox(b: Box, m: number, a: Point, c: Point): Point[];
+/**
+ * This function gives the links of one level along a closed venation backbone (NAT-016, after Runions and others, 2005).
+ * The backbone links the items by their relative neighbourhood graph or their Gabriel graph. Each backbone link goes around the other items.
+ * The level links go in the order of their counts, the largest first. Each one takes the cheapest way on the backbone, with the cost `L (1 - discount)` for a used backbone link.
+ * The way goes around each item between its two ends. A way longer than `detour` times the direct link, or a direct backbone link, keeps the direct link.
+ */
+export declare function venationLinks(items: readonly LevelItem[], direct: readonly LevelLink[], o: Readonly<VenationOptions>): LevelLink[];
+/**
+ * This function gives the zoom levels of the level strategy `venation` (NAT-016). The levels and their items are the levels of `depths`.
+ * In each level with groups, the links take their ways along a closed venation backbone (`venationLinks`). The last level stays as in `depths`.
+ */
+export declare function venationLevels(input: LevelInput, options: Readonly<VenationOptions>): Level[];
+/** The growth of the width of a stroke with the number of its edges. */
+export type WidthScale = "linear" | "sqrt" | "log";
+/** The values of `WidthScale`. */
+export declare const WIDTH_SCALES: readonly WidthScale[];
+/** The options of the level strategy `detail`: the options of `depths`, and the limits of the collapse. */
+export interface DetailOptions extends DepthLevelOptions {
+  /** Two parallel legs closer than this number of pixels on the screen become one stroke, from 0.5 to 4. The default is 3. */
+  readonly pxMin: number;
+  /** A stroke holds this number of edges or more, from 2 to 5. The default is 2. */
+  readonly minCount: number;
+  /** The width of a stroke of one edge, in pixels, from 1 to 4. The default is 1.5. A renderer reads it with `detailWidth`. */
+  readonly w0: number;
+  /** The growth of the width of a stroke with its count. The default is `log`. */
+  readonly widthScale: WidthScale;
+}
+/** The default options of the level strategy `detail`. */
+export declare const DETAIL_DEFAULTS: Readonly<DetailOptions>;
+/**
+ * This function gives the width of a stroke of `count` edges, in pixels (WILD-016). With `log`, it is `w0 × (1 + log2(count))`.
+ * With `sqrt`, it is `w0 × sqrt(count)`. With `linear`, it is `w0 × count`.
+ */
+export declare function detailWidth(count: number, o?: Pick<DetailOptions, "w0" | "widthScale">): number;
+/**
+ * This function collapses the legs of the links of one level that are closer than `tol` (WILD-016, EDA-038).
+ * The legs of each axis go in clusters along the axis across it. The leg with the largest count of a cluster is its stroke, and each other leg moves onto it.
+ * A cluster needs two legs whose projections overlap, and a count of `minCount` or more. A move that puts a leg through the box of an item does not happen.
+ */
+export declare function collapseLinks(items: readonly LevelItem[], links: readonly LevelLink[], tol: number, minCount: number): LevelLink[];
+/**
+ * This function gives the zoom levels of the level strategy `detail` (WILD-016 with EDA-038). The levels and their items are the levels of `depths`.
+ * A level with groups first shows at the scale `itemAt / size`, with `size` its median item (`pickLevel`). At that scale, `pxMin` pixels are `pxMin × size / itemAt` units.
+ * The links of the level collapse their legs that are closer than that length (`collapseLinks`). The last level stays as in `depths`.
+ */
+export declare function detailLevels(input: LevelInput, options: Readonly<DetailOptions>): Level[];
+/** One setting of the portfolio: a name and the options of the pipeline. */
+export interface PortfolioSetting {
+  readonly name: string;
+  readonly pipeline: PipelineOptions;
+}
+/** The options of the whole strategy `board-portfolio` (WILD-045). */
+export interface BoardPortfolioOptions {
+  /** The number of settings that the portfolio tries, from the start of its list, from 3 to 12. The default is 4. */
+  readonly settings: number;
+  /** The weight of the crossings (R1) in the score, from 0 to 4. The default is 1. */
+  readonly crossings: number;
+  /** The weight of the median detour (R5) in the score, from 0 to 4. The default is 1. */
+  readonly detour: number;
+  /** The weight of the ink saved (B1) in the score, from 0 to 4. The default is 1. */
+  readonly ink: number;
+  /**
+   * The time budget in seconds, from 0 to 10. After the budget, no new setting starts. The first setting always runs.
+   * The value 0, the default, sets no budget, so the output does not depend on the speed of the machine.
+   */
+  readonly budget: number;
+}
+/** The default options of the strategy `board-portfolio`. */
+export declare const BOARD_PORTFOLIO_DEFAULTS: Readonly<BoardPortfolioOptions>;
+/** The measures of one setting on the board, and its output. */
+export interface PortfolioEntry {
+  readonly name: string;
+  readonly output: WholeOutput;
+  readonly crossings: number;
+  readonly detour: number;
+  readonly ink: number;
+}
+/** The result of `boardPortfolio`: the output and the name of the pick. It also holds the measures of each setting with no break of a hard rule. */
+export interface BoardPortfolioRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly PortfolioEntry[];
+}
+/** This function gives the rank of each value from 0 (the best) to 1 (the worst). Equal values get the mean of their ranks. One value gets 0. */
+export declare function rankShares(values: readonly number[], lowerIsBetter: boolean): number[];
+/**
+ * This function runs the portfolio for one board (WILD-045, after Rice, 1976). It reads only the board and the outputs of its own settings.
+ * A setting whose router or highway strategy has a node limit below the size of the board does not run.
+ * A setting with a break of a hard rule does not count. The score of a setting is `Σ w_i × the rank share of measure_i` over the settings.
+ * The measures are the crossings (R1), the median detour (R5) and the ink saved (B1). The least score wins, and a tie goes to the earlier setting.
+ */
+export declare function boardPortfolio(graph: Graph, list: readonly PortfolioSetting[], o: Readonly<BoardPortfolioOptions>, now?: () => number): BoardPortfolioRun;
+/** One rule of the curriculum: the crossings (R1), the lane separation (R12) or the crossing angle (R2). */
+export type CurriculumRule = "R1" | "R12" | "R2";
+/** The order in which the curriculum adds its rules. */
+export type CurriculumOrder = "R1-R12-R2" | "R12-R1-R2" | "R1-R2-R12";
+/** The values of `CurriculumOrder`. */
+export declare const CURRICULUM_ORDERS: readonly CurriculumOrder[];
+/** The options of the whole strategy `curriculum` (RULE-048). */
+export interface CurriculumOptions {
+  /** The order in which the stages add the rules. The default is `R1-R12-R2`. */
+  readonly order: CurriculumOrder;
+  /** The number of passes over the edges in each stage, from 1 to 3. The default is 1. */
+  readonly passes: number;
+  /** The number of settings in the pool of routes, from the start of its list, from 2 to 3. The default is 3. */
+  readonly settings: number;
+  /** A new route has a detour of at most this value, or of its old route, from 1.5 to 4. The default is 2. */
+  readonly detour: number;
+}
+/** The default options of the strategy `curriculum`. */
+export declare const CURRICULUM_DEFAULTS: Readonly<CurriculumOptions>;
+/**
+ * This function gives the arc sine of `x` in radians, from -1 to 1. It is the algorithm of fdlibm, with only `+`, `*`, `/` and `Math.sqrt`.
+ * These operations are exact to the last bit on each platform, so the result does not depend on the engine.
+ */
+export declare function arcsin(x: number): number;
+/**
+ * This function gives the costs of the rules between two routes. R1 is the number of crossings.
+ * R2 is the sum of `1 - θ / 90` over the crossings. θ is the crossing angle in degrees.
+ * R12 is the overlap of the legs of `a` and `b` that are within 5 degrees of parallel. The two legs are nearer than 4 units.
+ */
+export declare function pairCosts(a: readonly Point[], b: readonly Point[]): Record<CurriculumRule, number>;
+/**
+ * This function runs the whole strategy `curriculum` (RULE-048, after curriculum learning, Bengio 2009). The record has no energy solver yet (RULE-019).
+ * Thus a pool of routes of fixed settings takes its place. Each edge can take its route from any setting of the pool.
+ * The first answer is the first setting. Each stage adds one rule, in the order `order`. A pass of a stage visits the edges, the worst first.
+ * An edge takes the route of the pool with the least cost of the new rule. That cost is lower, and the earlier rules do not get worse.
+ * A route with a break of a hard rule is not in the pool. The output has the routes alone, with no runs, bundles or levels.
+ */
+export declare function curriculum(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<CurriculumOptions>): WholeOutput;
+/** The features of one route, in order: crossings (R1), angle cost (R2), lane overlap (R12) over 20, detour minus 1 (R5), and bends over 2. */
+export declare const PREFERENCE_FEATURES: readonly string[];
+/**
+ * The weights of the made-up panel that labels the made-up pairs, in the order of `PREFERENCE_FEATURES`.
+ * The order comes from the studies of the readers of graphs: the crossings count most, then the bends and the length, then the angle (Purchase 1997, Ware, Purchase, Colpoys and McGill 2002).
+ * The numbers are made up. They do not come from the screen or from a board.
+ */
+export declare const PREFERENCE_PANEL: readonly number[];
+/** The options of the fit of the preferences. */
+export interface PreferenceFit {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The seed of the made-up pairs. The default is 1. */
+  readonly seed: number;
+  /** The number of made-up pairs, from 50 to 1000. The default is 200. */
+  readonly pairs: number;
+}
+/** The options of the whole strategy `preferences` (RULE-038). */
+export interface PreferenceOptions {
+  /** The weight of the L2 term of the fit, from 0 to 1. The default is 0.01. */
+  readonly l2: number;
+  /** The number of passes over the edges, from 1 to 3. The default is 1. */
+  readonly passes: number;
+  /** The number of settings in the pool of routes, from the start of its list, from 2 to 3. The default is 3. */
+  readonly settings: number;
+  /** A new route has a detour of at most this value, or of its old route, from 1.5 to 4. The default is 2. */
+  readonly detour: number;
+}
+/** The default options of the strategy `preferences`. */
+export declare const PREFERENCE_DEFAULTS: Readonly<PreferenceOptions>;
+/** One made-up pair: the features of two routes, and 1 when the panel prefers the first one. */
+export interface PreferencePair {
+  readonly a: readonly number[];
+  readonly b: readonly number[];
+  readonly first: 0 | 1;
+}
+/** The result of the fit: the weights, the agreement with held-out pairs, and the source of the pairs. */
+export interface PreferenceModel {
+  readonly weights: readonly number[];
+  /** The share of 50 held-out made-up pairs where the weights agree with the panel. */
+  readonly agreement: number;
+  readonly source: string;
+}
+/**
+ * This function gives a smooth step from 0 to 1, a stand-in for the logistic function with only `+`, `*`, `/` and `Math.abs`.
+ * It is `0.5 + 0.5 z / (1 + |z|)`. These operations are exact to the last bit on each platform.
+ */
+export declare function softStep(z: number): number;
+/**
+ * This function gives `count` made-up pairs, with the labels of the made-up panel `PREFERENCE_PANEL` and a noise.
+ * The pairs come from the seed alone. They do not come from a board.
+ */
+export declare function madeUpPairs(count: number, seed: number): PreferencePair[];
+/** This function gives the share of the pairs where the weights `w` prefer the same route as the panel. */
+export declare function agreementOf(w: readonly number[], pairs: readonly PreferencePair[]): number;
+/**
+ * This function fits the weights of the rules to made-up pairs (RULE-038, a Bradley-Terry model, after Bradley and Terry 1952).
+ * The probability that a reader prefers `a` to `b` is `softStep(u(a) - u(b))`, with `u(x) = -w · f(x)`. The fit takes 400 steps of the gradient of the score.
+ * An L2 term `l2 × |w|²` keeps the weights small. A weight below 0 becomes 0. The weights are scaled so that their sum is the number of features.
+ * The held-out pairs come from the seed plus 7919. The pairs do not come from the screen or from a board.
+ */
+export declare function fitPreferences(options?: Partial<PreferenceFit>): PreferenceModel;
+/**
+ * This function runs the whole strategy `preferences` (RULE-038). It fits the weights of the rules to made-up pairs (`fitPreferences`).
+ * Each edge can take its route from any setting of the pool. The first answer is the first setting.
+ * A pass visits the edges in order. An edge takes the route of the pool with the least weighted cost, when that cost is lower than the cost of its route.
+ * The cost is the weighted sum of the features of the route against the routes of the other edges. A route with a break of a hard rule is not in the pool.
+ * The output has the routes alone, with no runs, bundles or levels.
+ */
+export declare function preferences(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<PreferenceOptions>): WholeOutput;
+/** The search of the whole strategy `fireflies`: the firefly algorithm, or the artificial bee colony. */
+export type SwarmSearch = "firefly" | "bees";
+/** The values of `SwarmSearch`. */
+export declare const SWARM_SEARCHES: readonly SwarmSearch[];
+/** The options of the whole strategy `fireflies` (NAT-047). */
+export interface FireflyOptions {
+  /** The search. The default is `firefly`. */
+  readonly search: SwarmSearch;
+  /** The budget: the largest number of different settings that the search routes, from 4 to 40. The default is 12. */
+  readonly budget: number;
+  /** The number of fireflies or food sources, from 4 to 20. The default is 6. */
+  readonly colony: number;
+  /** The absorption `gamma` of the light of a firefly, from 0.01 to 10. The default is 1. */
+  readonly gamma: number;
+  /** The size `alpha` of the random step of a firefly, as a share of the range, from 0.01 to 0.5. The default is 0.2. */
+  readonly alpha: number;
+  /** The number of tries with no gain, after which a scout bee leaves a food source, from 10 to 100. The default is 10. */
+  readonly limit: number;
+  /** The seed of the search, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+}
+/** The default options of the strategy `fireflies`. */
+export declare const FIREFLY_DEFAULTS: Readonly<FireflyOptions>;
+/**
+ * This function gives the attraction of a firefly at the distance `r`: `BETA0 / (1 + u + u² / 2)` with `u = gamma × r²`.
+ * It is a rational stand-in for `BETA0 × exp(-u)`, with only `+`, `*` and `/`, so it is exact to the last bit on each platform.
+ */
+export declare function attraction(gamma: number, r2: number): number;
+/** One setting of the router `shared`: the option `discount` and the option `margin`. */
+export interface SwarmSetting {
+  readonly discount: number;
+  readonly margin: number;
+}
+/** This function gives the setting of a point of the unit square, on the grid of the search. */
+export declare function settingAt(x: number, y: number): SwarmSetting;
+/** One setting that the search routed: its score and its output. A setting with a break of a hard rule has the score `Infinity`. */
+export interface SwarmEntry {
+  readonly setting: SwarmSetting;
+  readonly score: number;
+  readonly output: WholeOutput;
+}
+/** The result of `fireflies`: the output, the best setting and each setting that the search routed, in order. */
+export interface SwarmRun {
+  readonly output: WholeOutput;
+  readonly best: SwarmSetting;
+  readonly entries: readonly SwarmEntry[];
+}
+/**
+ * This function gives the score of an output on its board. A lower score is better.
+ * The score is `crossings / edges + (median detour - 1) - ink saved`. A break of a hard rule gives `Infinity`.
+ */
+export declare function swarmScore(output: WholeOutput): number;
+/**
+ * This function runs the whole strategy `fireflies` (NAT-047, after the firefly algorithm of Yang 2008 and the bee colony of Karaboga 2005).
+ * It searches the options `discount` and `margin` of the router `router` on the board, on a grid of 20 × 8 settings.
+ * The first firefly or food source is the default setting, so the score of the output is not worse than the score of the default.
+ * A firefly moves toward each brighter one by `attraction(gamma, r²)` of the distance, plus a seeded step of size `alpha`.
+ * A bee tries `v = x + phi (x - x_k)` in one dimension, and a scout takes a new seeded place after `limit` tries with no gain.
+ * The search stops after `budget` different settings, or after 60 rounds. It reads only the board and the outputs of its own settings.
+ */
+export declare function fireflies(graph: Graph, router: Strategy<"router">, options?: Partial<FireflyOptions>): SwarmRun;
+/** The value of the loads of the edges of a board that the pick reads: the median, the quantile 0.95 or the mean. */
+export type TracingQuantile = "q50" | "q95" | "mean";
+/** The values of `TracingQuantile`. */
+export declare const TRACING_QUANTILES: readonly TracingQuantile[];
+/** The weights of the places to choose on the way of one edge (WILD-057). */
+export interface TracingWeights {
+  /** The weight of a crossing, from 0 to 4. The default is 1. */
+  readonly crossing: number;
+  /** The weight of a merge or a split where the edge is not an outer lane, from 0 to 4. The default is 2. */
+  readonly merge: number;
+  /** The weight of a bend, from 0 to 4. The default is 0.5. */
+  readonly bend: number;
+}
+/** The default weights of the tracing load, as the record gives them. */
+export declare const TRACING_WEIGHTS: Readonly<TracingWeights>;
+/** The options of the whole strategy `tracing` (WILD-057). */
+export interface TracingOptions extends TracingWeights {
+  /** The number of settings that the strategy tries, from the start of its list, from 1 to 12. The default is 4. */
+  readonly settings: number;
+  /** The value of the loads that the pick reads. The default is `q95`. */
+  readonly quantile: TracingQuantile;
+}
+/** The default options of the strategy `tracing`. */
+export declare const TRACING_DEFAULTS: Readonly<TracingOptions>;
+/**
+ * This function gives the tracing load of each edge of a result (WILD-057, after the tracing tasks of Ware, Purchase, Colpoys and McGill 2002).
+ * The load is `T(e) = crossing × crossings + merge × (merges and splits where e is not an outer lane) + bend × bends`.
+ * A shared run where the edge is not an outer lane gives one merge and one split. Such a bundle gives one split.
+ * A bend is a turn of more than 1 degree. The measure is W4 of MEAS3.
+ */
+export declare function tracingLoads(result: Result, weights?: Partial<TracingWeights>): Map<string, number>;
+/** This function gives a value of a list of loads: the median, the quantile 0.95 by the nearest rank, or the mean. An empty list gives 0. */
+export declare function tracingValue(loads: Iterable<number>, quantile: TracingQuantile): number;
+/** The tracing loads of one setting on the board: the value that the pick reads, and the median for a tie. */
+export interface TracingEntry {
+  readonly name: string;
+  readonly value: number;
+  readonly median: number;
+}
+/** The result of `tracing`: the output, the name of the pick and the loads of each setting with no break of a hard rule. */
+export interface TracingRun {
+  readonly output: WholeOutput;
+  readonly pick: string;
+  readonly entries: readonly TracingEntry[];
+}
+/**
+ * This function runs the whole strategy `tracing` (WILD-057). It runs the first `settings` settings of `list` on the board.
+ * A setting with a break of a hard rule, or above its node limit, does not count. The setting with the least tracing load wins.
+ * A tie goes to the least median load, then to the earlier setting. It reads only the board and the outputs of its own settings.
+ */
+export declare function tracing(graph: Graph, list: readonly PortfolioSetting[], options?: Partial<TracingOptions>): TracingRun;
 /** A broken hard rule. A correct router has none. */
 export interface Violation {
   readonly rule: "complete" | "ends-at-plugs" | "fixed-plugs" | "no-pass-through" | "counts-sum" | "link-ends" | "bundle-trunk" | "run-shared";
@@ -5213,6 +5897,153 @@ export declare function interchangeCandidates(spines: readonly (readonly Point[]
  * 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;
+/** One point of a balancing-factor tree. */
+interface FanPoint {
+  readonly point: Point;
+  /** The index of the point before, toward the root. The root has -1. */
+  parent: number;
+  /** The length of the tree from the root to this point. */
+  pl: number;
+  /** A new branch can join the tree at this point, and on the link from its parent. A plug of a target is not open. */
+  readonly open: boolean;
+}
+/** The result of `balancedFan`: the points of the tree, and the index of the last point of the route of each target. */
+interface Fan {
+  readonly points: readonly FanPoint[];
+  readonly leaf: readonly number[];
+}
+/** The rule that picks one tree on the front: the knee of the chord, or the least weighted sum. */
+type KneeRule = "chord" | "weights";
+/** The values of `KneeRule`. */
+export declare const KNEE_RULES: readonly KneeRule[];
+/** The options of the highway strategy `knee` (NAT-018 of the nature notes, on the trees of NAT-017). */
+interface KneeOptions {
+  /** The number of points of the sweep of the balancing factor, from 5 to 21. The default is 11. */
+  readonly sweep: number;
+  /** The rule that picks one tree on the front. The default is `chord`. */
+  readonly rule: KneeRule;
+  /** The weight of the ink in the rule `weights`, from 0 to 1. The rest of the weight goes to the path length. The default is 0.5. */
+  readonly ink: number;
+  /** 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 `knee`. */
+export declare const KNEE_DEFAULTS: Readonly<KneeOptions>;
+/** One tree of the sweep: its balancing factor, its ink `L`, the sum of its path lengths `S`, and the tree. */
+interface KneeTree {
+  readonly bf: number;
+  readonly ink: number;
+  readonly paths: number;
+  readonly fan: Fan;
+}
+/**
+ * This function gives the index of the tree that the rule picks on the front of the trees (NAT-018).
+ * The front holds the trees that no other tree beats on the ink and on the path lengths. The two values go to the range from 0 to 1.
+ * With `chord`, the pick is the tree of the front farthest from the line between the two ends of the front.
+ * With `weights`, the pick is the tree with the least `ink × L + (1 - ink) × S`. A tie goes to the earlier tree.
+ */
+export declare function kneeOf(trees: readonly Pick<KneeTree, "ink" | "paths">[], rule: KneeRule, ink: number): number;
+/**
+ * This function gives the highways of the knee trees (NAT-018). The edges from one source node get one tree. Its root is the out point of the plug nearest the center of the targets.
+ * A sweep of the balancing factor of NAT-017 gives trees from the least ink to the most direct paths.
+ * The tree at the knee of the front of ink and path lengths is the pick. 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 kneePlan(input: HighwayInput, o: Readonly<KneeOptions>): HighwayPlan;
+/** The end of a ride that the price moves: the exit, the entry, or both by half. */
+type BalanceEnd = "exit" | "entry" | "both";
+/** The values of `BalanceEnd`. */
+export declare const BALANCE_ENDS: readonly BalanceEnd[];
+/** The options of the highway strategy `balance` (EDA-017). */
+interface BalanceOptions {
+  /** The target of the stretch of an edge: its route on the plan over its route alone, from 1.1 to 2. The default is 1.2. */
+  readonly tau: number;
+  /** The number of updates of the prices, from 5 to 30. The default is 5. */
+  readonly iterations: number;
+  /** The end of a ride that the price moves. The default is `exit`. */
+  readonly end: BalanceEnd;
+  /** The plan that the strategy balances. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `balance`. */
+export declare const BALANCE_DEFAULTS: Readonly<BalanceOptions>;
+/**
+ * This function gives the plan of the highway strategy `balance` (EDA-017, after the Lagrange relaxation of the stretch).
+ * The stretch of an edge is its route on the plan over its route alone, as the gate `stretch` measures it.
+ * At each update, an edge with a stretch above `tau` adds `stretch - tau` to its price. Each of its rides keeps the share `1 - price` of its first length.
+ * A ride shorter than the margin leaves the plan. The updates stop when no edge is above `tau`.
+ */
+export declare function balancePlan(input: HighwayInput, options?: Partial<BalanceOptions>): HighwayPlan;
+/** This function balances the plan `first` of the graph, as `balancePlan` does. It reads all the options except `from`. */
+export declare function balanceOf(graph: Graph, first: HighwayPlan, options?: Partial<BalanceOptions>): HighwayPlan;
+/** The place of the header in the gap before the row: near the row, or near the feed node. */
+type ManifoldSide = "near" | "far";
+/** The values of `ManifoldSide`. */
+export declare const MANIFOLD_SIDES: readonly ManifoldSide[];
+/** The options of the highway strategy `manifolds` (WILD-036). */
+interface ManifoldOptions {
+  /** A manifold has this number of taps or more, from 3 to 8. The default is 3. */
+  readonly kMin: number;
+  /** The nodes of one row have centers in a band of this many median box heights, from 0.5 to 2. The default is 1. */
+  readonly band: number;
+  /** The place of the header in the gap before the row. The default is `near`. */
+  readonly side: ManifoldSide;
+  /** A tap stays on the manifold only when its way is this many times the direct line or less, from 1 to 3. The default is 1.5. */
+  readonly detour: number;
+  /** The plan of the edges that are not on a manifold. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `manifolds`. */
+export declare const MANIFOLD_DEFAULTS: Readonly<ManifoldOptions>;
+/**
+ * This function gives the plan of the highway strategy `manifolds` (WILD-036, after the headers of pipes and of bus bars).
+ * A fan of `kMin` edges or more from one node to a row of nodes gets a straight header in the gap before the row.
+ * Each edge of the fan joins the header at the feed point, in line with the center of the node. It leaves the header at its tap, in line with the center of its far node.
+ * A tap whose way is more than `detour` times the direct line leaves the manifold. Each edge is on one manifold at most. The other edges keep the plan `from`.
+ */
+export declare function manifoldPlan(input: HighwayInput, options?: Partial<ManifoldOptions>): HighwayPlan;
+/** The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap of the angles. */
+type BronchialSplit = "count" | "weight" | "gap";
+/** The values of `BronchialSplit`. */
+export declare const BRONCHIAL_SPLITS: readonly BronchialSplit[];
+/** The options of the highway strategy `bronchial` (NAT-019 of the nature notes). */
+interface BronchialOptions {
+  /**
+   * The rule of the split. With `count`, each half gets half of the targets. With `weight`, the two halves get near-equal sums of the distances from the tip.
+   * With `gap`, the cut goes at the widest gap between the angles of the targets. The default is `count`.
+   */
+  readonly split: BronchialSplit;
+  /** The share of the distance to the center of the targets that a branch grows, from 0.3 to 0.7. The default is 0.5. */
+  readonly share: number;
+  /** A set with this number of targets or fewer stops the splits, from 1 to 3. Each of its targets gets its own way from the tip. The default is 1. */
+  readonly smallest: number;
+  /** 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 `bronchial`. */
+export declare const BRONCHIAL_DEFAULTS: Readonly<BronchialOptions>;
+/**
+ * This function gives the diamond angle of the direction `(dx, dy)`: a value from 0 to 4 that grows with the angle, with no trigonometry.
+ * The value 0 is the direction of the positive x axis.
+ */
+export declare function diamondAngle(dx: number, dy: number): number;
+/**
+ * This function splits the targets of a tip in two halves (NAT-019). The targets go in the order of their angles around the tip.
+ * The order starts after the widest gap of the angles, so each half is a sector. The rule of `split` then cuts the order in two.
+ */
+export declare function splitTargets(tip: Point, targets: readonly Point[], ids: readonly number[], split: BronchialSplit): [number[], number[]];
+/**
+ * This function gives the highways of the bronchial trees (NAT-019, after Kitaoka and others, 1999). The edges from one source node get one tree.
+ * The root of a tree is the out point of the plug nearest the center of the targets.
+ * From the tip, the tree grows a share of the way to the center of its targets. Then it splits the targets in two and grows a branch for each half.
+ * A branch that hits a box grows half as far, or not at all. A small set of targets gets its own ways from the tip, through the corner graph.
+ * Each edge takes its path in the tree when that path is short enough, and the stretches that two edges or more share become highways.
+ */
+export declare function bronchialPlan(input: HighwayInput, o: Readonly<BronchialOptions>): 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`. */
@@ -5966,6 +6797,53 @@ interface SidePlugOptions {
   /** The largest number of places that the search tries on each side. The default is 16. */
   readonly most?: number;
 }
+/** The edges that can join a trunk: only the edges with the key of the trunk, or each edge. */
+type SlotKeys = "same" | "any";
+/** The values of `SlotKeys`. */
+export declare const SLOT_KEYS: readonly SlotKeys[];
+/** The options of the highway strategy `slots` (RULE-047). */
+interface SlotOptions {
+  /** The weight `k` of the pull, from 0.25 to 8. The default is 2. The name is not `k`, because `follow` reads `k` as an option of its ways. */
+  readonly pull: number;
+  /** The reach `r` of the pull, in units, from 8 to 64. A route point farther than this distance from a trunk gets no pull. The default is 24. */
+  readonly reach: number;
+  /** The distance between two lanes of a trunk, in units, from 2 to 8. The default is 4. */
+  readonly laneSpacing: number;
+  /** The largest stretch of a route after it joins a trunk: its new length over its first length, from 1.05 to 2. The default is 1.25. */
+  readonly maxStretch: number;
+  /** The edges that can join a trunk. The default is `same`. */
+  readonly keys: SlotKeys;
+  /** The plan that gives the trunks. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+}
+/** The default options of the strategy `slots`. */
+export declare const SLOT_DEFAULTS: Readonly<SlotOptions>;
+/** One possible join of an edge to a trunk: the trunk, the places on its spine, the pull and the detour. */
+interface SlotJoin {
+  readonly highway: number;
+  readonly on: number;
+  readonly off: number;
+  /** The pull energy that the join removes: `k × Σ w(d) × (d - slot)² × step / r²`, in units of length. */
+  readonly pull: number;
+  /** The length that the join adds to the route, as an estimate. */
+  readonly detour: number;
+}
+/**
+ * This function gives the best join of one route to the trunk `h`, or `undefined`.
+ * The longest row of samples nearer than `reach` to the spine is the part of the route that the trunk pulls.
+ * The slot of the new lane is at `laneSpacing × (lanes + 1) / 2` from the spine. The weight is `w(d) = max(0, 1 - d / r)`.
+ */
+export declare function slotJoin(route: readonly Point[], h: Highway, index: number, o: Readonly<SlotOptions>): SlotJoin | undefined;
+/**
+ * This function gives the plan of the highway strategy `slots` (RULE-047, after the pull of force-directed edge bundling, Holten and van Wijk 2009).
+ * The trunks are the highways of the plan `from`. Each edge outside the plan gets a pull toward the slot of a new lane of a trunk near its first route.
+ * The energy of the pull is `E = k Σ w(d_i) ‖x_i - slot_i‖²` over the samples of the route, with `w(d) = max(0, 1 - d / r)`.
+ * The edge joins the trunk when the pull is larger than the length that the join adds, and the stretch stays under `maxStretch`.
+ * The edge takes the trunk with the largest gain, on the outer lane. An edge that does not fit stays off the trunks.
+ */
+export declare function slotPlan(input: HighwayInput, options?: Partial<SlotOptions>): HighwayPlan;
+/** This function adds the joins of `slotPlan` to the plan `first` of the graph. It reads all the options except `from`. A join that breaks a hard rule after `follow` leaves the plan. */
+export declare function slotsOf(graph: Graph, first: HighwayPlan, routes: ReadonlyMap<string, readonly Point[]>, options?: Partial<SlotOptions>): HighwayPlan;
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
 /** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
@@ -6110,6 +6988,11 @@ export declare const highwayStrategies: {
   readonly streets: Strategy<"highway", StreetOptions>;
   readonly search: Strategy<"highway", SearchOptions>;
   readonly interchanges: Strategy<"highway", InterchangeOptions>;
+  readonly knee: Strategy<"highway", KneeOptions>;
+  readonly bronchial: Strategy<"highway", BronchialOptions>;
+  readonly balance: Strategy<"highway", BalanceOptions>;
+  readonly manifolds: Strategy<"highway", ManifoldOptions>;
+  readonly slots: Strategy<"highway", SlotOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -6122,17 +7005,35 @@ export declare const plugStrategies: {
   readonly side: Strategy<"plugs", SidePlugOptions>;
   readonly justify: Strategy<"plugs", JustifyOptions>;
   readonly spread: Strategy<"plugs", SpreadOptions>;
+  readonly leaders: Strategy<"plugs", LeaderOptions>;
 };
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
 export declare const levelStrategies: {
   readonly depths: Strategy<"levels", DepthLevelOptions>;
+  readonly venation: Strategy<"levels", VenationOptions>;
+  readonly detail: Strategy<"levels", DetailOptions>;
 };
+/**
+ * The fixed list of settings of the whole strategy `board-portfolio` (WILD-045), in order. The option `settings` takes the first ones.
+ * The list holds routers and highway strategies with their defaults. It comes from the catalog of the strategies, not from a fit to the screen.
+ */
+export declare const BOARD_PORTFOLIO_SETTINGS: readonly PortfolioSetting[];
+/**
+ * The pool of routes of the whole strategy `curriculum` (RULE-048), in order: the routers of the base of the screen. The first one gives the first answer.
+ * The option `settings` takes the first ones.
+ */
+export declare const CURRICULUM_POOL: readonly PortfolioSetting[];
 /**
  * The built-in whole strategies: the strategies of the step `whole`. The strategy `pipeline` runs one strategy of each step, as the demo of the site does.
  * Without options, it routes the graph with the router `corners`.
  */
 export declare const wholeStrategies: {
   readonly pipeline: Strategy<"whole", PipelineOptions>;
+  readonly "board-portfolio": Strategy<"whole", BoardPortfolioOptions>;
+  readonly curriculum: Strategy<"whole", CurriculumOptions>;
+  readonly preferences: Strategy<"whole", PreferenceOptions>;
+  readonly fireflies: Strategy<"whole", FireflyOptions>;
+  readonly tracing: Strategy<"whole", TracingOptions>;
 };
 /** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
 export declare const BUILT_IN_STRATEGIES: readonly AnyStrategy[];
@@ -6686,8 +7587,27 @@ export declare const SCREEN_V2_HELD_OUT: readonly number[];
  * This set does not change. The tests compare it with the files in `corpus/screen-v2`.
  */
 export declare const SCREEN_V2: ScreenSet;
+/** The member seeds of each family of `screen-v3` that the split `default` holds out. */
+export declare const SCREEN_V3_HELD_OUT: readonly number[];
+/**
+ * The screen set `screen-v3` (CORPUS-FAMILIES): the 15 families of `HIGHWAYS_FAMILIES`, each with the 10 members 0 to 9, thus 150 boards.
+ * The first 6 families are the families of `screen-v2` with their seeds. Thus their boards are the boards of `screen-v2`, under the ids of `screen-v3`.
+ * The 9 new families cover frames with rows, a long chain, a wide fan-out and two hubs.
+ * They also cover uneven sizes, thin bars, long edges, short edges and a complete bipartite part.
+ *
+ * The manifest declares 10 inputs for each family. The split `default` holds out the members 7 to 9 of each family.
+ * This set does not change. A new family goes into a new set. The tests compare it with the files in `corpus/screen-v3`.
+ */
+export declare const SCREEN_V3: ScreenSet;
 /**
- * The screen sets by id. `screen-v1` and its larger version `screen-v2` (CORPUS-SEEDS) have the boards of the screen.
+ * This function gives the power of the sign test over `families` families at the level `level`.
+ * The power is the least count of families on one side that passes.
+ * A family set without ties and with that count or more on one side passes the two-sided exact sign test, with the p below `level`.
+ * The function gives `undefined` when no count passes, for example for 5 families or fewer at the level 0.05.
+ */
+export declare function signTestPower(families: number, level?: number): number | undefined;
+/**
+ * The screen sets by id. `screen-v1`, its larger version `screen-v2` (CORPUS-SEEDS) and `screen-v3` with 15 families (CORPUS-FAMILIES) have the boards of the screen.
  * `exact-v1` has small boards with a known optimum (MEAS2). `exact-v1-bounds` has larger boards with bounds (EXACT-BOUNDS).
  */
 export declare const SCREEN_SETS: Readonly<Record<string, ScreenSet>>;
@@ -7253,8 +8173,37 @@ export declare const MANY_GROUPS: HighwaysFamily;
  * Its generator record always has `cols`, `rows` and `long`, as the screen sets of today. It has `reach` only away from its default.
  */
 export declare const PACKED_GRID: HighwaysFamily;
+/**
+ * The family `frame-rows`: cards with full-width rows, as INTERIOR-ROUTE takes them. Each row has a fixed plug on the east wall and on the west wall of its card.
+ * The links join a plug of a card to a plug of another card. An inner edge joins a row to a plug of its own card. The default has no inner edge.
+ */
+export declare const FRAME_ROWS: HighwaysFamily;
+/** The family `pipeline`: a long chain of stages in rows that turn at each end, with some links that skip stages. */
+export declare const PIPELINE: HighwaysFamily;
+/** The family `fan-out`: one large hub in the middle, with a link to each leaf on the square rings around it. */
+export declare const FAN_OUT: HighwaysFamily;
+/** The family `two-hubs`: two tall hubs with many nodes between them. Each such node has a link from each hub. A few nodes of one hub are on its far side. */
+export declare const TWO_HUBS: HighwaysFamily;
+/** The family `uneven-sizes`: a few large boxes and many small boxes in shelves, in a random order. Many edges end on a large box. */
+export declare const UNEVEN_SIZES: HighwaysFamily;
+/** The family `thin-bars`: long thin bars in lanes, as a timeline or the rows of a table. The links join bars of lanes near each other. */
+export declare const THIN_BARS: HighwaysFamily;
+/** The family `sparse-long`: few nodes far apart on a large board, and edges that go to far targets. */
+export declare const SPARSE_LONG: HighwaysFamily;
+/** The family `local-mesh`: a grid of small nodes with many short edges, each to a node of the 8 nodes around it. */
+export declare const LOCAL_MESH: HighwaysFamily;
+/** The values of the dimension `layout` of `bipartite`. */
+export declare const BIPARTITE_LAYOUTS: readonly string[];
+/**
+ * The family `bipartite`: a complete bipartite part, with dense crossings that no plan can remove, and other nodes with random links.
+ * At 3 nodes or more on each side, the part has no drawing without crossings.
+ */
+export declare const BIPARTITE: HighwaysFamily;
+/** The 9 families of CORPUS-FAMILIES, in the order of `screen-v3`. */
+export declare const COVERAGE_FAMILIES: readonly HighwaysFamily[];
 /**
  * The corpus families of highways, in the order of the screen sets. Each family at its defaults makes the board of its screen family.
+ * The first 6 families are the families of `screen-v1` and `screen-v2`. The 9 families of `COVERAGE_FAMILIES` follow them (CORPUS-FAMILIES).
  * An import registers nothing. A host makes a registry with `createFamilyRegistry(HIGHWAYS_FAMILIES)`, or with the lists of other engines too.
  */
 export declare const HIGHWAYS_FAMILIES: readonly HighwaysFamily[];
@@ -7652,5 +8601,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 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 };
+export { type AdamOptions, type AdvectionSettings, type AmbiguityGuardOptions, type AnnealingOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type BalanceEnd, type BalanceOptions, type Biclique, type BreakEvenOptions, type BronchialOptions, type BronchialSplit, type BundleLine, type BundleOrder, type CanalHub, type CanalOptions, 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 GutterEdge, type GutterOptions, 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 InnerMode, type Interchange, type InterchangeBase, type InterchangeOptions, type JogStyle, type KdAxis, type KdLine, type KdOptions, type KdeebOptions, type KeyOptions, type KeyedWay, type KeysOptions, type KneeOptions, type KneeRule, type KneeTree, type LaneCurve, type LanesOptions, type LevelHighwayOptions, type LinkCommunityOptions, type LinkEdge, type Linkage, type ManifoldOptions, type ManifoldSide, 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 RerouteOptions, 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 SharedHooks, type SharedNegotiation, type SharedOptions, type SharedSearch, type SharedStretchOptions, type SharedWaysOptions, type SkeletonGroups, type SkeletonTarget, type SlotJoin, type SlotKeys, type SlotOptions, 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 TightFirst, type TightOptions, type TightTies, 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