@mark1russell7/layout-contract 0.2.14 → 0.2.16

package/README.md

@@ -8,9 +8,9 @@ The package has no runtime dependencies.
 
 | Part | Exports |
 |---|---|
-| 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`, `PairGap`, `canonicalInput` |
+| Geometry | `Point`, `Rect`, `Region`, `Side`, `Sides`, `Margin`, `marginSides`, `grow`, `boundsOf`, `regionArea`, `translate`, `overlapOf` |
+| The shape kinds | `ShapeKind`, `SHAPE_KINDS`, `SHAPE_KIND_IDS`, `ShapeKindSpec`, `ShapeGeometry`, `DEFAULT_SHAPES`, `ShapeSupport`, `RuleLevel`, `ShapeCheck`, `isShapeKind`, `shapeKindOf`, `shapeKindsOf`, `itemShapeOf`, `shapeKindProblem`, `shapesOf`, `ruleLevel`, `shapeSupportProblems`, `boxArea`, `checkShapes` |
+| 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` |
@@ -44,10 +44,22 @@ The package has no runtime dependencies.
   - 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.
+  - 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.
+  - `regionArea(region)` gives the exact area of a region. `boxArea(box)` gives the exact area of a box, or `undefined` for a `free` box. A box with an ellipse shape is `free`.
+  - `ShapeSupport.safe` lists the kinds with a safe count: an upper bound that does not miss a break. `ruleLevel(rule, kind)` gives `exact`, `safe` or `none`.
+  - `no-overlap` and `in-container` are safe on `polygon`, `circle` and `free`. `checkShapes` accepts a safe kind only with `{ level: "safe" }`.
+  - `shapeSupportProblems(uses)` refuses a kind in `shapes` and in `safe`.
+  - `MemberRule.view: "bounds"` gives the members of a meta option the bounding box of each item. A shape filter then checks the members with `rect`.
+- **The corpus dimensions.** `CorpusDimension.precision` is the count of decimal places of a numeric value of a family. The registry rounds the value and the default to it before the `invalidates` compare. `docs/CORPUS.md` tells the rules.
 - **The output hash.** `outputHash` gives the first 16 hex characters of the SHA-256 of the canonical JSON of an output. Each number goes to the grid of `RECORD_EPS` first.
 - **The corpus checks.** `checkDeclared` and `checkSplit` give a list of `ClaimBreak`. An empty list tells that each claim is true. `corpusHashOf` gives the corpus hash of `packing`.
 - **The verdict.** `verdict` compares two strategies on one measure, with the family as the unit. A verdict counts only when it holds for the mean of the family means and for the mean of the inputs.

package/build/index.d.ts

@@ -54,6 +54,11 @@ export declare function marginSides(margin: Margin | undefined): Sides;
 export declare function grow(rect: Rect, margin: Margin | undefined): Rect;
 /** This function gives the bounding box of a region. */
 export declare function boundsOf(region: Region): Rect;
+/**
+ * This function gives the exact area of a region. A `rect` gives `w` by `h`, a circle gives `PI * r * r`, and an ellipse gives `PI * rx * ry`.
+ * A polygon gives the absolute value of the shoelace formula, less the area of each hole. A ring with fewer than 3 points has the area 0.
+ */
+export declare function regionArea(region: Region): number;
 /** This function gives the region moved by `dx` and `dy`. */
 export declare function translate(region: Region, dx: number, dy: number): Region;
 /**
@@ -189,14 +194,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;
@@ -326,6 +344,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 {
@@ -352,7 +375,7 @@ export type ShapeKind = "rect" | "polygon" | "circle" | "free";
 export interface ShapeGeometry {
   /** The bounding box: `boundsOf` and `placedRect`. */
   readonly bounds: boolean;
-  /** The area of the shape. */
+  /** The area of the shape: `regionArea` and `boxArea`. */
   readonly area: boolean;
   /** The test that the shape is inside a region: `rectInRegion` for a `rect`. */
   readonly contains: boolean;
