@mark1russell7/layout-contract 0.2.10 → 0.2.11

package/README.md

@@ -21,6 +21,8 @@ The package has no runtime dependencies.
 | The portfolio | `portfolio`, `Portfolio`, `PortfolioKey`, `PortfolioLevel`, `PortfolioOptions`, `PortfolioPick`, `PortfolioTrace`, `Member`, `MemberTrace`, `MemberStatus`, `pickMoves` |
 | 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 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` |
@@ -39,6 +41,7 @@ The package has no runtime dependencies.
 - **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 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.
 - **The tolerances.** `EPS` (`1e-6`) is for the float compares in an engine. `RECORD_EPS` (`1e-3`) is for the compares on a written file. A record writes the tolerance of each hard rule in its field `tolerance`. The defaults are `overlap` `0.001` and `through` `0.5`.
 
 ## An example
@@ -59,3 +62,5 @@ const hard = packHard(input, output);
 ```
 
 The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`. The promotion guards are in `docs/PROMOTION.md`. The portfolio and its pick rule are in `docs/PORTFOLIO.md`. The corpus checks and the split files are in `docs/CORPUS-CHECKS.md`. The strategy space is in [`docs/STRATEGY-SPACE.md`](https://github.com/mark1russell7/layout-contract/blob/main/docs/STRATEGY-SPACE.md).
+
+The verdict over families is in [`docs/VERDICT.md`](https://github.com/mark1russell7/layout-contract/blob/main/docs/VERDICT.md).

package/build/index.d.ts

@@ -714,7 +714,30 @@ export interface DeclaredClaim {
   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[];
 /**
@@ -734,8 +757,14 @@ export declare function declaredClaimOf(manifest: object): DeclaredClaim | undef
  * - 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[]): ClaimBreak[];
+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;
@@ -966,4 +995,113 @@ export declare function splitConfig(config: StrategyConfig, engine: string): Str
  * The constraints get the same prefixes. The named configs are the pairs `<name of a>+<name of b>`. It throws a `RangeError` when the two engines have the same name.
  */
 export declare function productSpace(a: StrategySpace, b: StrategySpace, name: string): StrategySpace;
+/**
+ * The largest count of inputs for the exact permutation test. Up to this count, the test enumerates all `2^n` sign sets.
+ * At 16 inputs, that is 65 536 sign sets, approximately 3 times the default draws. Above it, the cost doubles with each input, so the test uses seeded draws.
+ */
+export declare const VERDICT_EXACT_MAX = 16;
+/** The largest value of the option `exactMax`. At 20 inputs, the exact test has approximately 1 million sign sets. */
+export declare const VERDICT_EXACT_CAP = 20;
+/** The default count of the samples of each bootstrap. It is the parameter `bootstrapRuns` of `docs/PROMOTION.md`. */
+export declare const VERDICT_RUNS = 1e4;
+/** The default count of the random sign sets of the permutation test above `VERDICT_EXACT_MAX` inputs. */
+export declare const VERDICT_DRAWS = 2e4;
+/** The default seed of the bootstraps and of the random sign sets. */
+export declare const VERDICT_SEED = 1;
+/** The fields of a record that the verdict reads. */
+export type VerdictRecord = Pick<LayoutRecord, "strategy" | "input" | "seed" | "measures"> & {
+  readonly skipped?: string;
+};
+/** One side of a verdict: a strategy id, or a test that selects the records of the side. */
+export type VerdictSide<R extends VerdictRecord = VerdictRecord> = string | ((record: R) => boolean);
+/** The arguments of `verdict`. `tie` and `level` have no default. */
+export interface VerdictOptions<R extends VerdictRecord = VerdictRecord> {
+  /** The unit of the verdict. The family is the only unit. */
+  readonly by: "family";
+  /** The hook that gives the family of a record, for example `familyOf` of the cell of its input. */
+  readonly family: (record: R) => string;
+  /** The measure. Its direction tells which side is better. */
+  readonly measure: Pick<MeasureSpec, "id" | "direction">;
+  /** The baseline side. */
+  readonly a: VerdictSide<R>;
+  /** The candidate side. A positive difference tells that `b` is better than `a`. */
+  readonly b: VerdictSide<R>;
+  /**
+   * The minimum effect of the sign of a family, as `minEffect` of `MeasureSpec`. A smaller change of the family mean is a tie.
+   * `compareMeasure` compares the two family means, so the smallest tie is one grid step of `RECORD_EPS`.
+   */
+  readonly tie: number | {
+    readonly rel: number;
+  };
+  /** The significance level, from 0 to 1. The permutation p must be below it. The intervals have the level `1 - level`. */
+  readonly level: number;
+  /** The count of the samples of each bootstrap. The default is `VERDICT_RUNS`. */
+  readonly runs?: number;
+  /** The count of the random sign sets above the exact limit. The default is `VERDICT_DRAWS`. */
+  readonly draws?: number;
+  /** The seed of the bootstraps and of the random sign sets. The default is `VERDICT_SEED`. */
+  readonly seed?: number;
+  /** The largest count of inputs for the exact test. The default is `VERDICT_EXACT_MAX`. The value 0 always uses draws. */
+  readonly exactMax?: number;
+}
+/** A mean with its bootstrap interval. The interval is clear of 0 when `lo > 0` or `hi < 0`. */
+export interface VerdictInterval {
+  readonly mean: number;
+  readonly lo: number;
+  readonly hi: number;
+}
+/** The difference of one family: the count of its inputs, the mean of their differences and its sign. */
+export interface FamilyVerdict {
+  readonly family: string;
+  readonly n: number;
+  readonly mean: number;
+  /** The value 1 tells that `b` is better, -1 that `b` is worse, and 0 a tie by `tie`. */
+  readonly sign: -1 | 0 | 1;
+}
+/** The stratified paired permutation test. With `exact`, `draws` is the count of all the sign sets. */
+export interface VerdictPermutation {
+  readonly p: number;
+  readonly exact: boolean;
+  readonly draws: number;
+  readonly seed: number;
+}
+/** The two-sided exact sign test of the family signs. It is a report only. Ties do not count. */
+export interface VerdictSignTest {
+  readonly wins: number;
+  readonly losses: number;
+  readonly ties: number;
+  readonly p: number;
+}
+/** 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 result of `verdict`. */
+export interface VerdictResult {
+  readonly measure: string;
+  /** The count of the paired inputs. */
+  readonly n: number;
+  /** The mean of the family means, with a bootstrap of the seeds inside each family. */
+  readonly stratified: VerdictInterval;
+  /** The mean of the inputs, with a bootstrap of the inputs. */
+  readonly pooled: VerdictInterval;
+  readonly permutation: VerdictPermutation;
+  /** The families, in sort order. */
+  readonly families: readonly FamilyVerdict[];
+  readonly signTest: VerdictSignTest;
+  /** `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 inputs without a pair: one side has no record, a skipped record or no value of the measure. */
+  readonly dropped: readonly string[];
+}
+/**
+ * This function gives the verdict of the candidate `b` against the baseline `a` on one measure, with the family as the unit (`docs/VERDICT.md`).
+ *
+ * - It pairs the records by input and seed. The difference of a pair is `b - a` for a measure where more is better, else `a - b`.
+ * - `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`.
+ *
+ * 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;
 //# 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/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"],"mappings":"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"}
+{"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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"}

package/build/index.js

@@ -1394,6 +1394,52 @@ function portfolio(id, members, key, options = {}) {
 	};
 }
 // src/corpus.ts
+/** The entry of the map form of `FamilyBy` for each kind without its own entry. */
+const FAMILY_ANY_KIND = "*";
+/** The separator of the parts of a family key. */
+const FAMILY_SEP = "/";
+/** This function gives the text of a dimension value. A missing value, or a value that is not a string, a number or a boolean, gives `undefined`. */
+function partOf$1(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+}
+/** This function gives the parts of the family key of a cell. A missing dimension, a missing kind or a kind without an entry gives a problem. */
+function familyParts(cell, familyBy) {
+	let dims;
+	let kind;
+	const parts = [];
+	if (Array.isArray(familyBy)) dims = familyBy;
+	else {
+		const map = familyBy;
+		kind = partOf$1(cell["kind"]);
+		if (kind === void 0) return { problem: "a cell without kind, which the map form of familyBy needs" };
+		const entry = Object.hasOwn(map, kind) ? map[kind] : Object.hasOwn(map, "*") ? map["*"] : void 0;
+		if (entry === void 0) return { problem: `the kind "${kind}", which has no entry in familyBy and no entry "*"` };
+		dims = entry;
+		parts.push(kind);
+	}
+	for (const dim of dims) {
+		const part = partOf$1(cell[dim]);
+		if (part === void 0) return { problem: `a cell${kind === void 0 ? "" : ` of the kind "${kind}"`} without the dimension "${dim}" of familyBy` };
+		parts.push(part);
+	}
+	return { parts };
+}
+/**
+* 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.
+*/
+function familyOf(cell, familyBy) {
+	const found = familyParts(cell, familyBy);
+	if ("problem" in found) throw new RangeError(`familyOf: ${found.problem}.`);
+	return found.parts.join(FAMILY_SEP);
+}
+/** This function tells if a value is a `FamilyBy`: a list of dimensions, or a map from a kind to a list of dimensions. */
+function isFamilyBy(value) {
+	const isDims = (v) => Array.isArray(v) && v.every((d) => typeof d === "string");
+	return isDims(value) || isObject$1(value) && Object.values(value).every(isDims);
+}
 /**
 * 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.
@@ -1420,10 +1466,15 @@ function declaredClaimOf(manifest) {
 	if (!Number.isInteger(minCount) || minCount < 0) throw new Error("The field claims.declared.minCount is a whole number of 0 or more.");
 	if (!Array.isArray(thin) || !thin.every((id) => typeof id === "string")) throw new Error("The field claims.declared.thin is a list of property ids.");
 	if (!isObject$1(counts) || !Object.values(counts).every((n) => Number.isInteger(n) && n >= 0)) throw new Error("The field claims.declared.counts gives a whole count for each property id.");
+	const { familyBy, familyMin } = declared;
+	if (familyBy !== void 0 && !isFamilyBy(familyBy)) throw new Error("The field claims.declared.familyBy is a list of dimensions, or a map from a kind to a list of dimensions.");
+	if (familyMin !== void 0 && (!Number.isInteger(familyMin) || familyMin < 0)) throw new Error("The field claims.declared.familyMin is a whole number of 0 or more.");
 	return {
 		minCount,
 		thin: [...thin],
-		counts: { ...counts }
+		counts: { ...counts },
+		...familyBy === void 0 ? {} : { familyBy: Array.isArray(familyBy) ? [...familyBy] : { ...familyBy } },
+		...familyMin === void 0 ? {} : { familyMin }
 	};
 }
 /**
@@ -1433,9 +1484,16 @@ function declaredClaimOf(manifest) {
 * - 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.
 */
