@mark1russell7/highways 0.1.5 → 0.2.0

package/README.md

@@ -122,12 +122,65 @@ On the packed board, the links are short only because they go through the boxes.
 
 The links of a gap without lanes share one line. Thus the crossings on that line do not count. With a lane for each link, the crossings show, and the order `crossings` removes 20% of them. The spacing changes the crossings less than 5%. The mean detour stays near 1.32 for each knob, because a link with legs parallel to the axes goes around the boxes.
 
+## Options of the zoom levels
+
+The router `sections` makes its hubs and its zoom levels from a tree of groups. Each rule and each limit of that tree is an option. The defaults give the output of version 0.1.5.
+
+| Option | Default | Where | What it sets |
+|---|---|---|---|
+| `group` | the quadtree | `sectionsRouter` | The grouping rule: a strategy of the step `group`. `groupOptions` gives its options. |
+| `levels` | each depth | `sectionsRouter` | The depths of the tree that get a level with groups. The level of single nodes always comes last. |
+| `stretch` | 2 | `sectionsRouter` | The hub limit. A way through the hubs is at most this many times the straight line. `Infinity` keeps each such way. |
+| `stretchPad` | 4 | `sectionsRouter` | A way through the hubs can be this many margins longer than the hub limit. |
+| `hubSlack` | 80 | `sectionsRouter` | A way skips a hub that is this many units farther from the target than the way was before. |
+| `hubs` | `Infinity` | `sectionsRouter` | The number of hubs on each side of the lowest common section that a way passes. |
+| `cap` | 8 | `buildSections` | The section limit. A section with more nodes splits in four. |
+| `maxDepth` | 16 | `buildSections` | The depth limit of the tree. |
+| `collapse` | 32 | `buildSections` | A cell shrinks to one quarter at most this many times without a split. |
+| `tightMargin` | 1 | `levelLinks` | The margin of the second corner graph of the level links. |
+| `plugInset` | 6 | `levelLinks` | A plug of a level link stays this far from the corners of its side. |
+| `routesAt`, `itemAt` | 22, 120 | `pickLevel` | The far-view thresholds, in pixels on the screen. `PICK` holds them. |
+
+`SECTIONS_DEFAULTS`, `SECTION_DEFAULTS`, `LEVEL_LINK_DEFAULTS` and `PICK` give the default numbers. `itemSizes(levels)` gives the sizes that `pickLevel(sizes, scale, options)` reads.
+
+The built-in grouping rules are in `groupStrategies`. The rule `quadtree` splits the plane, as `buildSections` does. The rule `keys` makes one group for each key of the nodes. Its default key is the string `data.group` of a node, and a node without a key is a group alone. With the option `split`, a large group splits into a quadtree.
+
+A consumer rule groups the nodes by its own field. Then the far view shows one item for each group:
+
+```ts
+import { defineStrategy, keyedSections, sectionsRouter } from "@mark1russell7/highways";
+
+const byTeam = defineStrategy({
+  step: "group",
+  name: "team",
+  describe: "One group for each team.",
+  defaults: {},
+  run: (graph) => keyedSections(graph.nodes, { key: (node) => String(node.data?.["team"]) }),
+});
+const result = sectionsRouter({ name: "teams", group: byTeam }).route(graph);
+// result.levels[1] has one item for each team. The id of an item is "s:" and the team.
+```
+
+The router examines the tree of a consumer rule with `checkSections`. Each node must be in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+
+The benchmark sweeps the hub limit, `hubSlack`, `cap` and the grouping rules on the case boards. Each table starts with the defaults. On `case-hub-chain`:
+
+| `stretch` | Worst detour | Routes through hubs | Shared runs | Out and back |
+|---|---:|---:|---:|---:|
+| 1.25 | 1.19 | 14 | 4 | 0 |
+| 1.5 | 1.39 | 20 | 8 | 0 |
+| 2 (default) | 1.78 | 24 | 10 | 0 |
+| 3 | 2.05 | 25 | 11 | 0 |
+
+A smaller hub limit gives shorter routes and fewer shared runs. No route goes through a box or out and back at any value. On `case-many-groups`, the rule `keys` has one key for each group of cards. It gives 32 items at the far view, and no level link goes out and back.
+
 ## Strategies
 
 The steps of the pipeline that vary have strategies. Each step has one interface, so a consumer chooses a strategy by its name or adds its own.
 
 | Step | Input | Output | Built-in strategies |
 |---|---|---|---|