@@ -368,7 +391,10 @@ export interface ShapeKindSpec {
   readonly regions: readonly Region["kind"][];
   readonly geometry: ShapeGeometry;
 }
-/** The declared shape kinds, in their order. Only `rect` has all of its geometry. The other kinds have their bounding box only. */
+/**
+ * The declared shape kinds, in their order. Only `rect` has all of its geometry.
+ * `polygon` and `circle` have their bounding box and their exact area. `free` has its bounding box only.
+ */
 export declare const SHAPE_KINDS: readonly ShapeKindSpec[];
 /** The ids of `SHAPE_KINDS`, in their order. */
 export declare const SHAPE_KIND_IDS: readonly ShapeKind[];
@@ -377,8 +403,23 @@ export declare const DEFAULT_SHAPES: readonly ShapeKind[];
 /** A measure or a rule, with the shape kinds that it supports. Without `shapes`, it supports `DEFAULT_SHAPES`. */
 export interface ShapeSupport<Id extends string = string> {
   readonly id: Id;
+  /** The kinds with an exact count or value. */
   readonly shapes?: readonly ShapeKind[];
+  /**
+   * The kinds with a safe count: the rule can count a break that is not real, but it does not miss a real break.
+   * Thus a safe count of 0 tells that the rule has no break. A kind is in `shapes` or in `safe`, not in the two lists.
+   */
+  readonly safe?: readonly ShapeKind[];
 }
+/** The level of a rule on a shape kind: an exact count, a safe count (an upper bound), or no support. */
+export type RuleLevel = "exact" | "safe" | "none";
+/** This function gives the level of a rule on a shape kind. A kind of `shapesOf` is `exact`, a kind of `safe` is `safe`, and another kind is `none`. */
+export declare function ruleLevel(rule: Pick<ShapeSupport, "shapes" | "safe">, kind: ShapeKind): RuleLevel;
+/**
+ * This function gives the problems of a list of measures and rules. An empty list tells that the list is good.
+ * It refuses an unknown kind, a kind two times in one list, and a kind in `safe` that is also in `shapesOf`.
+ */
+export declare function shapeSupportProblems(uses: readonly ShapeSupport[]): string[];
 /** This function tells if a value is a declared shape kind. */
 export declare function isShapeKind(value: unknown): value is ShapeKind;
 /**
@@ -386,6 +427,13 @@ export declare function isShapeKind(value: unknown): value is ShapeKind;
  * Without it, the kind comes from `shape`: no shape is a `rect`, and an ellipse is `free`.
  */
 export declare function shapeKindOf(box: LayoutBox): ShapeKind;
+/**
+ * This function gives the exact area of a box, or `undefined` when the contract knows only its bounding box.
+ * A box with `shape` gives `regionArea` of the shape. A `rect` box without `shape` gives `w` by `h`.
+ * A box of the kind `free` gives `undefined`, also with a shape. Thus a box with an ellipse shape gives `undefined`, because `shapeKindOf` makes an ellipse `free`.
+ * A box of another kind without `shape` is a bad input, and gives `undefined`.
+ */
+export declare function boxArea(box: LayoutBox): number | undefined;
 /** This function gives the shape kinds of the boxes of an input, in the order of `SHAPE_KINDS`. An input without boxes gives an empty list. */
 export declare function shapeKindsOf(input: Pick<LayoutInput, "boxes">): ShapeKind[];
 /** This function gives the value of the cell dimension `itemShape` of an input: its one kind, `mixed` for more kinds, or `rect` without boxes. */
@@ -394,11 +442,20 @@ export declare function itemShapeOf(input: Pick<LayoutInput, "boxes">): ShapeKin
 export declare function shapeKindProblem(box: LayoutBox): string | undefined;
 /** This function gives the shape kinds that a measure or a rule supports. */
 export declare function shapesOf(use: Pick<ShapeSupport, "shapes">): readonly ShapeKind[];
