@mark1russell7/layout-contract 0.2.11 → 0.2.13

package/README.md

@@ -9,6 +9,7 @@ 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` |
 | The packer | `PackInput`, `toPackInput`, `Placement`, `PackOutput`, `StageTrace`, `applyPack` |
 | The record `layout-record/1` | `LayoutRecord`, `Stage`, `Supports`, `RunFacts`, `RunEnv`, `toLayoutRecord` |
@@ -22,13 +23,13 @@ The package has no runtime dependencies.
 | The pick rule | `selectBest`, `SelectCandidate`, `SelectLevel`, `Selection`, `PickSpec` |
 | The corpus checks | `ClaimBreak`, `checkDeclared`, `declaredCounts`, `declaredClaimOf`, `DeclaredClaim`, `Declares`, `corpusHashOf`, `CorpusEntry` |
 | The families | `familyOf`, `FamilyBy`, `FamilyCell`, `FAMILY_ANY_KIND` |
-| The verdict | `verdict`, `VerdictOptions`, `VerdictResult`, `VerdictRecord`, `VerdictSide`, `VerdictInterval`, `FamilyVerdict`, `VerdictPermutation`, `VerdictSignTest`, `VerdictLabel`, `VERDICT_EXACT_MAX`, `VERDICT_EXACT_CAP`, `VERDICT_RUNS`, `VERDICT_DRAWS`, `VERDICT_SEED` |
+| The verdict | `verdict`, `VerdictOptions`, `VerdictResult`, `VerdictRecord`, `VerdictSide`, `VerdictInterval`, `FamilyVerdict`, `VerdictPermutation`, `VerdictSignTest`, `VerdictLabel`, `VerdictScope`, `VerdictBreadth`, `VERDICT_EXACT_MAX`, `VERDICT_EXACT_CAP`, `VERDICT_RUNS`, `VERDICT_DRAWS`, `VERDICT_SEED` |
 | The split files | `checkSplit`, `splitFolds`, `leaveOneSeedOut`, `splitFileName`, `SPLIT_SCHEMA`, `CorpusSplit`, `SplitFold`, `SplitCorpus` |
-| The strategy space | `StrategySpace`, `SpaceStage`, `StageOption`, `SpaceParam`, `ParamWhen`, `MemberRule`, `SpaceConstraint`, `OptionRef`, `StrategyConfig`, `StageChoice`, `ParamKind`, `ParamValue`, `STRATEGY_SPACE_SCHEMA` |
-| The space functions | `checkSpace`, `checkConfig`, `canonicalConfig`, `configId`, `spaceSize`, `paramLevels`, `enumerateSpace`, `productSpace`, `joinConfigs`, `splitConfig`, `SpaceSize`, `SpaceSizeOptions`, `EnumerateOptions`, `GridOptions`, `SampleOptions` |
+| The strategy space | `StrategySpace`, `SpaceStage`, `StageOption`, `OptionSupports`, `ShapeFilter`, `SpaceParam`, `ParamWhen`, `MemberRule`, `SpaceConstraint`, `OptionRef`, `StrategyConfig`, `StageChoice`, `ParamKind`, `ParamValue`, `STRATEGY_SPACE_SCHEMA` |
+| The space functions | `checkSpace`, `checkConfig`, `canonicalConfig`, `configId`, `spaceSize`, `spaceShapeKinds`, `paramLevels`, `enumerateSpace`, `productSpace`, `joinConfigs`, `splitConfig`, `SpaceSize`, `SpaceSizeOptions`, `EnumerateOptions`, `GridOptions`, `SampleOptions` |
 | The turn | `turnBox`, `turnPort`, `turnMargin`, `turnRegion`, `turnSide`, `turnPoint` |
 | The tolerances | `EPS`, `RECORD_EPS`, `RECORD_SCALE`, `Tolerance`, `DEFAULT_TOLERANCE` |
-| The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `rectInRegion`, `countOutside`, `ContainerTest`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
+| The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `rectInRegion`, `countOutside`, `ContainerTest`, `countPortsOffBorder`, `packHard`, `PackHard`, `PACK_HARD_RULES`, `placedRect`, `checkInput` |
 
 ## The rules
 
@@ -39,6 +40,7 @@ The package has no runtime dependencies.
 - **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`.
 - **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.
 - **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