+| `group` | `Graph` | `Section`: the tree of groups of the router `sections` | `quadtree`, `keys` |
 | `router` | `Graph` | `Result` | `straight`, `plugs`, `corners`, `corners-smooth`, `trunks`, `shared`, `shared-all`, `sections`, `sections-tree` |
 | `curve` | `CurveInput`: the points, the normals of the plugs and the free space | `CurveSegment[]` | `straight`, `rounded`, `spline`, `arc` |
 | `room` | `RoomInput`: the boxes and the links of a board | `Gap[]` | `routes`, `lines` |
@@ -139,7 +192,7 @@ A strategy has a `step`, a `name`, a `describe` text, its `defaults` and the met
 - `register(registry, ...strategies)` gives a new registry. It does not change the registry before it.
 - `listStrategies(registry, step)` gives the strategies of a step, in order. `findStrategy` and `getStrategy` give one strategy by its name.
 - `asRouter(strategy, options?)` gives a `Router`, and `routersOf(registry)` gives the routers of a registry.
-- `STRATEGIES` is the registry of `BUILT_IN_STRATEGIES`. The records `routerStrategies`, `curveStrategies` and `roomStrategies` give each built-in strategy with its typed options.
+- `STRATEGIES` is the registry of `BUILT_IN_STRATEGIES`. The records `groupStrategies`, `routerStrategies`, `curveStrategies` and `roomStrategies` give each built-in strategy with its typed options.
 
 A registry is data. No import changes it. The benchmark and the site take their lists from `STRATEGIES`, so a new built-in strategy gets its rows and its button with no other edit. A consumer makes its own registry:
 
@@ -167,7 +220,7 @@ const rows = runBenchmark(routersOf(registry), FIXTURES.slice(0, 1)); // The row
 
 The built-in strategies give the same output as their functions. `curveStrategies.rounded.run({ points, space }, { radius: 8 })` gives the segments of `curveOf(points, { type: "rounded", space, radius: 8 })`. `benchCurveStrategies` and the fourth argument of `benchRoom` take a list of strategies.
 
-The plugs and the zoom levels have one strategy each, so they have no step yet.
+The plugs have one strategy, so they have no step yet. The step `group` gives the grouping rule of the zoom levels.
 
 ## License
 

package/build/index.d.ts