-function checkDeclared(inputs, declares, claim, ids = Object.keys(claim.counts)) {
-	const computed = declaredCounts(inputs, declares, ids);
+function checkDeclared(inputs, declares, claim, ids = Object.keys(claim.counts), cellOf = cellField) {
+	const list = [...inputs];
+	const computed = declaredCounts(list, declares, ids);
 	const out = [];
 	for (const id of ids) if (!(id in claim.counts)) out.push(`the property "${id}" has no count`);
 	else if (claim.counts[id] !== computed[id]) out.push(`the property "${id}" has the count ${claim.counts[id]}, but the inputs give ${computed[id]}`);
@@ -1443,11 +1501,58 @@ function checkDeclared(inputs, declares, claim, ids = Object.keys(claim.counts))
 	for (const id of ids) if ((computed[id] ?? 0) < claim.minCount && !claim.thin.includes(id)) out.push(`the property "${id}" has ${computed[id]} inputs, below minCount ${claim.minCount}, and it is not in thin`);
 	for (const id of claim.thin) if (!ids.includes(id)) out.push(`"${id}" of thin is not a declared property`);
 	for (const id of Object.keys(computed)) if (!ids.includes(id)) out.push(`${computed[id]} inputs declare "${id}", which is not a declared property`);
-	return out.map((detail) => ({
+	const breaks = out.map((detail) => ({
 		claim: "declared",
 		detail,
 		inputs: []
 	}));
+	if (claim.familyBy !== void 0) breaks.push(...checkFamilies(list, claim.familyBy, claim.familyMin, cellOf));
+	return breaks;
+}
+/** This function gives the field `cell` of an input, when it is an object. */
+function cellField(input) {
+	const cell = isObject$1(input) ? input["cell"] : void 0;
+	return isObject$1(cell) ? cell : void 0;
+}
+/** This function gives the field `id` of an input, or its place in the list. */
+function inputId(input, at) {
+	const id = isObject$1(input) ? input["id"] : void 0;
+	return typeof id === "string" ? id : `#${at}`;
+}
+/** This function gives the breaks of the family keys of the inputs: the problems of each key, the collisions and the thin families. */
+function checkFamilies(inputs, familyBy, familyMin, cellOf) {
+	const problems = /* @__PURE__ */ new Map();
+	const members = /* @__PURE__ */ new Map();
+	inputs.forEach((input, at) => {
+		const id = inputId(input, at);
+		const cell = cellOf(input);
+		const found = cell === void 0 ? { problem: "no cell, which familyBy needs" } : familyParts(cell, familyBy);
+		if ("problem" in found) {
+			problems.set(found.problem, [...problems.get(found.problem) ?? [], id]);
+			return;
+		}
+		const key = found.parts.join(FAMILY_SEP);
+		const family = members.get(key) ?? {
+			tuples: /* @__PURE__ */ new Map(),
+			ids: []
+		};
+		const tuple = JSON.stringify(found.parts);
+		family.tuples.set(tuple, [...family.tuples.get(tuple) ?? [], id]);
+		family.ids.push(id);
+		members.set(key, family);
+	});
+	const breaks = [];
+	const add = (detail, ids) => void breaks.push({
+		claim: "declared",
+		detail,
+		inputs: [...ids]
+	});
+	for (const [problem, ids] of problems) add(`${ids.length} inputs have ${problem}`, ids);
+	for (const [key, family] of members) {
+		if (family.tuples.size > 1) add(`the family "${key}" comes from different dimension values: ${[...family.tuples.keys()].join(" and ")}`, family.ids);
+		if (familyMin !== void 0 && family.ids.length < familyMin) add(`the family "${key}" has ${family.ids.length} inputs, below familyMin ${familyMin}`, family.ids);
+	}
+	return breaks;
 }
 /**
 * 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`
@@ -2258,6 +2363,218 @@ function productSpace(a, b, name) {
 		parts: [a, b]
 	};
 }
-export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, SIDES, SPLIT_SCHEMA, STRATEGY_SPACE_SCHEMA, applyPack, boundsOf, canonicalConfig, canonicalJson, checkConfig, checkDeclared, checkInput, checkSpace, checkSplit, compareMeasure, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, enumerateSpace, exercised, fnv1a32, grow, joinConfigs, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramLevels, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
+// src/verdict.ts
+/**
+* The largest count of inputs for the exact permutation test. Up to this count, the test enumerates all `2^n` sign sets.
+* At 16 inputs, that is 65 536 sign sets, approximately 3 times the default draws. Above it, the cost doubles with each input, so the test uses seeded draws.
+*/
+const VERDICT_EXACT_MAX = 16;
+/** The largest value of the option `exactMax`. At 20 inputs, the exact test has approximately 1 million sign sets. */
+const VERDICT_EXACT_CAP = 20;
+/** The default count of the samples of each bootstrap. It is the parameter `bootstrapRuns` of `docs/PROMOTION.md`. */
+const VERDICT_RUNS = 1e4;
+/** The default count of the random sign sets of the permutation test above `VERDICT_EXACT_MAX` inputs. */
+const VERDICT_DRAWS = 2e4;
+/** The default seed of the bootstraps and of the random sign sets. */
+const VERDICT_SEED = 1;
+/** This function gives the mean of a list that is not empty. */
+const meanOf = (values) => values.reduce((s, v) => s + v, 0) / values.length;
+/** This function gives the `q` quantile of sorted values, with linear interpolation. */
+function quantileOf(sorted, q) {
+	const at = (sorted.length - 1) * q;
+	const lo = Math.floor(at);
+	const hi = Math.ceil(at);
+	return sorted[lo] + (sorted[hi] - sorted[lo]) * (at - lo);
+}
+/** This function gives the interval of the samples of a bootstrap at the level `1 - level`. */
+function intervalOf(mean, samples, level) {
+	samples.sort((x, y) => x - y);
+	return {
+		mean,
+		lo: quantileOf(samples, level / 2),
+		hi: quantileOf(samples, 1 - level / 2)
+	};
+}
+/** This function tells if an interval is clear of 0 on the side of the sign `sign`. */
+const clearOn = (i, sign) => sign > 0 ? i.lo > 0 : sign < 0 ? i.hi < 0 : false;
+/** This function gives the two-sided p of the exact binomial sign test, with `p = 0.5`. No count gives 1. */
+function signP(wins, losses) {
+	const n = wins + losses;
+	if (n === 0) return 1;
+	const k = Math.min(wins, losses);
+	let tail = 0;
+	let c = 1;
+	for (let i = 0; i <= k; i++) {
+		tail += c;
+		c = c * (n - i) / (i + 1);
+	}
+	return Math.min(1, 2 * tail / 2 ** n);
+}
+/** This function tells if a value is a positive whole number. */
+const isCount = (v) => Number.isInteger(v) && v > 0;
+/** This function gives the test of one side. */
+function sideTest(side) {
+	return typeof side === "string" ? (r) => r.strategy === side : side;
+}
+/** This function pairs the records of `a` and `b` by input and seed, and gives the pairs in the order of family and key. */
+function pairsOf(records, options) {
+	const isA = sideTest(options.a);
+	const isB = sideTest(options.b);
+	const sides = /* @__PURE__ */ new Map();
+	for (const r of records) {
+		const inA = isA(r);
+		const inB = isB(r);
+		if (inA && inB) throw new RangeError(`verdict: the record of the input "${r.input}" is in the two sides`);
+		if (!inA && !inB) continue;
+		const key = `${r.input}#${r.seed}`;
+		const entry = sides.get(key) ?? {};
+		const side = inA ? "a" : "b";
+		if (entry[side] !== void 0) throw new RangeError(`verdict: the side ${side} has two records of the input "${r.input}" and the seed ${r.seed}`);
+		entry[side] = r;
+		sides.set(key, entry);
+	}
+	const pairs = [];
+	const dropped = [];
+	const id = options.measure.id;
+	for (const [key, { a, b }] of sides) {
+		const va = a?.skipped === void 0 ? a?.measures[id] : void 0;
+		const vb = b?.skipped === void 0 ? b?.measures[id] : void 0;
+		if (a === void 0 || b === void 0 || va === void 0 || vb === void 0) {
+			dropped.push(key);
+			continue;
+		}
+		if (!Number.isFinite(va) || !Number.isFinite(vb)) throw new RangeError(`verdict: the measure ${id} of the input "${a.input}" is not finite`);
+		const family = options.family(a);
+		if (options.family(b) !== family) throw new RangeError(`verdict: the two records of the input "${a.input}" have different families`);
+		pairs.push({
+			key,
+			family,
+			a: va,
+			b: vb,
+			d: options.measure.direction === "higher" ? vb - va : va - vb
+		});
+	}
+	pairs.sort((x, y) => x.family < y.family ? -1 : x.family > y.family ? 1 : x.key < y.key ? -1 : x.key > y.key ? 1 : 0);
+	dropped.sort();
+	return {
+		pairs,
+		dropped
+	};
+}
+/**
+* This function gives the verdict of the candidate `b` against the baseline `a` on one measure, with the family as the unit (`docs/VERDICT.md`).
+*
+* - It pairs the records by input and seed. The difference of a pair is `b - a` for a measure where more is better, else `a - b`.
+* - `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`.
+*
+* 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`.
+*/
+function verdict(records, options) {
+	const { tie, level, measure } = options;
+	if (options.by !== "family") throw new RangeError(`verdict: the unit is "family", not "${String(options.by)}"`);
+	if (tie === void 0 || (typeof tie === "number" ? !(tie >= 0) : !(tie.rel >= 0))) throw new RangeError("verdict: tie is a required number of 0 or more, or { rel } of 0 or more");
+	if (level === void 0 || !(level > 0 && level < 1)) throw new RangeError("verdict: level is a required number between 0 and 1");
+	const runs = options.runs ?? 1e4;
+	const draws = options.draws ?? 2e4;
+	const seed = options.seed ?? 1;
+	const exactMax = options.exactMax ?? 16;
+	if (!isCount(runs) || !isCount(draws)) throw new RangeError("verdict: runs and draws are whole numbers above 0");
+	if (!Number.isInteger(exactMax) || exactMax < 0 || exactMax > 20) throw new RangeError(`verdict: exactMax is a whole number from 0 to 20`);
+	const { pairs, dropped } = pairsOf(records, options);
+	const n = pairs.length;
+	if (n === 0) throw new RangeError(`verdict: the records give no pair of the measure ${measure.id}`);
+	const groups = /* @__PURE__ */ new Map();
+	for (const p of pairs) groups.set(p.family, [...groups.get(p.family) ?? [], p]);
+	const lists = [...groups.values()];
+	const spec = {
+		direction: measure.direction,
+		minEffect: tie
+	};
+	const families = lists.map((list) => {
+		const verdictOf = compareMeasure(meanOf(list.map((p) => p.b)), meanOf(list.map((p) => p.a)), spec);
+		return {
+			family: list[0].family,
+			n: list.length,
+			mean: meanOf(list.map((p) => p.d)),
+			sign: verdictOf === "better" ? 1 : verdictOf === "worse" ? -1 : 0
+		};
+	});
+	const stratMean = meanOf(families.map((f) => f.mean));
+	const rs = stepRandom(seed, "verdict.stratified");
+	const stratSamples = [];
+	for (let run = 0; run < runs; run++) {
+		let sum = 0;
+		for (const list of lists) {
+			let s = 0;
+			for (let j = 0; j < list.length; j++) s += list[Math.floor(rs() * list.length)].d;
+			sum += s / list.length;
+		}
+		stratSamples.push(sum / lists.length);
+	}
+	const stratified = intervalOf(stratMean, stratSamples, level);
+	const pooledMean = meanOf(pairs.map((p) => p.d));
+	const rp = stepRandom(seed, "verdict.pooled");
+	const pooledSamples = [];
+	for (let run = 0; run < runs; run++) {
+		let s = 0;
+		for (let j = 0; j < n; j++) s += pairs[Math.floor(rp() * n)].d;
+		pooledSamples.push(s / n);
+	}
+	const pooled = intervalOf(pooledMean, pooledSamples, level);
+	const terms = lists.flatMap((list) => list.map((p) => p.d / (lists.length * list.length)));
+	const observed = Math.abs(terms.reduce((s, t) => s + t, 0));
+	const slack = 1e-12 * terms.reduce((s, t) => s + Math.abs(t), 0);
+	const exact = n <= exactMax;
+	let hits = 0;
+	let total;
+	if (exact) {
+		total = 2 ** n;
+		for (let mask = 0; mask < total; mask++) {
+			let t = 0;
+			for (let i = 0; i < n; i++) t += mask & 1 << i ? -terms[i] : terms[i];
+			if (Math.abs(t) >= observed - slack) hits++;
+		}
+	} else {
+		total = draws;
+		const rf = stepRandom(seed, "verdict.permutation");
+		for (let k = 0; k < draws; k++) {
+			let t = 0;
+			for (let i = 0; i < n; i++) t += rf() < .5 ? -terms[i] : terms[i];
+			if (Math.abs(t) >= observed - slack) hits++;
+		}
+	}
+	const permutation = {
+		p: exact ? hits / total : (hits + 1) / (total + 1),
+		exact,
+		draws: total,
+		seed
+	};
+	const wins = families.filter((f) => f.sign === 1).length;
+	const losses = families.filter((f) => f.sign === -1).length;
+	const signTest = {
+		wins,
+		losses,
+		ties: families.length - wins - losses,
+		p: signP(wins, losses)
+	};
+	const sign = Math.sign(stratified.mean);
+	const agree = sign !== 0 && sign === Math.sign(pooled.mean) && clearOn(stratified, sign) && clearOn(pooled, sign) && permutation.p < level;
+	const label = agree ? sign > 0 ? "better" : "worse" : sign * Math.sign(pooled.mean) < 0 ? "depends on the mix" : "no verdict";
+	return {
+		measure: measure.id,
+		n,
+		stratified,
+		pooled,
+		permutation,
+		families,
+		signTest,
+		agree,
+		label,
+		dropped
+	};
+}
+export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, SIDES, SPLIT_SCHEMA, STRATEGY_SPACE_SCHEMA, VERDICT_DRAWS, VERDICT_EXACT_CAP, VERDICT_EXACT_MAX, VERDICT_RUNS, VERDICT_SEED, applyPack, boundsOf, canonicalConfig, canonicalJson, checkConfig, checkDeclared, checkInput, checkSpace, checkSplit, compareMeasure, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, enumerateSpace, exercised, familyOf, fnv1a32, grow, joinConfigs, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramLevels, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
 
 //# sourceMappingURL=index.js.map