@@ -64,33 +64,128 @@ export declare function overlapOf(a: Rect, b: Rect): {
   readonly x: number;
   readonly y: number;
 };
-/** The epsilon for the float compares in an engine. */
-export declare const EPS = 1e-6;
+/** One broken claim of a corpus, with the ids of the inputs that break it. */
+export interface ClaimBreak {
+  /** The name of the claim, for example `declared`, `split` or `index`. */
+  readonly claim: string;
+  /** The text of the break. */
+  readonly detail: string;
+  /** The ids of the inputs that break the claim. The list is empty when the break has no input. */
+  readonly inputs: readonly string[];
+}
+/** The claim `claims.declared` of a manifest: the count of the inputs for each declared property. */
+export interface DeclaredClaim {
+  /** A property with fewer inputs than this count is thin. */
+  readonly minCount: number;
+  /** The ids of the properties with a count below `minCount`. */
+  readonly thin: readonly string[];
+  /** The count of the inputs for each property id. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** The key of the family of an input. `familyOf` gives the key of one cell. The family is the unit of a verdict. */
+  readonly familyBy?: FamilyBy;
+  /** The minimum count of the inputs of each family. Without it, `checkDeclared` does not count the families. */
+  readonly familyMin?: number;
+}
 /**
- * The count of grid steps in one unit of a written file. A file rounds each number `v` to `Math.round(v * RECORD_SCALE) / RECORD_SCALE`.
- * Use a multiplication by this value, not a division by `RECORD_EPS`. The two differ at some half steps.
+ * The key of the family of a cell (`docs/CORPUS-CHECKS.md`).
+ *
+ * - The flat form is a list of dimensions. The key is the values of these dimensions of the cell, in order, with `/` between them.
+ * - The map form chooses an entry by the field `kind` of the cell, or the entry `"*"`. The key is the kind, then the values of the dimensions of the entry.
  */
-export declare const RECORD_SCALE = 1e3;
+export type FamilyBy = readonly string[] | {
+  readonly [kind: string]: readonly string[];
+};
+/** A cell of an input: one value for each dimension. The map form of `FamilyBy` also reads the field `kind`. */
+export type FamilyCell = Readonly<Record<string, unknown>>;
+/** The entry of the map form of `FamilyBy` for each kind without its own entry. */
+export declare const FAMILY_ANY_KIND = "*";
 /**
- * The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,
- * so a difference of two values can move by up to 0.001. It is `1 / RECORD_SCALE`.
+ * This function gives the family key of a cell. It throws a `RangeError` when the cell does not have a dimension of the key.
+ * In the map form, it also throws for a cell without `kind`, and for a kind with no entry and no entry `"*"`.
+ * For example, `{ "rect-grid": ["obstacles"], "*": [] }` gives `rect-grid/wall` for a `rect-grid` cell and `gallery` for a `gallery` cell.
  */
-export declare const RECORD_EPS = .001;
+export declare function familyOf(cell: FamilyCell, familyBy: FamilyBy): string;
+/** The hook that gives the ids of the properties that one input declares. */
+export type Declares<I> = (input: I) => readonly string[];
 /**
- * The tolerance of each hard rule, in layout units. A record writes the tolerance that its run used,
- * in its field `tolerance`, next to `hard`.
+ * This function gives the count of the inputs for each property id. Each id of `ids` has a count, also when the count is 0.
+ * An id from `declares` that is not in `ids` comes after the ids of `ids`, in the order of the first input that declares it.
  */