@@ -96,6 +96,8 @@ export interface Node {
   readonly id: string;
   readonly box: Box;
   readonly ports?: readonly Port[];
+  /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
+  readonly data?: Readonly<Record<string, unknown>>;
 }
 /** One end of an edge: a node, and optionally one plug of that node. */
 export interface End {
@@ -652,7 +654,11 @@ export interface SectionOptions {
   readonly cap?: number;
   /** The tree stops at this depth. The default is 16. */
   readonly maxDepth?: number;
+  /** A cell shrinks to one quarter at most this many times without a split. Then it stops. The default is 32. */
+  readonly collapse?: number;
 }
+/** The default values of `SectionOptions`. */
+export declare const SECTION_DEFAULTS: Readonly<Required<SectionOptions>>;
 /**
  * This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
  * When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
@@ -662,6 +668,55 @@ export declare function buildSections(nodes: readonly Node[], options?: SectionO
 export declare function allSections(root: Section): Section[];
 /** This function gives the depth of the deepest section. */
 export declare function treeDepth(root: Section): number;
+/**
+ * This function examines a tree of sections from a grouping rule. It throws an error when the tree is not valid for `count` nodes.
+ * In a valid tree, each node is in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+ */
+export declare function checkSections(root: Section, count: number): void;
+/**
+ * This function gives the tree of sections of the grouping rule `quadtree`: the cells of a quadtree of the plane (`buildSections`).
+ * It is the default grouping rule of the router `sections`.
+ */
+export declare function quadtreeGroups(graph: Graph, options?: SectionOptions): Section;
+/** A key rule gives the key of the group of a node. A node without a key is a group alone. */
+type NodeKey = (node: Node, index: number) => string | undefined;
+/** The options of the grouping rule `keys`. */
+interface KeyOptions {
+  /** This function gives the key of the group of each node. The default is `byDataGroup`. */
+  readonly key?: NodeKey;
+  /**
+   * With this value, a group with more nodes than its `cap` splits into the cells of a quadtree, as `buildSections` does.
+   * Without it, each group is one leaf. The default is no split.
+   */
+  readonly split?: SectionOptions;
+}
+/** This key rule gives the string `data.group` of the node, or `undefined` when the node has no such string. */
+export declare const byDataGroup: NodeKey;
+/**
+ * This function gives the tree of sections of the grouping rule `keys`. The root holds each node. Each child of the root holds the nodes of one key,
+ * in the order of their first node. The id of a group is `s:` and its key. A node without a key is a group alone, with the id `s#` and its index.
+ * Thus the far view of the router `sections` shows one item for each group.
+ */
+export declare function keyedSections(nodes: readonly Node[], options?: KeyOptions): Section;
+/** This function gives the tree of sections of the grouping rule `keys` for a graph. */
+export declare function keyGroups(graph: Graph, options?: KeyOptions): Section;
+/** This function gives the median width of the shown items of each level, in units of the plane. */
+export declare function itemSizes(levels: readonly Level[]): number[];
+/** The far-view thresholds of `pickLevel`, in pixels on the screen. */
+export interface PickOptions {
+  /** When a node is at least this wide on the screen, the view shows each route. */
+  readonly routesAt: number;
+  /** A level is fine enough when its median item is at least this wide on the screen. */
+  readonly itemAt: number;
+}
+/** The default thresholds: a node of 22 pixels shows its routes, and a group of 120 pixels shows its parts. */
+export declare const PICK: PickOptions;
+/**
+ * This function picks the level that a camera shows at a scale, in pixels for each unit of the plane. The sizes come from `itemSizes`.
+ * The value `sizes.length` stands for the routes of each edge. The last level holds the nodes alone.
+ * Each threshold that `options` does not give gets its value from `PICK`.
+ */
+export declare function pickLevel(sizes: readonly number[], scale: number, options?: Partial<PickOptions>): number;
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export declare function boxExit(box: Box, toward: Point): Point;
 /**
@@ -705,73 +760,16 @@ interface SharedOptions extends WayOptions {
  * The result gives each stretch as a run, with the order of its lanes.
  */
 export declare function sharedRouter(options: SharedOptions): Router;
-/** The options of the router with sections. */
-interface SectionsOptions extends WayOptions, SectionOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
+/** The options of the links of a level: the options of the ways, and two limits of the level links. */
+interface LevelLinkOptions extends WayOptions {
   /**
-   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
-   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
+   * The second graph uses the smaller of this value and `margin`. The default is 1.
    */
-  readonly hubs?: number;
-  /** A way through the hubs can be at most this many times as long as the line between its plugs. Else the edge goes directly. The default is 2. */
-  readonly stretch?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
+  readonly tightMargin?: number;
+  /** A plug stays at least this far from the corners of its side. The level links use the smaller of this value and `margin`. The default is 6. */
+  readonly plugInset?: number;
 }
-/**
- * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
- * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
- * Each way from hub to hub is found one time, so all the edges on it share its points.
- * The edges in one section of the lowest level go straight around the nodes.
- *
- * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
- *
- * The result gives one zoom level for each depth of the tree.
- * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
- */
-export declare function sectionsRouter(options: SectionsOptions): Router;
-/** The options of the trunk router. */
-interface TrunksOptions extends WayOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
-  /** The grouping rule. The edges from one plug with one key share a trunk. */
-  readonly rule: GroupRule;
-  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
-  readonly split?: number;
-  /** A group with fewer edges stays unbundled. The default is 2. */
-  readonly minSize?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
-}
-/** The rule that groups the edges by the collection of their target, in `data.collection`. */
-export declare const byCollection: GroupRule;
-/**
- * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
- * A group with fewer than `minSize` edges does not appear.
- */
-export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
-/**
- * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
- * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
- */
-export declare function laneOrder(dir: Point, from: Point, branches: readonly {
-  readonly edge: string;
-  readonly next: Point;
-}[]): string[];
-/**
- * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
- * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
- */
-export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
-/**
- * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
- * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
- * The edges outside the groups go as in the corner router.
- */
-export declare function trunksRouter(options: TrunksOptions): Router;
-/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
-export declare const ROUTERS: readonly Router[];
 /** An item with a box: a node of a graph, an item of a level or a box of a host layout. */
 export interface Boxed {
   readonly id: string;
@@ -862,6 +860,207 @@ export declare function roomDemand(items: readonly Boxed[], links: readonly Room
 export declare function makeRoom<T extends Boxed>(items: readonly T[], links: readonly RoomLink[], options?: RoomOptions): Room<T>;
 /** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
 export declare function roomLinks(graph: Graph): RoomLink[];
+/** The input of a curve strategy: one polyline and the context of its route. */
+export interface CurveInput {
+  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
+  readonly points: readonly Point[];
+  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
+  readonly startNormal?: Point;
+  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. */
+  readonly space?: CurveSpace;
+}
+/** The input of a room strategy: the boxes of a board and the links between them. */
+export interface RoomInput {
+  readonly items: readonly Boxed[];
+  readonly links: readonly RoomLink[];
+}
+/**
+ * The steps that have strategies, with the fixed input and output type of each step.
+ *
+ * - `group`: a graph in, the tree of sections out. The router `sections` makes its hubs and its zoom levels from this tree.
+ * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
+ * - `curve`: a polyline in, the segments of a curve out.
+ * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ */
+export interface StepTypes {
+  readonly group: {
+    readonly input: Graph;
+    readonly output: Section;
+  };
+  readonly router: {
+    readonly input: Graph;
+    readonly output: Result;
+  };
+  readonly curve: {
+    readonly input: CurveInput;
+    readonly output: CurveSegment[];
+  };
+  readonly room: {
+    readonly input: RoomInput;
+    readonly output: Gap[];
+  };
+}
+/** The name of a step that has strategies. */
+export type Step = keyof StepTypes;
+/** The input type of a step. */
+export type StepInput<S extends Step> = StepTypes[S]["input"];
+/** The output type of a step. */
+export type StepOutput<S extends Step> = StepTypes[S]["output"];
+/** The steps that have strategies, in the order of the pipeline. */
+export declare const STEPS: readonly Step[];
+/**
+ * A strategy: one way to do one step, with a name and a description.
+ * The same input and the same options must give the same output.
+ */
+export interface Strategy<S extends Step = Step, O extends object = object> {
+  /** The step of the strategy. It fixes the input and the output type. */
+  readonly step: S;
+  /** The name of the strategy. Each name is unique in its step of a registry. */
+  readonly name: string;
+  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
+  readonly describe: string;
+  /** The values of the options when the caller gives no value. */
+  readonly defaults: Readonly<O>;
+  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
+  readonly maxNodes?: number;
+  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
+  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
+}
+/** A strategy of any step. A registry holds a list of these. */
+export type AnyStrategy = { [S in Step]: Strategy<S>; }[Step];
+/** The definition of a strategy, for `defineStrategy`. */
+export interface StrategyDefinition<S extends Step, O extends object> {
+  readonly step: S;
+  readonly name: string;
+  readonly describe: string;
+  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
+  readonly defaults: O;
+  readonly maxNodes?: number;
+  /** This function does the step. It gets each option, from the caller or from `defaults`. */
+  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
+}
+/**
+ * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+ * When the caller gives no option, the definition gets the `defaults` object itself.
+ */
+export declare function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O>;
+/**
+ * A registry: the strategies of each step, in order. A registry is data. No import changes it.
+ * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
+ * The list `group` is optional in the type, so a registry from version 0.1.5 stays a registry. `createRegistry` always gives it.
+ */
+export type Registry = { readonly [S in Exclude<Step, "group">]: readonly Strategy<S>[]; } & {
+  readonly group?: readonly Strategy<"group">[];
+};
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+export declare function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry;
+/** This function gives the strategies of one step of a registry, in order. */
+export declare function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[];
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+export declare function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined;
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+export declare function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S>;
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+export declare function routersOf(registry: Registry): Router[];
+/**
+ * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
+ * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
+ * The options `tightMargin` and `plugInset` are the limits of the level links (`levelLinks`).
+ */
+interface SectionsOptions extends LevelLinkOptions, SectionOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
+   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   */
+  readonly hubs?: number;
+  /**
+   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
+   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
+   */
+  readonly stretch?: number;
+  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
+  readonly stretchPad?: number;
+  /**
+   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
+   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   */
+  readonly hubSlack?: number;
+  /**
+   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
+   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   */
+  readonly group?: Strategy<"group">;
+  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly groupOptions?: object;
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/**
+ * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+ * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+ * Each way from hub to hub is found one time, so all the edges on it share its points.
+ * The edges in one section of the lowest level go straight around the nodes.
+ *
+ * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ *
+ * The result gives one zoom level for each depth of the tree.
+ * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ */
+export declare function sectionsRouter(options: SectionsOptions): Router;
+/** The options of the trunk router. */
+interface TrunksOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The grouping rule. The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule;
+  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
+  readonly split?: number;
+  /** A group with fewer edges stays unbundled. The default is 2. */
+  readonly minSize?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/** The rule that groups the edges by the collection of their target, in `data.collection`. */
+export declare const byCollection: GroupRule;
+/**
+ * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
+ * A group with fewer than `minSize` edges does not appear.
+ */
+export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
+/**
+ * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
+ * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
+ */
+export declare function laneOrder(dir: Point, from: Point, branches: readonly {
+  readonly edge: string;
+  readonly next: Point;
+}[]): string[];
+/**
+ * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
+ * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
+ */
+export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
+/**
+ * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
+ * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
+ * The edges outside the groups go as in the corner router.
+ */
+export declare function trunksRouter(options: TrunksOptions): Router;
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
+export declare const ROUTERS: readonly Router[];
 /**
  * The lane order of the pieces of the links in one gap.
  *
@@ -1066,106 +1265,6 @@ export declare function formatTable(rows: readonly BenchRow[]): string;
  * A router without such levels gets a dash in the columns of the levels.
  */
 export declare function formatFaults(rows: readonly BenchRow[]): string;
-/** The input of a curve strategy: one polyline and the context of its route. */
-export interface CurveInput {
-  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
-  readonly points: readonly Point[];
-  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
-  readonly startNormal?: Point;
-  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
-  readonly endNormal?: Point;
-  /** The boxes that the curve must not go through, from `curveSpace`. */
-  readonly space?: CurveSpace;
-}
-/** The input of a room strategy: the boxes of a board and the links between them. */
-export interface RoomInput {
-  readonly items: readonly Boxed[];
-  readonly links: readonly RoomLink[];
-}
-/**
- * The steps that have strategies, with the fixed input and output type of each step.
- *
- * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
- * - `curve`: a polyline in, the segments of a curve out.
- * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
- */
-export interface StepTypes {
-  readonly router: {
-    readonly input: Graph;
-    readonly output: Result;
-  };
-  readonly curve: {
-    readonly input: CurveInput;
-    readonly output: CurveSegment[];
-  };
-  readonly room: {
-    readonly input: RoomInput;
-    readonly output: Gap[];
-  };
-}
-/** The name of a step that has strategies. */
-export type Step = keyof StepTypes;
-/** The input type of a step. */
-export type StepInput<S extends Step> = StepTypes[S]["input"];
-/** The output type of a step. */
-export type StepOutput<S extends Step> = StepTypes[S]["output"];
-/** The steps that have strategies, in the order of the pipeline. */
-export declare const STEPS: readonly Step[];
-/**
- * A strategy: one way to do one step, with a name and a description.
- * The same input and the same options must give the same output.
- */
-export interface Strategy<S extends Step = Step, O extends object = object> {
-  /** The step of the strategy. It fixes the input and the output type. */
-  readonly step: S;
-  /** The name of the strategy. Each name is unique in its step of a registry. */
-  readonly name: string;
-  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
-  readonly describe: string;
-  /** The values of the options when the caller gives no value. */
-  readonly defaults: Readonly<O>;
-  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
-  readonly maxNodes?: number;
-  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
-  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
-}
-/** A strategy of any step. A registry holds a list of these. */
-export type AnyStrategy = { [S in Step]: Strategy<S>; }[Step];
-/** The definition of a strategy, for `defineStrategy`. */
-export interface StrategyDefinition<S extends Step, O extends object> {
-  readonly step: S;
-  readonly name: string;
-  readonly describe: string;
-  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
-  readonly defaults: O;
-  readonly maxNodes?: number;
-  /** This function does the step. It gets each option, from the caller or from `defaults`. */
-  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
-}
-/**
- * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
- * When the caller gives no option, the definition gets the `defaults` object itself.
- */
-export declare function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O>;
-/**
- * A registry: the strategies of each step, in order. A registry is data. No import changes it.
- * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
- */
-export type Registry = { readonly [S in Step]: readonly Strategy<S>[]; };
-/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
-export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
-/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
-export declare function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry;
-/** This function gives the strategies of one step of a registry, in order. */
-export declare function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[];
-/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
-export declare function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined;
-/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
-export declare function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S>;
-/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
-export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
-/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
-export declare function routersOf(registry: Registry): Router[];
 /**
  * One row of the benchmark of the curves: one curve type on the routes of one router on one fixture.
  * The type `T` of the name of the curve is `CurveType` for `benchCurves`, and `string` for `benchCurveStrategies`.
@@ -1268,6 +1367,59 @@ export declare function laneSettings(spacings?: readonly number[], orders?: read
 export declare function passSettings(gutters?: readonly number[], passes?: readonly number[]): RoomSetting[];
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 export declare function formatRoom(rows: readonly RoomBenchRow[]): string;
+/** The options of one setting of the router `sections`, without the name. */
+export type SectionsSettingOptions = Omit<SectionsOptions, "name" | "maxNodes">;
+/** One setting of a sweep of the router `sections`. */
+export interface SectionsSetting {
+  /** The name of the setting in the column `setting`. */
+  readonly name: string;
+  readonly options: SectionsSettingOptions;
+}
+/** One row of a sweep of the router `sections`: one setting on one board, and the measures of its routes and of its zoom levels. */
+export interface SectionsBenchRow {
+  readonly fixture: string;
+  readonly setting: string;
+  /** The faults of the routes of the edges (`measureRouteFaults`). */
+  readonly faults: LinkFaults;
+  /** The sum of the faults of the levels with groups (`measureLevelFaults` and `sumFaults`). */
+  readonly levelFaults: LinkFaults;
+  /** The sum of the overlaps of the levels with groups. */
+  readonly overlaps: number;
+  /** The number of routes that go through hubs: the routes that are not the same as the direct route of their edge. */
+  readonly hubRoutes: number;
+  /** The number of shared stretches of way of the result (`runs`). */
+  readonly runs: number;
+  /** The number of zoom levels, with the last level of single nodes. */
+  readonly levels: number;
+  /** The number of items of the far view: the first level with more than one item. */
+  readonly farItems: number;
+  /** The time of one route, in milliseconds. */
+  readonly ms: number;
+}
+/**
+ * This function measures the router `sections` on one board with each setting. The first row is the fair baseline: the defaults, with no option.
+ * The direct routes come from the hub limit 0, so `hubRoutes` counts the routes that use the hubs.
+ */
+export declare function sweepSections(fixture: string, graph: Graph, settings: readonly SectionsSetting[]): SectionsBenchRow[];
+/** The values of the hub limit (`stretch`) of the sweep of CUSTOM. The default is 2. */
+export declare const STRETCH_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the hub limit: one setting for each value of `stretch`. */
+export declare function stretchSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of `hubSlack` of the sweep of CUSTOM. The default is 80. */
+export declare const SLACK_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the slack of the hubs: one setting for each value of `hubSlack`. */
+export declare function slackSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of the section limit (`cap`) of the sweep of CUSTOM. The default is 8. */
+export declare const CAP_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the section limit: one setting for each value of `cap`. */
+export declare function capSettings(values?: readonly number[]): SectionsSetting[];
+/**
+ * This function gives one setting for each grouping rule: the router `sections` with the strategy as its option `group`.
+ * The map `options` gives the options of a strategy by its name.
+ */
+export declare function groupSettings(strategies?: readonly Strategy<"group">[], options?: Readonly<Record<string, object>>): SectionsSetting[];
+/** This function writes the rows of `sweepSections` as a Markdown table. */
+export declare function formatSections(rows: readonly SectionsBenchRow[]): string;
 /** 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`. */
@@ -1306,9 +1458,14 @@ export declare const roomStrategies: {
   readonly routes: Strategy<"room", RoomPreset>;
   readonly lines: Strategy<"room", RoomPreset>;
 };
+/** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
+export declare const groupStrategies: {
+  readonly quadtree: Strategy<"group", Required<SectionOptions>>;
+  readonly keys: Strategy<"group", KeyOptions>;
+};
 /** 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[];
 /** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
 export declare const STRATEGIES: Registry;
-export type { ArcOptions, CornersOptions, CurveSpace, RoundedOptions, SectionsOptions, SharedOptions, SplineOptions, TrunksOptions };
+export type { ArcOptions, CornersOptions, CurveSpace, KeyOptions, NodeKey, RoundedOptions, SectionsOptions, SharedOptions, SplineOptions, TrunksOptions };
 //# sourceMappingURL=index.d.ts.map