@mark1russell7/layout-contract 0.2.13 → 0.2.15

package/README.md

@@ -10,7 +10,7 @@ The package has no runtime dependencies.
 |---|---|
 | Geometry | `Point`, `Rect`, `Region`, `Side`, `Sides`, `Margin`, `marginSides`, `grow`, `boundsOf`, `translate`, `overlapOf` |
 | The shape kinds | `ShapeKind`, `SHAPE_KINDS`, `SHAPE_KIND_IDS`, `ShapeKindSpec`, `ShapeGeometry`, `DEFAULT_SHAPES`, `ShapeSupport`, `isShapeKind`, `shapeKindOf`, `shapeKindsOf`, `itemShapeOf`, `shapeKindProblem`, `shapesOf`, `checkShapes` |
-| The input `layout-input/1` | `LayoutInput`, `LayoutBox` (`Item` for the packer), `Port`, `LayoutEdge`, `LayoutContainer`, `Obstacle`, `LayoutCell`, `LayoutGenerator` |
+| The input `layout-input/1` | `LayoutInput`, `LayoutBox` (`Item` for the packer), `Port`, `portPoint`, `LayoutEdge`, `LayoutContainer`, `Obstacle`, `LayoutCell`, `LayoutGenerator`, `PairGap`, `canonicalInput` |
 | The packer | `PackInput`, `toPackInput`, `Placement`, `PackOutput`, `StageTrace`, `applyPack` |
 | The record `layout-record/1` | `LayoutRecord`, `Stage`, `Supports`, `RunFacts`, `RunEnv`, `toLayoutRecord` |
 | The strategies | `StrategyInfo` |
@@ -36,8 +36,21 @@ The package has no runtime dependencies.
 - **The turn.** A turn is 90 degrees clockwise, with the y axis down. A point (`px`, `py`) of a box of height `h` goes to (`h - py`, `px`). Each side moves one step clockwise. The router gets the turned box and ports, and does not read `turn`.
 - **The margin.** A margin is a ring around a box. No other box and no route enters it. A route from a port of the box crosses the ring at a right angle.
 - **The gap.** The gap is the free space between two boxes with their margins. Routes use it. Two boxes are `mA + gap + mB` apart.
+- **The pair gaps.** `pairGaps` gives a minimum distance to some pairs of boxes: `{ a, b, gap, lanes? }`. For its pair, the `gap` of an entry replaces `mA + gap + mB`.
+  - The order of `a` and `b` has no meaning. A pair without an entry keeps its margins and the global `gap`.
+  - `lanes` is the count of the channels that the gap has space for. It is information only.
+  - `checkInput` refuses an unknown box, a pair of one box, a repeated pair in either order, a negative or infinite `gap` and bad `lanes`.
+  - `canonicalInput` puts `a` before `b` in each pair and sorts the list. `documentHash` uses this form, so an input without `pairGaps` keeps its hash.
+  - The hard rule `no-overlap` reads `pairGaps`. For a pair of the list, in either order, the `gap` replaces the two margins. The pair breaks the rule only when the boxes are nearer than the gap.
+  - The pairs that are not in the list keep their margins. Without `pairGaps`, the verdicts and the hashes of the records do not change.
 - **The ports.** A port can have a side. Without a side, the router picks the side. A fixed port has `x` and `y` on the border of the box, relative to its top-left corner.
