@mark1russell7/highways 0.9.3 → 0.9.4

package/README.md

@@ -99,6 +99,16 @@ A node can name a frame node in `parent`. A frame is a node that holds other nod
   - `throw` (the default) throws a `RangeError`.
   - `skip` gives no route to the edges of that node.
   - `clamp` cuts the box to the bounds of the frame.
+- The option `inner` sets the mode of the inner routes:
+  - `corners` (the default) finds each route in the corner graph, as above.
+  - `gutter` gives orthogonal routes in the gaps between the nodes and in the strips at the walls.
+- In the mode `gutter`, a route uses the whole box of the frame. The mode does not use `frameInset`.
+- A route of the mode `gutter` goes into its row at the port, or at the left or right end of the row.
+- The plug stub stays perpendicular to the wall. A plug that is level with its row gives only the stub.
+- The option `bendCost` is the cost of one bend in units of length. A larger cost gives fewer bends. The default is 16.
+- Each gap that two or more routes share gets one lane for each route. The lanes are evenly spaced, in an order with few crossings.
+- The space between two lanes is the margin of the router. In a narrow gap, the space becomes smaller.
+- An edge with no way through the free room gets no route, as with `skip`. Rows that touch each other with gap 0 can block a way.
 
 ```ts
 const nodes = [
@@ -107,6 +117,7 @@ const nodes = [
 ];
 const edges = [{ id: "inner", source: { node: "row" }, target: { node: "card", port: "in" } }];
 const inner = cornersRouter({ name: "corners" }).route({ nodes, edges }).routes; // inner[0].frame is "card"
+const gutters = cornersRouter({ name: "corners", inner: "gutter", bendCost: 24 }).route({ nodes, edges }).routes; // only H and V legs
 ```
 
 ## Curve types
@@ -463,6 +474,13 @@ Each of these steps has one default strategy. The default gives the output of th
   The option `level` of `sections` takes a level strategy, and `levelOptions` gives its options. The strategy also gets the level options of the router.
 - `pipeline` (the step `whole`) runs a room strategy, then a router or a highway plan, with the rules that the router reads (`runPipeline`).
   Without options, it routes with `corners`. The demo of the site runs it. It does not draw the curves.
+- `venation` (the step `levels`, NAT-016) keeps the levels of `depths`. Its level links take their ways on a closed backbone of the items.
+  The backbone is the relative neighbourhood graph (`rng`) or the Gabriel graph. A backbone link that a level link uses costs less for the next level links.
+  The routes do not change, so only the level links (Z3) change.
+- `board-portfolio` (the step `whole`, WILD-045) runs a short list of settings on the board and keeps the best one.
+  The list `BOARD_PORTFOLIO_SETTINGS` holds 12 routers and highway plans. The option `settings` sets how many of them run.
+  A setting with a break of a hard rule does not count. The score adds the rank shares of the crossings, the median detour and the ink saved.
+  It reads no screen record and has no fit. With `budget: 0`, the default, the pick does not depend on the speed of the machine.
 - `strategyKey(router, step)` gives the option of a router that takes a strategy of the step. `pipeline` uses it for the steps `group`, `plugs` and `levels`.
 - `stepRouterStrategy(strategy)` runs a strategy of a step of `RoutedStep` as a router. `stepRouters(registry, step)` gives one router for each strategy of the step.
 
@@ -541,6 +559,8 @@ The step `highway` decides which edges share a way. It gives a plan, not routes.
 | `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. |
+| `knee` | The knee tree of NAT-018. A sweep of the balancing factor gives trees from the least ink to the most direct paths, and the knee of that front is the pick. |
+| `bronchial` | The bronchial tree of NAT-019. The tree grows toward the center of its targets, then splits them in two sectors, again and again. |
 
 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`.
@@ -616,6 +636,17 @@ The router `attraction` is opt-in. It is not in `STRATEGIES`, so the default out
 - 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 routers `tight` and `annealing`
+
+The routers `tight` and `annealing` are opt-in. They are not in `STRATEGIES`, so the default outputs do not change. Both put a hook on the router `shared`.
+
+- `tightRouter(options)` gives the order of WILD-023: the edges whose second way costs much more than their first way go first.
+  Its options are `penalty` (2 to 10), `first` (`tight` or `loose`) and `ties` (`id` or `length`). `tightStrategy` is its router strategy.
+- `annealingRouter(options)` gives the simulated annealing of RULE-021, with the candidate routes of WILD-028. Each edge picks one of a few ways.
+  The energy adds the ink, the path length and the crossings. The chance to keep a worse state is rational, so it uses no `Math.exp`.
+  Its options are `candidates` (3 to 8), `crossing` (0 to 20), `temperature` (0.1 to 10), `cooling` (0.9 to 0.99), `budget` (20 to 200) and `seed`.
+  The same seed gives the same routes. `annealingStrategy` is its router strategy.
+
 ### 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.
@@ -774,6 +805,24 @@ const { rows, front } = compareStep("curve", graph, { options: { arc: { radius:
 const lanes = compareStep("curve", graph, { curveRouter: "shared", lanes: { width: 5, maxWidth: 30 }, options: { highway: { jog: "quintic" } } });
 ```
 
+## The corpus families
+
+`HIGHWAYS_FAMILIES` lists the 15 generators of the boards of the screen and the site. Each one is a family of `@mark1russell7/layout-contract`, with its dimensions as data. `highwaysRegistry()` makes a registry of them.
+
+- The first 6 families make the boards of `screen-v1` and `screen-v2`.
+- `COVERAGE_FAMILIES` adds 9 families: `frame-rows`, `pipeline`, `fan-out`, `two-hubs`, `uneven-sizes`, `thin-bars`, `sparse-long`, `local-mesh` and `bipartite`.
+- The screen set `screen-v3` has the 15 families, each with 10 seeds.
+- `signTestPower(n)` gives the least count of families out of `n` that passes a two-sided sign test at the level 0.05. For 15 families, the count is 12.
+
+```ts
+import { highwaysRegistry, signTestPower } from "@mark1russell7/highways";
+
+const { graph } = highwaysRegistry().generate("fan-out", 4, { leaves: 40 });
+console.log(graph.nodes.length, signTestPower(15)); // 41 12
+```
+
+[The corpus families](https://github.com/mark1russell7/highways/blob/main/docs/LAYOUT-RECORDS.md#the-corpus-families-corpus-gen) give the dimensions of each family.
+
 ## The same routes on each platform
 
 A transcendental Math function, for example `Math.atan2` or `Math.hypot`, can give a different last bit on another platform or node version. A decision of a router must not depend on that bit.

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,139 @@ 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;
+}
+/**
+ * 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 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. */
@@ -2195,6 +2358,92 @@ 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[];
+/** 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;
 /** 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 +5462,101 @@ 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 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`. */
@@ -6110,6 +6454,8 @@ 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 "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -6126,13 +6472,20 @@ export declare const plugStrategies: {
 /** 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>;
 };
+/**
+ * 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 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>;
 };
 /** 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 +7039,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 +7625,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 +8053,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 AdvectionSettings, type AmbiguityGuardOptions, type AnnealingOptions, type ArcOptions, type ArcSource, type AreaOptions, type AreaWidth, type AttractionOptions, type Biclique, type BreakEvenOptions, type BronchialOptions, type BronchialSplit, 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 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 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 SharedHooks, type SharedNegotiation, type SharedOptions, type SharedSearch, 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 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