-export interface Tolerance {
-  /** Two boxes with their margins break `no-overlap` when their insides overlap by more than this on each axis. */
-  readonly overlap: number;
-  /** A route breaks `no-pass-through` when a part longer than this is inside a box made this much smaller. */
-  readonly through: number;
+export declare function declaredCounts<I>(inputs: Iterable<I>, declares: Declares<I>, ids?: readonly string[]): Record<string, number>;
+/**
+ * This function reads the field `claims.declared` of a manifest. A manifest without it gives `undefined`.
+ * It throws an `Error` for a claim without a whole `minCount`, a list `thin` of ids and a whole count for each id.
+ */
+export declare function declaredClaimOf(manifest: object): DeclaredClaim | undefined;
+/**
+ * This function checks the claim `claims.declared` against the inputs. It gives one break `declared` for each problem. An empty list tells that the claim is true.
+ *
+ * - `ids` are the property ids. The default is the ids of `claim.counts`.
+ * - Each id of `ids` has a count in `claim.counts`, and `claim.counts` has no other id. Each count is the count of the inputs.
+ * - An id with a count below `minCount` is in `thin`. Each id of `thin` is an id of `ids`.
+ * - Each id that `declares` gives is an id of `ids`.
+ *
+ * With `claim.familyBy`, the hook `cellOf` gives the cell of each input. The default reads the field `cell` of the input.
+ *
+ * - Each cell has each dimension of its key. In the map form, each cell has a `kind`, and the kind has an entry or the entry `"*"` is there.
+ * - Two cells with different dimension values do not give the same key.
+ * - With `claim.familyMin`, each family has `familyMin` inputs or more.
+ */
+export declare function checkDeclared<I>(inputs: Iterable<I>, declares: Declares<I>, claim: DeclaredClaim, ids?: readonly string[], cellOf?: (input: I) => FamilyCell | undefined): ClaimBreak[];
+/** The id and the hash of one input of a corpus. */
+export interface CorpusEntry {
+  readonly id: string;
+  readonly hash: string;
 }
 /**
- * The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.
- * Routes are sampled curves that follow the margin line, so `through` is larger.
+ * This function gives the hash of a corpus: the first 16 hex characters of a SHA-256. The text of the SHA-256 is `canonicalJson`
+ * of the corpus id and the `[id, hash]` of each input, in the order of the manifest. A change of one input changes the hash.
  */
-export declare const DEFAULT_TOLERANCE: Tolerance;
+export declare function corpusHashOf(corpus: string, inputs: readonly CorpusEntry[]): string;
+/** The schema of a split file. */
+export declare const SPLIT_SCHEMA = "corpus-split/1";
+/** One fold of a split: the seeds that fit a selector and the seeds that score it. */
+export interface SplitFold {
+  readonly train: readonly number[];
+  readonly heldOut: readonly number[];
+}
+/** A split file `corpus-split/1`. Its name is `<corpus id>.<corpus hash>.json`. It is beside the corpus, so the corpus does not change. */
+export interface CorpusSplit {
+  readonly schema: typeof SPLIT_SCHEMA;
+  readonly corpus: string;
+  /** The hash of the corpus: `corpusHashOf` of its manifest. */
+  readonly corpusHash: string;
+  /** The splits by name. Each split has one fold or more. */
+  readonly splits: Readonly<Record<string, {
+    readonly folds: readonly SplitFold[];
+  }>>;
+}
+/** The fields of a manifest that the split check reads. */
+export interface SplitCorpus {
+  readonly corpus: string;
+  readonly specs: readonly {
+    readonly seeds: readonly number[];
+  }[];
+  readonly inputs: readonly CorpusEntry[];
+}
+/** This function gives the name of the split file of a corpus. */
+export declare function splitFileName(corpus: string, hash: string): string;
+/**
+ * This function checks a split file against a manifest. It gives one break `split` for each problem. An empty list tells that the file is good.
+ *
+ * - The schema is `corpus-split/1`, the corpus is the id of the manifest and `corpusHash` is `corpusHashOf` of the manifest.
+ * - Each split has one fold or more. In each fold, `train` and `heldOut` are lists of seeds, not empty and with no common seed.
+ * - Each seed is a seed of a spec of the manifest.
+ * - With `name`, the file has the split `name`.
+ */
+export declare function checkSplit(split: unknown, corpus: SplitCorpus, name?: string): ClaimBreak[];
+/**
+ * This function gives a copy of the folds of the split `name` of a split file. `where` names the file in the text of an error.
+ * It throws an `Error` for each problem of `checkSplit`, and then for an unknown split name.
+ */
+export declare function splitFolds(split: unknown, corpus: SplitCorpus, name: string, where?: string): SplitFold[];
+/** This function gives the folds that hold out one seed each, in the order of the seeds. Each fold trains on the other seeds. */
+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.
@@ -118,6 +213,11 @@ export interface LayoutBox {
   readonly group?: string;
   /** A region relative to the origin of the box. Without it, the box is the rectangle `w` by `h`. */
   readonly shape?: Region;
+  /**
+   * The shape kind of the box (`docs/SHAPES.md`). Without it, `shapeKindOf` gives the kind of `shape`, or `rect` without a shape.
+   * The kind `free` tells that the contract knows only the bounding box `w` by `h`.
+   */
+  readonly shapeKind?: ShapeKind;
   readonly ports?: readonly Port[];
   /** A ring around the box. No other box enters it. Only a route from a port of the box enters it, at a right angle. */
   readonly margin?: Margin;
@@ -178,6 +278,8 @@ export interface LayoutCell {
   readonly edgeShape?: "random" | "clustered" | "hubChain" | "longRange" | "tree" | "bundled";
   readonly groups?: "none" | "flat" | "nested";
   readonly ports?: "free" | "sides" | "fixed";
+  /** The shape kinds of the boxes: one kind, or `mixed` for more kinds. Without it, each box is a `rect`. `itemShapeOf` gives the value. */
+  readonly itemShape?: ShapeKind | "mixed";
 }
 /** An input of the corpus: the format `layout-input/1`. */
 export interface LayoutInput {
@@ -220,6 +322,89 @@ export interface PackInput {
 }
 /** 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;
+/**
+ * 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.
+ */
+export type ShapeKind = "rect" | "polygon" | "circle" | "free";
+/** The geometry of a shape kind that this package gives. A `false` value tells that the kind declares the operation, but this package does not supply it. */
+export interface ShapeGeometry {
+  /** The bounding box: `boundsOf` and `placedRect`. */
+  readonly bounds: boolean;
+  /** The area of the shape. */
+  readonly area: boolean;
+  /** The test that the shape is inside a region: `rectInRegion` for a `rect`. */
+  readonly contains: boolean;
+  /** The test that two shapes overlap: `overlapOf` for two `rect` shapes. */
+  readonly overlap: boolean;
+}
+/** The facts of one shape kind: its fields, the kinds of `Region` that give it, and its geometry. */
+export interface ShapeKindSpec {
+  readonly id: ShapeKind;
+  /** The fields of the outline, relative to the top-left corner of the box. A name with `?` is optional. */
+  readonly fields: readonly string[];
+  /** The kinds of `LayoutBox.shape` that agree with this kind. */
+  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. */
+export declare const SHAPE_KINDS: readonly ShapeKindSpec[];
+/** The ids of `SHAPE_KINDS`, in their order. */
+export declare const SHAPE_KIND_IDS: readonly ShapeKind[];
+/** The shape kinds of a measure or a rule without `shapes`. The contract measured only rectangles before L46. */
+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;
+  readonly shapes?: readonly ShapeKind[];
+}
+/** This function tells if a value is a declared shape kind. */
+export declare function isShapeKind(value: unknown): value is ShapeKind;
+/**
+ * This function gives the shape kind of a box. A box with `shapeKind` has that kind.
+ * 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 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. */
+export declare function itemShapeOf(input: Pick<LayoutInput, "boxes">): ShapeKind | "mixed";
+/** This function gives the problem of the shape kind of a box, or `undefined` when `shapeKind` and `shape` agree. */
+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[];
+/**
+ * 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.
+ */
+export declare function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[]): ClaimBreak[];
+/** The epsilon for the float compares in an engine. */
+export declare const EPS = 1e-6;
+/**
+ * The count of grid steps in one unit of a written file. A file rounds each number `v` to `Math.round(v * RECORD_SCALE) / RECORD_SCALE`.
+ * Use a multiplication by this value, not a division by `RECORD_EPS`. The two differ at some half steps.
+ */
+export declare const RECORD_SCALE = 1e3;
+/**
+ * The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,
+ * so a difference of two values can move by up to 0.001. It is `1 / RECORD_SCALE`.
+ */
+export declare const RECORD_EPS = .001;
+/**
+ * The tolerance of each hard rule, in layout units. A record writes the tolerance that its run used,
+ * in its field `tolerance`, next to `hard`.
+ */
+export interface Tolerance {
+  /** Two boxes with their margins break `no-overlap` when their insides overlap by more than this on each axis. */
+  readonly overlap: number;
+  /** A route breaks `no-pass-through` when a part longer than this is inside a box made this much smaller. */
+  readonly through: number;
+}
+/**
+ * The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.
+ * Routes are sampled curves that follow the margin line, so `through` is larger.
+ */
+export declare const DEFAULT_TOLERANCE: Tolerance;
 /** The position of one item. `turn` is 90 when the packer turned a turnable item. */
 export interface Placement {
   readonly id: string;
@@ -276,6 +461,8 @@ export interface LayoutRecord {
   readonly seed: number;
   readonly nodes: number;
   readonly edges: number;
+  /** The shape kinds of the boxes of the input, in the order of `SHAPE_KINDS`. Without it, each box is a `rect`. */
+  readonly shapes?: readonly ShapeKind[];
   /** The value of each measure, by its name: `pack.*`, `route.*` or `joint.*`. */
   readonly measures: Readonly<Record<string, number>>;
   /** The count of the breaks of each hard rule. A good run has 0 for each rule. */
@@ -319,8 +506,11 @@ export interface RunEnv {
   readonly cpus: number;
 }
 /** The facts of a run that the input does not give. */
-export type RunFacts = Omit<LayoutRecord, "schema" | "input" | "inputHash" | "set" | "nodes" | "edges">;
-/** This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges. */
+export type RunFacts = Omit<LayoutRecord, "schema" | "input" | "inputHash" | "set" | "nodes" | "edges" | "shapes">;
+/**
+ * This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges.
+ * The input also gives `shapes`. An input with only `rect` boxes gets no `shapes`, so its record does not change.
+ */
 export declare function toLayoutRecord(input: LayoutInput, run: RunFacts): LayoutRecord;
 /** This function gives the area of a placed box: its shape or its rectangle, at its position. A box without a position gives `undefined`. */
 export declare function placedRect(box: LayoutBox): Rect | undefined;
@@ -355,6 +545,12 @@ export interface PackHard {
   readonly "locked-kept": number;
   readonly complete: number;
 }
+/**
+ * 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`.
+ * `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>[];
 /** This function tells if the inside of `region` and the inside of `rect` have a common point. */
 export declare function regionHitsRect(region: Region, rect: Rect): boolean;
 /**
@@ -425,10 +621,15 @@ export interface MeasureSpec<Id extends string = string> {
   };
   /** The role of the measure in the joint selector. */
   readonly role?: "guard" | "change-guard" | "diagnostic" | "time";
+  /** The shape kinds of the boxes that the measure supports. Without it, the measure supports only `rect`. `checkShapes` refuses the other kinds. */
+  readonly shapes?: readonly ShapeKind[];
 }
 /** The id of a joint measure. `docs/JOINT-MEASURES.md` gives the definitions. */
 export type JointMeasureId = "joint.fill" | "joint.aspectError" | "joint.spill" | "joint.straight.crossings" | "joint.straight.length" | "joint.stability.mean" | "joint.stability.moved" | "joint.proxy.rank" | "joint.ms";
-/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */
+/**
+ * The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`.
+ * `joint.fill` and `joint.straight.length` read the area of each box, so they support only `rect`. `docs/SHAPES.md` tells the reasons.
+ */
 export declare const JOINT_MEASURES: readonly MeasureSpec<JointMeasureId>[];
 /** The threshold of `joint.stability.moved`, in widths `W` of the base. */
 export declare const JOINT_MOVED_MIN = .01;
@@ -697,128 +898,6 @@ export declare function pickMoves(trace: Pick<PortfolioTrace, "picked">): {
  * It also throws a `RangeError` for an empty list of members, or for two members with the same id.
  */
 export declare function portfolio<I, O>(id: string, members: readonly Member<I, O>[] | ((input: I) => readonly Member<I, O>[]), key: PortfolioKey<I, O>, options?: PortfolioOptions): Portfolio<I, O>;
-/** One broken claim of a corpus, with the ids of the inputs that break it. */
-export interface ClaimBreak {
-  /** The name of the claim, for example `declared`, `split` or `index`. */
-  readonly claim: string;
-  /** The text of the break. */
-  readonly detail: string;
-  /** The ids of the inputs that break the claim. The list is empty when the break has no input. */
-  readonly inputs: readonly string[];
-}
-/** The claim `claims.declared` of a manifest: the count of the inputs for each declared property. */
-export interface DeclaredClaim {
-  /** A property with fewer inputs than this count is thin. */
-  readonly minCount: number;
-  /** The ids of the properties with a count below `minCount`. */
-  readonly thin: readonly string[];
-  /** The count of the inputs for each property id. */
-  readonly counts: Readonly<Record<string, number>>;
-  /** The key of the family of an input. `familyOf` gives the key of one cell. The family is the unit of a verdict. */
-  readonly familyBy?: FamilyBy;
-  /** The minimum count of the inputs of each family. Without it, `checkDeclared` does not count the families. */
-  readonly familyMin?: number;
-}
-/**
- * The key of the family of a cell (`docs/CORPUS-CHECKS.md`).
- *
- * - The flat form is a list of dimensions. The key is the values of these dimensions of the cell, in order, with `/` between them.
- * - The map form chooses an entry by the field `kind` of the cell, or the entry `"*"`. The key is the kind, then the values of the dimensions of the entry.
- */
-export type FamilyBy = readonly string[] | {
-  readonly [kind: string]: readonly string[];
-};
-/** A cell of an input: one value for each dimension. The map form of `FamilyBy` also reads the field `kind`. */
-export type FamilyCell = Readonly<Record<string, unknown>>;
-/** The entry of the map form of `FamilyBy` for each kind without its own entry. */
-export declare const FAMILY_ANY_KIND = "*";
-/**
- * This function gives the family key of a cell. It throws a `RangeError` when the cell does not have a dimension of the key.
- * In the map form, it also throws for a cell without `kind`, and for a kind with no entry and no entry `"*"`.
- * For example, `{ "rect-grid": ["obstacles"], "*": [] }` gives `rect-grid/wall` for a `rect-grid` cell and `gallery` for a `gallery` cell.
- */
-export declare function familyOf(cell: FamilyCell, familyBy: FamilyBy): string;
-/** The hook that gives the ids of the properties that one input declares. */
-export type Declares<I> = (input: I) => readonly string[];
-/**
- * This function gives the count of the inputs for each property id. Each id of `ids` has a count, also when the count is 0.
- * An id from `declares` that is not in `ids` comes after the ids of `ids`, in the order of the first input that declares it.
- */
-export declare function declaredCounts<I>(inputs: Iterable<I>, declares: Declares<I>, ids?: readonly string[]): Record<string, number>;
-/**
- * This function reads the field `claims.declared` of a manifest. A manifest without it gives `undefined`.
- * It throws an `Error` for a claim without a whole `minCount`, a list `thin` of ids and a whole count for each id.
- */
-export declare function declaredClaimOf(manifest: object): DeclaredClaim | undefined;
-/**
- * This function checks the claim `claims.declared` against the inputs. It gives one break `declared` for each problem. An empty list tells that the claim is true.
- *
- * - `ids` are the property ids. The default is the ids of `claim.counts`.
- * - Each id of `ids` has a count in `claim.counts`, and `claim.counts` has no other id. Each count is the count of the inputs.
- * - An id with a count below `minCount` is in `thin`. Each id of `thin` is an id of `ids`.
- * - Each id that `declares` gives is an id of `ids`.
- *
- * With `claim.familyBy`, the hook `cellOf` gives the cell of each input. The default reads the field `cell` of the input.
- *
- * - Each cell has each dimension of its key. In the map form, each cell has a `kind`, and the kind has an entry or the entry `"*"` is there.
- * - Two cells with different dimension values do not give the same key.
- * - With `claim.familyMin`, each family has `familyMin` inputs or more.
- */
-export declare function checkDeclared<I>(inputs: Iterable<I>, declares: Declares<I>, claim: DeclaredClaim, ids?: readonly string[], cellOf?: (input: I) => FamilyCell | undefined): ClaimBreak[];
-/** The id and the hash of one input of a corpus. */
-export interface CorpusEntry {
-  readonly id: string;
-  readonly hash: string;
-}
-/**
- * This function gives the hash of a corpus: the first 16 hex characters of a SHA-256. The text of the SHA-256 is `canonicalJson`
- * of the corpus id and the `[id, hash]` of each input, in the order of the manifest. A change of one input changes the hash.
- */
-export declare function corpusHashOf(corpus: string, inputs: readonly CorpusEntry[]): string;
-/** The schema of a split file. */
-export declare const SPLIT_SCHEMA = "corpus-split/1";
-/** One fold of a split: the seeds that fit a selector and the seeds that score it. */
-export interface SplitFold {
-  readonly train: readonly number[];
-  readonly heldOut: readonly number[];
-}
-/** A split file `corpus-split/1`. Its name is `<corpus id>.<corpus hash>.json`. It is beside the corpus, so the corpus does not change. */
-export interface CorpusSplit {
-  readonly schema: typeof SPLIT_SCHEMA;
-  readonly corpus: string;
-  /** The hash of the corpus: `corpusHashOf` of its manifest. */
-  readonly corpusHash: string;
-  /** The splits by name. Each split has one fold or more. */
-  readonly splits: Readonly<Record<string, {
-    readonly folds: readonly SplitFold[];
-  }>>;
-}
-/** The fields of a manifest that the split check reads. */
-export interface SplitCorpus {
-  readonly corpus: string;
-  readonly specs: readonly {
-    readonly seeds: readonly number[];
-  }[];
-  readonly inputs: readonly CorpusEntry[];
-}
-/** This function gives the name of the split file of a corpus. */
-export declare function splitFileName(corpus: string, hash: string): string;
-/**
- * This function checks a split file against a manifest. It gives one break `split` for each problem. An empty list tells that the file is good.
- *
- * - The schema is `corpus-split/1`, the corpus is the id of the manifest and `corpusHash` is `corpusHashOf` of the manifest.
- * - Each split has one fold or more. In each fold, `train` and `heldOut` are lists of seeds, not empty and with no common seed.
- * - Each seed is a seed of a spec of the manifest.
- * - With `name`, the file has the split `name`.
- */
-export declare function checkSplit(split: unknown, corpus: SplitCorpus, name?: string): ClaimBreak[];
-/**
- * This function gives a copy of the folds of the split `name` of a split file. `where` names the file in the text of an error.
- * It throws an `Error` for each problem of `checkSplit`, and then for an unknown split name.
- */
-export declare function splitFolds(split: unknown, corpus: SplitCorpus, name: string, where?: string): SplitFold[];
-/** This function gives the folds that hold out one seed each, in the order of the seeds. Each fold trains on the other seeds. */
-export declare function leaveOneSeedOut(seeds: readonly number[]): SplitFold[];
 /** The schema of a strategy space. */
 export declare const STRATEGY_SPACE_SCHEMA = "strategy-space/1";
 /** The kind of a param: a whole number, a real number, one value of a list, or `true` and `false`. */
@@ -857,11 +936,23 @@ export interface MemberRule {
   readonly max: number;
   readonly ordered: boolean;
 }
+/** The inputs that an option supports. A missing field supports each value. */
+export interface OptionSupports {
+  /** The shape kinds of the boxes (`docs/SHAPES.md`). Without it, the option supports each kind. */
+  readonly shape?: readonly ShapeKind[];
+}
 /** One implementation of a stage. An option with `members` is a meta option: it chooses between whole configs, or wraps them. */
 export interface StageOption {
   readonly id: string;
   readonly params: readonly SpaceParam[];
   readonly members?: MemberRule;
+  /** The inputs that the option supports. It describes the option, so it is not part of a config or of its id. */
+  readonly supports?: OptionSupports;
+}
+/** The shape kinds of the inputs of a check, a count or an enumeration. Without `shapes`, each option counts. */
+export interface ShapeFilter {
+  /** The shape kinds of the input. Only the options that support each of these kinds count. */
+  readonly shapes?: readonly ShapeKind[];
 }
 /** One stage of the pipeline of an engine. A config of an `optional` stage can have no option. */
 export interface SpaceStage {
@@ -917,21 +1008,21 @@ export interface SpaceSize {
   readonly meta: bigint | null;
 }
 /** The options of `spaceSize`. */
-export interface SpaceSizeOptions {
+export interface SpaceSizeOptions extends ShapeFilter {
   /** The count of the levels of each numeric param, a whole number of 1 or more. */
   readonly levels: number;
   /** The largest meta count that `spaceSize` gives. The default is `10n ** 18n`. */
   readonly maxMeta?: bigint;
 }
 /** The options of a grid. The grid gives only the configs without a meta option. */
-export interface GridOptions {
+export interface GridOptions extends ShapeFilter {
   readonly mode: "grid";
   readonly levels: number;
   /** The largest count of configs. A larger grid causes a `RangeError`. The default is 100000. */
   readonly limit?: number;
 }
 /** The options of a sample. */
-export interface SampleOptions {
+export interface SampleOptions extends ShapeFilter {
   readonly mode: "sample";
   /** The count of the configs, a whole number of 0 or more. */
   readonly n: number;
@@ -946,8 +1037,9 @@ export type EnumerateOptions = GridOptions | SampleOptions;
 /**
  * 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`.
+ * 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): ClaimBreak[];
+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.
@@ -973,6 +1065,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.
+ * With `shapes`, it counts only the options that support each kind of the list.
  */
 export declare function spaceSize(space: StrategySpace, options: SpaceSizeOptions): SpaceSize;
 /**
@@ -981,8 +1074,14 @@ export declare function spaceSize(space: StrategySpace, options: SpaceSizeOption
  * - The mode `grid` gives each grid point without a meta option, in a stable order. Stages, options and values go in the order of the space.
  * - 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.
  */
 export declare function enumerateSpace(space: StrategySpace, options: EnumerateOptions): StrategyConfig[];
+/**
+ * This function gives the shape kinds that a space accepts, in the order of `SHAPE_KINDS`. The value comes from the `supports` of the options.
+ * A space accepts a kind when it has at least one config without a meta option on that kind.
+ */
+export declare function spaceShapeKinds(space: StrategySpace): ShapeKind[];
 /**
  * This function joins configs of the parts of a product space into one config of the space `space`.
  * The name of each stage gets the prefix `<space of the part>.`. The members of a meta option do not change.
@@ -1074,6 +1173,23 @@ export interface VerdictSignTest {
 }
 /** The label of a verdict. `better` and `worse` tell the side of `b`. */
 export type VerdictLabel = "better" | "worse" | "depends on the mix" | "no verdict";
+/**
+ * The scope of a verdict. The test keeps the families of the corpus as fixed, so its claim is about these families only.
+ * It is not a claim about a new kind of input.
+ */
+export type VerdictScope = "these families";
+/**
+ * The breadth of a verdict: the count of the families against its side.
+ * The side is the side of the label. For `depends on the mix` and `no verdict`, it is the sign of the stratified mean.
+ */
+export interface VerdictBreadth {
+  /** The count of the families with a sign against the side. A stratified mean of exactly 0 has no side, so this count is 0. */
+  readonly against: number;
+  /** The count of the families. */
+  readonly of: number;
+  /** The count of the families with the sign 0. */
+  readonly ties: number;
+}
 /** The result of `verdict`. */
 export interface VerdictResult {
   readonly measure: string;
@@ -1090,6 +1206,12 @@ export interface VerdictResult {
   /** `true` only when the two means have the same sign, the two intervals are clear of 0 and the permutation p is below `level`. */
   readonly agree: boolean;
   readonly label: VerdictLabel;
+  /** The scope of the claim: the families of the corpus, not a new kind of input. */
+  readonly scope: VerdictScope;
+  /** The count of the families against the side of the verdict, of all the families and of the ties. */
+  readonly breadth: VerdictBreadth;
+  /** The label, the scope and the breadth in one line, for example `better on these families, worse on 2 of 6 (1 tie)`. */
+  readonly summary: string;
   /** The inputs without a pair: one side has no record, a skipped record or no value of the measure. */
   readonly dropped: readonly string[];
 }
@@ -1100,6 +1222,7 @@ export interface VerdictResult {
  * - `stratified` is the mean of the family means. Its bootstrap draws the seeds inside each family. `pooled` is the mean of the inputs.
  * - The permutation test changes the sign of each difference inside its family. Its statistic is the mean of the family means.
  * - The label is `better` or `worse` only when `agree` is `true`. Opposite signs of the two means give `depends on the mix`.
+ * - `scope`, `breadth` and `summary` tell that the claim is about these families, and how many families are against it.
  *
  * 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`.
  */

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.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/corpus.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"],"mappings":"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"}