-- **The hard rules of a pack.** `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`. `checkInput` refuses a locked box without a position. Another box without a placement and not in `overflow` breaks `complete`.
+  - A port with `side` and `along` is fixed at a fraction of its side. `along` is a number from 0 to 1, from the start of the side.
+  - The start of `left` and `right` is the top end. The start of `top` and `bottom` is the left end. `countPortsOffBorder` uses the same start for `x` and `y`.
+  - `checkInput` refuses `along` without a side, a value that is not a finite number from 0 to 1, and `along` with `x` or `y`.
+  - `portPoint(box, port)` gives the point of a port, relative to the top-left corner of the box. A port without a fixed point gives `undefined`, because the router picks the point.
+  - A turn changes `along` of `left` and `right` to `1 - along`, because the start of the side moves to its other end. `along` of `top` and `bottom` stays.
+  - An input without `along` keeps its hash.
+- **The hard rules of a pack.** `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A pair of `pairGaps` uses its gap in place of the margins. A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`. `checkInput` refuses a locked box without a position. Another box without a placement and not in `overflow` breaks `complete`.
 - **The container rule.** `in-container` counts each box that goes out of the container made smaller by `inset`. The box counts with its margin. By default, a shaped container counts as its bounding box.
 - **The exact container.** Give `{ exactContainer: true }` to `packHard` or `countOutside`. Then a box of a shaped container with the size `fixed` must stay inside the shape. A cut corner, a notch and a hole count. A container with a free side keeps the bounding test. The default changes to the exact test at the next breaking version.
 - **The shape kinds.** An item is a `rect`, a `polygon`, a `circle` or a `free` shape. Each measure and rule declares its kinds. `checkShapes` refuses the other kinds. `docs/SHAPES.md` tells the rules.

package/build/index.d.ts

@@ -189,14 +189,27 @@ export declare function leaveOneSeedOut(seeds: readonly number[]): SplitFold[];
 /**
  * A port of a box: a place where edges go into the box.
  * With `x` and `y`, the port is fixed on the border of the box, relative to its top-left corner.
- * Without them, the router places the port on its `side`. Without a side, the router picks the side.
+ * With `side` and `along`, the port is fixed at a fraction of its side.
+ * With only a side, the router places the port on that side. Without a side, the router picks the side.
  */
 export interface Port {
   readonly id: string;
   readonly side?: Side;
   readonly x?: number;
   readonly y?: number;
+  /**
+   * The place of the port on its `side`: a fraction from 0 to 1, from the start of the side.
+   * The start of `left` and `right` is the top end. The start of `top` and `bottom` is the left end.
+   * It needs a `side`. A port with `along` has no `x` and no `y`.
+   */
+  readonly along?: number;
 }