+/** The options of `checkShapes`. */
+export interface ShapeCheck {
+  /**
+   * The lowest level of a rule that `checkShapes` accepts. The default `exact` refuses a kind with only a safe count.
+   * The value `safe` also accepts a kind of `safe`. Use it only when the run claims that a rule has no break.
+   */
+  readonly level?: "exact" | "safe";
+}
 /**
  * This function checks that each measure and each rule of a run supports each shape kind of the input. An empty list tells that the run is good.
  * Each break has the claim `shape`, the id of the input, and the first 5 ids of the boxes of the kind.
+ * By default, a kind of `safe` is a break, because the count of the rule is not exact. With the level `safe`, it is not a break.
  */
-export declare function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[]): ClaimBreak[];
+export declare function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[], options?: ShapeCheck): ClaimBreak[];
 /** The epsilon for the float compares in an engine. */
 export declare const EPS = 1e-6;
 /**
@@ -572,6 +629,7 @@ export interface PackHard {
 /**
  * The hard rules of a pack, with the shape kinds that each rule supports.
  * `no-overlap` and `in-container` test the bounding box of a shape. That count is exact only for a `rect`.
+ * For the other kinds, the count is safe: a shape is inside its bounding box, so the count is an upper bound. A count of 0 tells that the rule has no break.
  * `locked-kept` and `complete` read only the positions and the ids, so they support each kind.
  */
 export declare const PACK_HARD_RULES: readonly ShapeSupport<keyof PackHard>[];
@@ -603,13 +661,18 @@ 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;
@@ -968,6 +1031,11 @@ export interface MemberRule {
    * 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 view of the items that the members get. With `bounds`, the option gives its members the bounding box of each item.
+   * Then a shape filter checks the members with the kind `rect`, and the option itself with the kinds of the input. Without `view`, the members get the kinds of the input.
+   */
+  readonly view?: "bounds";
 }
 /** The inputs that an option supports. A missing field supports each value. */
 export interface OptionSupports {
@@ -1079,6 +1147,7 @@ export declare function paramValue(param: SpaceParam, value: ParamValue): ParamV
  *
  * 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.
+ * A member of an option with `view: "bounds"` gets the check with the kind `rect`.
  */
 export declare function checkConfig(space: StrategySpace, config: StrategyConfig, options?: ShapeFilter): ClaimBreak[];
 /**
@@ -1282,7 +1351,37 @@ export interface CorpusDimension extends SpaceParam {
   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 count of decimal places that the family uses for a value of a numeric dimension: a whole number of 0 or more.
+   * Only the `invalidates` compare reads it. The registry rounds the value and the default to it before the compare.
+   * The cells, the cell keys, `rngOf` and the value that `generate` gets do not change.
+   */
+  readonly precision?: number;
+}
+/**
+ * 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. */
@@ -1305,7 +1404,8 @@ export interface GenerateContext {
 }
 /**
  * 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. It does not change the output, and it does not calculate a hash.
+ * 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`. */
@@ -1328,6 +1428,12 @@ export interface CorpusFamily<O = LayoutInput> {
   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;
 }
@@ -1361,11 +1467,14 @@ export interface FamilyRegistry<O = LayoutInput> {
   /** 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 or a bad value.
+   * 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 is the output of the family, with no change. */
+  /**
+   * 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;
@@ -1387,8 +1496,24 @@ export declare const DEFAULT_FAMILY_BY: FamilyBy;
  * 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. */
+/**
+ * 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`, `invalidates` or `precision` 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`, `invalidates` or `precision`.
+ * 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.
@@ -1399,14 +1524,17 @@ 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): DimensionValues;
+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. */
@@ -1433,7 +1561,7 @@ export interface ComposeOptions {
   /** 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 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;
 }
 /**

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","../src/families.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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"}