+/**
+ * This function gives the point of a port on the border of its box, relative to the top-left corner of the box.
+ * A port with `x` and `y` gives that point. A port with `side` and `along` gives the point at that fraction of the side.
+ * Another port gives `undefined`, because the router picks its point.
+ */
+export declare function portPoint(box: Pick<LayoutBox, "w" | "h">, port: Port): Point | undefined;
 /** A box of an input. In the packer, its name is item. */
 export interface LayoutBox {
   readonly id: string;
@@ -266,6 +279,18 @@ export interface LayoutGenerator {
   readonly params: Readonly<Record<string, unknown>>;
   readonly seed: number;
 }
+/**
+ * One minimum distance between two boxes (`a` and `b`). It replaces the two margins of the boxes for this pair, and the global `gap`.
+ * The order of `a` and `b` has no meaning. A pair without an entry keeps the margins and the `gap`.
+ */
+export interface PairGap {
+  readonly a: string;
+  readonly b: string;
+  /** The minimum distance between the two boxes, in units: a finite number of 0 or more. */
+  readonly gap: number;
+  /** The count of the channels that the gap has space for. It is information only: a whole number of 0 or more. */
+  readonly lanes?: number;
+}
 /** The cell of an input in the taxonomy: one value for each dimension. The dimensions are in `docs/FORMAT.md` of `packing`. */
 export interface LayoutCell {
   readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
@@ -303,6 +328,8 @@ export interface LayoutInput {
   readonly container?: LayoutContainer;
   /** The free space between two boxes with their margins. Routes use it. */
   readonly gap?: number;
+  /** The distances of some pairs of boxes. An entry replaces the margins and the `gap` for its pair. `canonicalInput` sorts the list. */
+  readonly pairGaps?: readonly PairGap[];
   readonly boxes: readonly LayoutBox[];
   readonly edges?: readonly LayoutEdge[];
   readonly obstacles?: readonly Obstacle[];
@@ -312,6 +339,11 @@ export interface LayoutInput {
    */
   readonly base?: string;
   readonly change?: "add" | "remove" | "resize" | "reorder" | "packed";
+  /**
+   * The fields that a corpus registry removed, because a dimension value made them wrong (`CorpusDimension.invalidates`).
+   * The names are sorted. An input with no removed field has no `invalidated`.
+   */
+  readonly invalidated?: readonly string[];
 }
 /** The input of a packer: a `layout-input/1` file without the edges. */
 export interface PackInput {
@@ -319,9 +351,16 @@ export interface PackInput {
   readonly items: readonly Item[];
   readonly obstacles?: readonly Obstacle[];
   readonly gap?: number;
+  readonly pairGaps?: readonly PairGap[];
 }
 /** This function gives the packer input of a file. An input without a container gets `{ fixed: "none" }`, so the packer picks the size. */
 export declare function toPackInput(input: LayoutInput): PackInput;
+/**
+ * This function gives the canonical form of an input. `documentHash` uses it for each `layout-input/1` document.
+ * Each pair of `pairGaps` gets `a` before `b`, and the list is sorted by `a` and then by `b`.
+ * An input without `pairGaps` is the same object, so its hash does not change.
+ */
+export declare function canonicalInput<T extends LayoutInput>(input: T): T;
 /**
  * The kind of the shape of an item. A box without `shape` and without `shapeKind` is a `rect`.
  * The set is open: a later version can add a kind. A reader treats an unknown kind as a kind that it does not support.
@@ -517,8 +556,11 @@ export declare function placedRect(box: LayoutBox): Rect | undefined;
 /**
  * This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.
  * A box with a shape counts as its bounding box. That area is larger, thus the count is safe.
+ *
+ * A pair of `pairGaps`, in either order, uses its `gap` in place of the two margins. One box grows by the gap, and the other box does not grow.
+ * Thus the pair breaks the rule only when the boxes are nearer than the gap on each axis. The other pairs do not change.
  */
-export declare function countOverlaps(boxes: readonly LayoutBox[], tolerance?: number): number;
+export declare function countOverlaps(boxes: readonly LayoutBox[], tolerance?: number, pairGaps?: readonly PairGap[]): number;
 /** The options of the container test of `countOutside` and `packHard`. */
 export interface ContainerTest {
   /**
@@ -566,7 +608,8 @@ export declare function countObstacleHits(boxes: readonly LayoutBox[], obstacles
 /**
  * This function gives the count of each hard rule of the output of a packer.
  * It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.
- * `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle.
+ * `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A pair of `pairGaps` uses its gap in place of the margins.
+ *
  * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.
  * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.
  * Another box without a placement that is not in `overflow` breaks `complete`.
@@ -577,13 +620,19 @@ export declare function packHard(input: LayoutInput, output: PackOutput, toleran
 /**
  * This function gives the problems of an input file. An empty list tells that the file is good.
  * A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.
+ * In `pairGaps`, an unknown box, a pair of one box, a repeated pair in either order, a bad `gap` and bad `lanes` are problems.
+ * A port with `along` and no `side`, with `x` or `y`, or with a value outside [0, 1] is a problem.
  */
 export declare function checkInput(input: LayoutInput): readonly string[];
 /** This function gives the side after a turn of 90 degrees clockwise. */
 export declare function turnSide(side: Side): Side;
 /** This function gives a point of a box of height `h` after the turn. */
 export declare function turnPoint(x: number, y: number, h: number): [number, number];
-/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */
+/**
+ * This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`.
+ * The start of a side is its top end or its left end. Thus `left` goes to `top` and `right` goes to `bottom` with `along` changed to `1 - along`.
+ * `top` goes to `right` and `bottom` goes to `left` with the same `along`.
+ */
 export declare function turnPort(port: Port, h: number): Port;
 /** This function gives a margin after the turn: the value of each side moves one side clockwise. */
 export declare function turnMargin(margin: Margin): Margin;
@@ -731,6 +780,7 @@ export declare function outputHash(value: unknown, options?: HashOptions): strin
 /**
  * This function gives the hash of a document. It uses the rule of `outputHash`, but the form does not include the field `hash` of the document.
  * With the default grid, it is the input hash of `docs/FORMAT.md` of `packing`.
+ * A document with the schema `layout-input/1` goes through `canonicalInput` first. Thus the order of its `pairGaps` does not change the hash.
  */
 export declare function documentHash(doc: object, options?: HashOptions): string;
 /** One output group: the candidates with the same output hash on each decision input. */
@@ -935,6 +985,12 @@ export interface MemberRule {
   readonly min: number;
   readonly max: number;
   readonly ordered: boolean;
+  /**
+   * The member lists that the option permits. Each entry is a list of whole configs of the space of the members.
+   * Without `pool`, each list of base configs with a good count is a member list.
+   * With `pool`, a config of the option has the members of one entry, and `spaceSize` counts each entry one time.
+   */
+  readonly pool?: readonly (readonly StrategyConfig[])[];
 }
 /** The inputs that an option supports. A missing field supports each value. */
 export interface OptionSupports {
@@ -1027,22 +1083,31 @@ export interface SampleOptions extends ShapeFilter {
   /** The count of the configs, a whole number of 0 or more. */
   readonly n: number;
   readonly seed: number;
-  /** With `skip` (the default), the sample has no meta option. With `sample`, a meta option draws its members from base samples. */
+  /** With `skip` (the default), the sample has no meta option. With `sample`, a meta option draws its members from base samples, or one entry of its `pool`. */
   readonly meta?: "skip" | "sample";
   /** The largest count of option draws. The default is the larger value of 1000 and `100 * n`. */
   readonly maxTries?: number;
 }
 /** The options of `enumerateSpace`. */
 export type EnumerateOptions = GridOptions | SampleOptions;
+/** This function gives the problem of a value of a param, or `undefined` for a value in its range. The corpus dimensions of `families.ts` use it. */
+export declare function paramProblem(param: SpaceParam, value: unknown): string | undefined;
+/** This function tells if a param is active for the values of the earlier params. A param without `when` is always active. */
+export declare function paramActive(param: SpaceParam, values: Readonly<Record<string, ParamValue>>): boolean;
+/** This function gives the stable form of a value of a param: a real number gets 12 significant digits, and `-0` becomes `0`. */
+export declare function paramValue(param: SpaceParam, value: ParamValue): ParamValue;
 /**
  * This function checks one config of a space. It gives one break for each problem. An empty list tells that the config is good.
  * The `claim` of a break is the kind of the problem, for example `missing`, `unknown`, `inactive`, `param`, `constraint`, `members` or `depth`.
+ *
+ * A member list that is not an entry of the `pool` of its option gives the claim `pool`.
  * With `shapes`, an option that does not support a kind of the list gives the claim `shape`. A member of a meta option gets the same check.
  */
 export declare function checkConfig(space: StrategySpace, config: StrategyConfig, options?: ShapeFilter): ClaimBreak[];
 /**
  * This function checks a space. It gives one break for each problem. An empty list tells that the space is good.
  * It finds duplicate names, empty ranges, defaults out of range, enums without values, bad log scales, unknown names and bad named configs.
+ * It also checks each entry of a `pool`: the count of its members, each member and a repeated entry.
  * The `inputs` of a break of a named config have the name of the config.
  */
 export declare function checkSpace(space: StrategySpace): ClaimBreak[];
@@ -1065,6 +1130,7 @@ export declare function paramLevels(param: SpaceParam, levels: number): ParamVal
 /**
  * This function gives the count of the grid points of a space, with `levels` levels for each numeric param.
  * It counts only the active params and the combinations that keep the constraints. It gives the meta configs apart.
+ * A meta option with a `pool` counts each entry of the pool one time.
  * With `shapes`, it counts only the options that support each kind of the list.
  */
 export declare function spaceSize(space: StrategySpace, options: SpaceSizeOptions): SpaceSize;
@@ -1075,6 +1141,7 @@ export declare function spaceSize(space: StrategySpace, options: SpaceSizeOption
  * - The mode `sample` gives `n` configs of a seeded Latin hypercube. The options of a stage get equal strata, and each active param gets its own strata.
  * - A sample draws again when a point breaks a constraint. After `maxTries` draws, it throws an `Error`. Two sampled configs can be equal.
  * - With `shapes`, only the options that support each kind of the list count. Without `shapes`, the result does not change.
+ * - A meta option with a `pool` gives only the entries of its pool. With `shapes`, only the entries whose members support each kind count.
  */
 export declare function enumerateSpace(space: StrategySpace, options: EnumerateOptions): StrategyConfig[];
 /**
@@ -1227,4 +1294,239 @@ export interface VerdictResult {
  * It throws a `RangeError` for a missing `tie` or `level`, and for no pair. Two records of one side and input, or a value that is not finite, also cause a `RangeError`.
  */
 export declare function verdict<R extends VerdictRecord>(records: Iterable<R>, options: VerdictOptions<R>): VerdictResult;
+/**
+ * One dimension of a corpus: a param of `strategy-space.ts` with its meaning and the engines that use it.
+ * The field `when` has the form of `SpaceParam.when`: the dimension is active only for some values of an earlier dimension.
+ */
+export interface CorpusDimension extends SpaceParam {
+  /** The meaning of the dimension, in one sentence. */
+  readonly meaning: string;
+  /** The engines that read the dimension, for example `packing`, `highways` and `joint`. */
+  readonly engines: readonly string[];
+  /** The values of a sweep. Without them, a sweep uses the values of an `enum`, `false` and `true` of a `bool`, or the default. */
+  readonly levels?: readonly ParamValue[];
+  /**
+   * The values that the family accepts. Without it, the family accepts each value of the dimension.
+   * A list is for an `enum` or a `bool`. A sub-range is for an `int` or a `real`.
+   * The default and each level are supported values. `resolve` and `generate` refuse a value that is not supported.
+   */
+  readonly supported?: SupportedValues;
+  /**
+   * The output fields that a value other than the default makes wrong, for example `known`.
+   * Then `generate` of a registry removes these fields from the output, and lists them in `invalidated`.
+   */
+  readonly invalidates?: readonly string[];
+}
+/**
+ * The supported values of a dimension (`CorpusDimension.supported`).
+ * The list form gives the values of an `enum` or a `bool`. The range form gives a sub-range of an `int` or a `real`.
+ * A range without `min` or `max` keeps that end of the dimension.
+ */
+export type SupportedValues = readonly ParamValue[] | SupportedRange;
+/** The range form of `SupportedValues`: the least and the largest supported value of a numeric dimension. */
+export interface SupportedRange {
+  readonly min?: number;
+  readonly max?: number;
+}
+/** The name of the output field that lists the fields that `generate` of a registry removed. */
+export declare const INVALIDATED_FIELD = "invalidated";
+/** The values of the dimensions of one input: one value for each name. */
+export type DimensionValues = Readonly<Record<string, ParamValue>>;
+/** A factory of seeded random numbers: it gives a source of numbers in [0, 1) for a seed. */
+export type RngFactory = (seed: number) => () => number;
+/**
+ * The cross-engine note of a family. `exact` tells that each JavaScript engine gives the same output.
+ * `libm-dependent` tells that the family uses a function that is not correctly rounded in each engine, for example `Math.log`, `Math.cos` or `**`.
+ */
+export type CrossEngine = "exact" | "libm-dependent";
+/** The random numbers of the default factory: `mulberry32` of `random.ts`. Its stream is pinned in `families.test.ts`. */
+export declare const DEFAULT_RNG: RngFactory;
+/** The context that a registry gives to `generate`. */
+export interface GenerateContext {
+  /** The random factory of the family: its own `rng`, or `DEFAULT_RNG`. */
+  readonly rng: RngFactory;
+  /** The source of random numbers of the input: `rng(rngSeed(seed, dims))`. A family that does not use it takes no numbers from it. */
+  readonly random: () => number;
+  /** The name of the corpus of the input, when the caller gives one. */
+  readonly set?: string;
+}
+/**
+ * A family of a corpus: a seeded generator with declared dimensions. The engine that owns it gives it to a registry.
+ * The registry gives `generate` the raw seed and the full dimension values.
+ * The registry changes the output only for a dimension with `invalidates` at a value other than its default.
+ */
+export interface CorpusFamily<O = LayoutInput> {
+  /** The name of the family, for example `rect-grid`. */
+  readonly name: string;
+  /** The version. A change of the output of the family needs a new version. A dimension of only some versions is in the list of those versions only. */
+  readonly version: number;
+  /** The engine that owns the definition of the family, for example `packing`. */
+  readonly owner: string;
+  /** The meaning of the family, in one sentence. */
+  readonly meaning: string;
+  /** The dimensions of the family, in their order. A dimension with `when` comes after the dimension that its `when` names. The name `kind` is reserved. */
+  readonly dimensions: readonly CorpusDimension[];
+  /** The text of the rule that gives the random numbers of an input from its seed and its dimensions. */
+  readonly seeding: string;
+  /** The cross-engine note of the family. */
+  readonly crossEngine: CrossEngine;
+  /** The random factory of the family. The default is `DEFAULT_RNG`. */
+  readonly rng?: RngFactory;
+  /** This function gives the seed of `context.random` from the input seed and the full dimension values. The default gives the input seed. */
+  readonly rngSeed?: (seed: number, dims: DimensionValues) => number;
+  /** The dimensions of the family key of `familyBy`, after the kind of the cell. A dimension with `when` is not permitted. The default is no dimension. */
+  readonly familyBy?: readonly string[];
+  /**
+   * This function gives the hash of an output after the registry removes the fields of `invalidates`. The default is `documentHash` of `hash.ts`.
+   * The registry uses it only for an output with a `hash` field of text. The registry gives it an output of the family.
+   * Its parameter has the type `never`, so a family of each output type can be a `CorpusFamily<unknown>`.
+   */
+  readonly hash?: (output: never) => string;
+  /** This function gives the input of a seed. `dims` has a value for each dimension, also for an inactive dimension. */
+  generate(seed: number, dims: DimensionValues, context: GenerateContext): O;
+}
+/** The options of `generate` of a registry. */
+export interface GenerateOptions {
+  /** The version of the family. The default is the first version that the registry got. */
+  readonly version?: number;
+  /** The name of the corpus. The registry gives it to the family in `context.set`. */
+  readonly set?: string;
+}
+/** The options of `cells` and `cellCount` of a registry. */
+export interface CellsOptions {
+  readonly version?: number;
+  /** The dimensions of the sweep. The other dimensions keep their defaults. The default is each dimension of the family. */
+  readonly sweep?: readonly string[];
+  /** The values of a sweep for some dimensions, in place of the levels of the dimensions. */
+  readonly levels?: Readonly<Record<string, readonly ParamValue[]>>;
+}
+/** The cell of an input of a registry: `<name>@<version>` of its family in `kind` (`familyKind`), and the value of each active dimension. */
+export type RegistryCell = Readonly<Record<string, ParamValue>> & {
+  readonly kind: string;
+};
+/** This function gives the `kind` of the cells of a version of a family: `<name>@<version>`, for example `rect-grid@2`. Thus two versions do not share a family key. */
+export declare function familyKind(name: string, version: number): string;
+/** A registry of families. An import registers nothing: a host makes a registry from the lists of families of the engines. */
+export interface FamilyRegistry<O = LayoutInput> {
+  /** This method adds a family. It throws a `RangeError` for a second family with the same name and version, or for a bad dimension. */
+  register(family: CorpusFamily<O>): FamilyRegistry<O>;
+  /** This method gives a family. Without a version, it gives the first version that the registry got. It throws a `RangeError` for an unknown family. */
+  family(name: string, version?: number): CorpusFamily<O>;
+  /** This method gives each family, in the order of registration. */
+  families(): readonly CorpusFamily<O>[];
+  /**
+   * This method gives the full dimension values of an input. It throws a `RangeError` for an unknown dimension, a bad value or a value that is not supported.
+   * The methods with `dims` accept a cell of `cellOf`: they ignore a `kind` that is the `familyKind` of the family, and refuse another `kind`.
+   */
+  resolve(name: string, dims?: Readonly<Record<string, ParamValue>>, version?: number): DimensionValues;
+  /**
+   * This method gives the input of a seed: the output of the family. A dimension with `invalidates` at a value other than its default changes it.
+   * Then the method removes those fields, adds their names to `invalidated` and calculates the `hash` again. Another output has no change.
+   */
+  generate(name: string, seed: number, dims?: Readonly<Record<string, ParamValue>>, options?: GenerateOptions): O;
+  /** This method gives the cell of an input: the `familyKind` of the family version and the value of each active dimension. */
+  cellOf(name: string, dims?: Readonly<Record<string, ParamValue>>, version?: number): RegistryCell;
+  /** This method gives the full dimension values of each cell of a sweep, without the dead combinations of `when`. */
+  cells(name: string, options?: CellsOptions): Generator<DimensionValues>;
+  /** This method gives the count of the cells of `cells`. It makes no input. */
+  cellCount(name: string, options?: CellsOptions): number;
+  /** This method gives the defaults, and each end of each numeric range. The dimensions that a `when` needs get its first value. The other dimensions keep their defaults. */
+  boundaryCells(name: string, version?: number): DimensionValues[];
+  /** This method gives the random source of an input: the stream that `generate` gets in `context.random`. */
+  rngOf(name: string, version?: number): (seed: number, dims?: Readonly<Record<string, ParamValue>>) => () => number;
+  /** This method gives the map form of `FamilyBy` for the cells of `cellOf`: the `familyKind` of each family version, with its own `familyBy`. */
+  familyBy(): FamilyBy;
+}
+/** The default key of a family in a manifest: the kind of the cell alone. It is the map form of `FamilyBy` with the entry `"*"`. */
+export declare const DEFAULT_FAMILY_BY: FamilyBy;
+/**
+ * The shared dimension table. A family takes a dimension of it with `sharedDimension`, or declares its own dimension.
+ * The coverage table of each dimension and each engine is in `docs/CORPUS.md`.
+ */
+export declare const CORPUS_DIMENSIONS: Readonly<Record<string, CorpusDimension>>;
+/**
+ * This function gives a dimension of `CORPUS_DIMENSIONS`, with the fields of `patch` over it. It throws a `RangeError` for an unknown name.
+ * With `supported` or `invalidates` in the patch, it also throws a `RangeError` for a bad dimension, as `ownerDimension` does.
+ */
+export declare function sharedDimension(name: string, patch?: Partial<CorpusDimension>): CorpusDimension;
+/** The fields of a dimension that the owner declares: each field of `CorpusDimension` but the name. */
+export type OwnerDimensionSpec = Omit<CorpusDimension, "name">;
+/**
+ * This function gives a dimension that only its owner declares, for example `cut` of a family of `packing`.
+ * It throws a `RangeError` for a name of `CORPUS_DIMENSIONS`, the reserved name `kind`, or a bad default, level, `supported` or `invalidates`.
+ * The registry examines the `when` of the dimension, because it needs the earlier dimensions.
+ */
+export declare function ownerDimension(name: string, spec: OwnerDimensionSpec): CorpusDimension;
+/**
+ * This function tells if a family accepts a value of a dimension. A site uses it to show the values that a family does not support.
+ * It gives `false` for a bad value, and for a value outside `supported`. Without `supported`, it gives `true` for each good value.
+ */
+export declare function dimensionSupports(dim: CorpusDimension, value: unknown): boolean;
+/**
+ * This function gives the value at the fraction `t` of the range of a numeric dimension, on its scale. A slider of a site uses it.
+ * A log scale with a `min` of 0 or less is the log of `1 + x - min`. An `int` dimension gives a whole number.
+ */
+export declare function dimensionAt(dim: SpaceParam, t: number): number;
+/** This function gives the fraction of the range of a numeric dimension at a value, on its scale. It is the inverse of `dimensionAt`. */
+export declare function dimensionUnit(dim: SpaceParam, value: number): number;
+/**
+ * This function gives the values of a sweep of a dimension. `levels` of the dimension come first. Then an `enum` gives its values, and a `bool` gives `false` and `true`.
+ * With `steps`, a numeric dimension gives `steps` points from `min` to `max` on its scale. Else it gives its default.
+ * With `supported`, an `enum` and a `bool` give only the supported values, and the points of a numeric dimension stay in the supported range.
+ */
+export declare function levelsOf(dim: CorpusDimension, steps?: number): ParamValue[];
+/**
+ * This function gives the full dimension values of an input. A missing dimension gets its default. An inactive dimension of `when` also gets its default.
+ * Thus a default that the caller gives, a missing value and an inactive value give the same values. A real number gets its stable form.
+ *
+ * The function throws a `RangeError` for an unknown dimension or a bad value, also for a bad value of an inactive dimension.
+ * It also throws a `RangeError` for a value outside `supported`, with the text "not supported by" and `by`.
+ */
+export declare function resolveDimensions(dimensions: readonly CorpusDimension[], dims?: Readonly<Record<string, ParamValue>>, where?: string, by?: string): DimensionValues;
+/** This function gives a new registry with the families of the list. Each engine gives the list of its families. An import registers nothing. */
+export declare function createFamilyRegistry<O = LayoutInput>(families?: Iterable<CorpusFamily<O>>): FamilyRegistry<O>;
+/** A step of a composed family: a pure function that changes an input after its base family, as `edgeStep` does. */
+export interface CorpusStep {
+  readonly name: string;
+  readonly version: number;
+  /** The engine that owns the definition of the step. */
+  readonly owner: string;
+  readonly meaning: string;
+  /** The dimensions of the step. Their names are not names of the dimensions of the base family. */
+  readonly dimensions: readonly CorpusDimension[];
+  /** The text of the rule that gives the random numbers of the step from the seed. */
+  readonly seeding: string;
+  readonly crossEngine: CrossEngine;
+  /** This function gives the part of the family of the input that tells the values of the step. Without it, the family does not change. */
+  readonly familyPart?: (dims: DimensionValues) => string;
+  /** This function gives the changed input. It removes the old `hash` of the input. */
+  apply(input: LayoutInput, seed: number, dims: DimensionValues): LayoutInput;
+}
+/** The options of `composeFamily`. */
+export interface ComposeOptions {
+  /** The default is the name of the base family and the names of the steps, with `+` between them. */
+  readonly name?: string;
+  /** The default is the owner of the base family. */
+  readonly owner?: string;
+  readonly meaning?: string;
+  /** The hash of the composed input. The default is `documentHash` of `hash.ts`. The composed family also gives it to the registry in `hash`. */
+  readonly hash?: (input: LayoutInput) => string;
+}
+/**
+ * This function gives a family that runs the base family and then each step, with the same seed.
+ * The family of the input gets the part of each step after a dot. The id becomes `<set>/<family>/s<seed>`, and the input gets the hash of `options.hash`.
+ * The function throws a `RangeError` when a step has a dimension with the name of an earlier dimension.
+ */
+export declare function composeFamily(base: CorpusFamily<LayoutInput>, steps: readonly CorpusStep[], options?: ComposeOptions): CorpusFamily<LayoutInput>;
+/**
+ * The step `edges` of `edgeStep` (version 1), as a corpus step. Its family part is `e-<edgeDensity>.<edgeShape>.<groups>.<ports>`.
+ * The value `random` of `hubBy` adds the part `.hub-random`.
+ */
+export declare const EDGES_STEP: CorpusStep;
+/**
+ * The shared family `rect-scattered`, version 1: a fixed rectangle container, rectangle obstacles at random places and boxes without positions.
+ * It is the one copy of the generator of `docs/FORMAT.md` of `packing`. Its input is the input of `packing`, byte for byte.
+ * The steps `container`, `obstacles` and `boxes` each have a stream of `stepRandom`. Each value is a whole number, so the family is `exact`.
+ */
+export declare const RECT_SCATTERED: CorpusFamily<LayoutInput>;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/corpus.ts","../src/input.ts","../src/shapes.ts","../src/tolerance.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts","../src/hash.ts","../src/portfolio.ts","../src/strategy-space.ts","../src/verdict.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/corpus.ts","../src/input.ts","../src/shapes.ts","../src/tolerance.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts","../src/hash.ts","../src/portfolio.ts","../src/strategy-space.ts","../src/verdict.ts","../src/families.ts"],"mappings":"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"}