@mark1russell7/layout-contract 0.2.11 → 0.2.13

package/build/index.js

@@ -110,6 +110,134 @@ function overlapOf(a, b) {
 		y: Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y)
 	};
 }
+// src/shapes.ts
+/** The declared shape kinds, in their order. Only `rect` has all of its geometry. The other kinds have their bounding box only. */
+const SHAPE_KINDS = Object.freeze([
+	{
+		id: "rect",
+		fields: ["w", "h"],
+		regions: ["rect"],
+		geometry: {
+			bounds: true,
+			area: true,
+			contains: true,
+			overlap: true
+		}
+	},
+	{
+		id: "polygon",
+		fields: ["points", "holes?"],
+		regions: ["polygon"],
+		geometry: {
+			bounds: true,
+			area: false,
+			contains: false,
+			overlap: false
+		}
+	},
+	{
+		id: "circle",
+		fields: [
+			"cx",
+			"cy",
+			"r"
+		],
+		regions: ["circle"],
+		geometry: {
+			bounds: true,
+			area: false,
+			contains: false,
+			overlap: false
+		}
+	},
+	{
+		id: "free",
+		fields: [
+			"w",
+			"h",
+			"shape?"
+		],
+		regions: [
+			"rect",
+			"polygon",
+			"circle",
+			"ellipse"
+		],
+		geometry: {
+			bounds: true,
+			area: false,
+			contains: false,
+			overlap: false
+		}
+	}
+]);
+/** The ids of `SHAPE_KINDS`, in their order. */
+const SHAPE_KIND_IDS = Object.freeze(SHAPE_KINDS.map((k) => k.id));
+/** The shape kinds of a measure or a rule without `shapes`. The contract measured only rectangles before L46. */
+const DEFAULT_SHAPES = Object.freeze(["rect"]);
+const REGION_KIND = {
+	rect: "rect",
+	polygon: "polygon",
+	circle: "circle",
+	ellipse: "free"
+};
+/** This function tells if a value is a declared shape kind. */
+function isShapeKind(value) {
+	return typeof value === "string" && SHAPE_KIND_IDS.includes(value);
+}
+/**
+* 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`.
+*/
+function shapeKindOf(box) {
+	if (box.shapeKind !== void 0) return box.shapeKind;
+	return box.shape === void 0 ? "rect" : REGION_KIND[box.shape.kind];
+}
+/** 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. */
+function shapeKindsOf(input) {
+	const seen = new Set(input.boxes.map(shapeKindOf));
+	return SHAPE_KIND_IDS.filter((k) => seen.has(k));
+}
+/** This function gives the value of the cell dimension `itemShape` of an input: its one kind, `mixed` for more kinds, or `rect` without boxes. */
+function itemShapeOf(input) {
+	const kinds = shapeKindsOf(input);
+	return kinds.length === 0 ? "rect" : kinds.length === 1 ? kinds[0] : "mixed";
+}
+/** This function gives the problem of the shape kind of a box, or `undefined` when `shapeKind` and `shape` agree. */
+function shapeKindProblem(box) {
+	const k = box.shapeKind;
+	if (k === void 0) return void 0;
+	const spec = SHAPE_KINDS.find((s) => s.id === k);
+	if (spec === void 0) return `box ${box.id}: the shape kind ${String(k)} is not a declared kind`;
+	if (box.shape === void 0) return k === "rect" || k === "free" ? void 0 : `box ${box.id}: the shape kind ${k} has no shape`;
+	if (!spec.regions.includes(box.shape.kind)) return `box ${box.id}: the shape kind ${k} does not agree with a shape of the kind ${box.shape.kind}`;
+}
+/** This function gives the shape kinds that a measure or a rule supports. */
+function shapesOf(use) {
+	return use.shapes ?? DEFAULT_SHAPES;
+}
+/**
+* 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.
+*/
+function checkShapes(input, uses) {
+	const kinds = shapeKindsOf(input);
+	const out = [];
+	for (const use of uses) {
+		const shapes = shapesOf(use);
+		for (const kind of kinds) {
+			if (shapes.includes(kind)) continue;
+			const ids = input.boxes.filter((b) => shapeKindOf(b) === kind).map((b) => b.id);
+			const shown = ids.slice(0, 5).join(", ") + (ids.length > 5 ? `, and ${ids.length - 5} more` : "");
+			out.push({
+				claim: "shape",
+				detail: `${use.id} supports only the shape kinds ${shapes.join(", ") || "(none)"}, but the input ${input.id} has ${kind} boxes: ${shown}`,
+				inputs: [input.id]
+			});
+		}
+	}
+	return out;
+}
 // src/tolerance.ts
 /** The epsilon for the float compares in an engine. */
 const EPS = 1e-6;
@@ -256,8 +384,13 @@ function applyPack(input, output) {
 	};
 }
 // src/record.ts
-/** 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. */
+/**
+* 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.
+*/
 function toLayoutRecord(input, run) {
+	const shapes = shapeKindsOf(input);
+	const onlyRect = shapes.length === 0 || shapes.length === 1 && shapes[0] === "rect";
 	return {
 		schema: "layout-record/1",
 		...run,
@@ -265,7 +398,8 @@ function toLayoutRecord(input, run) {
 		inputHash: input.hash ?? "",
 		set: input.set ?? "",
 		nodes: input.boxes.length,
-		edges: input.edges?.length ?? 0
+		edges: input.edges?.length ?? 0,
+		...onlyRect ? {} : { shapes }
 	};
 }
 // src/rules.ts
@@ -359,6 +493,29 @@ function countPortsOffBorder(boxes, eps = RECORD_EPS) {
 	}
 	return count;
 }
+/**
+* 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.
+*/
+const PACK_HARD_RULES = Object.freeze([
+	{
+		id: "no-overlap",
+		shapes: ["rect"]
+	},
+	{
+		id: "in-container",
+		shapes: ["rect"]
+	},
+	{
+		id: "locked-kept",
+		shapes: SHAPE_KIND_IDS
+	},
+	{
+		id: "complete",
+		shapes: SHAPE_KIND_IDS
+	}
+]);
 /** This function tells if the inside of `region` and the inside of `rect` have a common point. */
 function regionHitsRect(region, rect) {
 	if (rect.w <= 0 || rect.h <= 0) return false;
@@ -561,13 +718,22 @@ function checkInput(input) {
 		ids.add(box.id);
 		if (!(box.w > 0 && box.h > 0 && Number.isFinite(box.w) && Number.isFinite(box.h))) problems.push(`box ${box.id}: the size is not positive and finite`);
 		if (box.locked === true && (box.x === void 0 || box.y === void 0)) problems.push(`box ${box.id}: a locked box has no position`);
+		const shape = shapeKindProblem(box);
+		if (shape !== void 0) problems.push(shape);
 	}
 	if (countPortsOffBorder(input.boxes) > 0) problems.push("a fixed port is not on the border of its box");
 	for (const edge of input.edges ?? []) if (!ids.has(edge.source) || !ids.has(edge.target)) problems.push(`edge ${edge.id}: a box of the edge is not in the input`);
 	return problems;
 }
 // src/measures.ts
-/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */
+/** The shape kinds of a joint measure that reads only the bounding boxes, the centers and the positions of the boxes. */
+const BOUNDS_ONLY = SHAPE_KIND_IDS;
+/** The shape kinds of a joint measure that reads the area `w` by `h` of each box. */
+const AREA = ["rect"];
+/**
+* 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.
+*/
 const JOINT_MEASURES = Object.freeze([
 	{
 		id: "joint.fill",
@@ -577,7 +743,8 @@ const JOINT_MEASURES = Object.freeze([
 		min: 0,
 		max: 1,
 		floor: 1,
-		role: "guard"
+		role: "guard",
+		shapes: AREA
 	},
 	{
 		id: "joint.aspectError",
@@ -588,7 +755,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: Infinity,
 		floor: 0,
 		tol: .01,
-		role: "guard"
+		role: "guard",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.spill",
@@ -599,7 +767,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: 1,
 		floor: 0,
 		tol: .001,
-		role: "guard"
+		role: "guard",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.straight.crossings",
@@ -610,7 +779,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: Infinity,
 		floor: 0,
 		tol: 0,
-		role: "guard"
+		role: "guard",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.straight.length",
@@ -621,7 +791,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: Infinity,
 		floor: 0,
 		tol: .01,
-		role: "guard"
+		role: "guard",
+		shapes: AREA
 	},
 	{
 		id: "joint.stability.mean",
@@ -632,7 +803,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: Infinity,
 		floor: 0,
 		tol: .005,
-		role: "change-guard"
+		role: "change-guard",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.stability.moved",
@@ -643,7 +815,8 @@ const JOINT_MEASURES = Object.freeze([
 		max: 1,
 		floor: 0,
 		tol: .02,
-		role: "change-guard"
+		role: "change-guard",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.proxy.rank",
@@ -651,7 +824,8 @@ const JOINT_MEASURES = Object.freeze([
 		direction: "higher",
 		min: -1,
 		max: 1,
-		role: "diagnostic"
+		role: "diagnostic",
+		shapes: BOUNDS_ONLY
 	},
 	{
 		id: "joint.ms",
@@ -659,7 +833,8 @@ const JOINT_MEASURES = Object.freeze([
 		direction: "lower",
 		min: 0,
 		max: Infinity,
-		role: "time"
+		role: "time",
+		shapes: BOUNDS_ONLY
 	}
 ]);
 /** The threshold of `joint.stability.moved`, in widths `W` of the base. */
@@ -1764,12 +1939,28 @@ function optionProblems(stage, o) {
 			if (problem !== void 0) out.push(["when", `${pat} has a when value that is not a value of ${p.when.param}: ${problem}`]);
 		}
 	});
+	if (o.supports !== void 0) out.push(...supportsProblems(o.supports, at));
 	if (o.members !== void 0) {
 		const { min, max, ordered } = o.members;
 		if (!Number.isInteger(min) || !Number.isInteger(max) || min < 1 || min > max || typeof ordered !== "boolean") out.push(["members", `${at} has a member rule without whole counts 1 <= min <= max and a boolean ordered`]);
 	}
 	return out;
 }
+/** This function gives the problems of the `supports` of an option. */
+function supportsProblems(supports, at) {
+	if (!isObject(supports)) return [["shape", `the supports of ${at} are not an object`]];
+	const shape = supports["shape"];
+	if (shape === void 0) return [];
+	if (!Array.isArray(shape) || shape.length === 0) return [["shape", `${at} supports no shape kind. Remove shape to support each kind`]];
+	const out = [];
+	shape.forEach((k, i) => {
+		if (!isShapeKind(k)) out.push(["shape", `${at} supports the shape kind ${show(k)}, which is not one of ${SHAPE_KIND_IDS.join(", ")}`]);
+		else if (shape.indexOf(k) !== i) out.push(["duplicate", `${at} has the shape kind ${k} two times`]);
+	});
+	return out;
+}
+/** This function tells if an option supports each shape kind of the list. */
+const supportsShapes = (o, shapes) => shapes === void 0 || o.supports?.shape === void 0 || shapes.every((k) => o.supports.shape.includes(k));
 /** This function gives the problems of the params of one stage choice. */
 function choiceParamProblems(o, params, at) {
 	if (params !== void 0 && !isObject(params)) return [["config", `the params of ${at} are not an object`]];
@@ -1791,7 +1982,7 @@ function choiceParamProblems(o, params, at) {
 	return out;
 }
 /** This function gives the problems of a config of a space. A member of a meta option has `member: true`. */
-function configProblems(space, config, member) {
+function configProblems(space, config, member, shapes) {
 	if (!isObject(config) || !isObject(config["stages"])) return [["config", "the config is not an object with stages"]];
 	const out = [];
 	const stages = config["stages"];
@@ -1829,6 +2020,10 @@ function configProblems(space, config, member) {
 		}
 		chosen.set(s.name, o.id);
 		const at = `the option ${s.name}.${o.id}`;
+		if (!supportsShapes(o, shapes)) {
+			const missing = shapes.filter((k) => !o.supports.shape.includes(k));
+			out.push(["shape", `${at} supports the shape kinds ${o.supports.shape.join(", ")}, not ${missing.join(", ")}`]);
+		}
 		if (meta !== void 0 && meta !== s.name) out.push(["meta", `the stage ${s.name} is set, but the meta option of ${meta} replaces the other stages of its part`]);
 		out.push(...choiceParamProblems(o, c["params"], at));
 		if (o.members === void 0) {
@@ -1839,19 +2034,19 @@ function configProblems(space, config, member) {
 			out.push(["depth", `a member has the meta option ${s.name}.${o.id}. The depth of a meta config is 1`]);
 			continue;
 		}
-		out.push(...memberProblems(partOf(space, s.name).space, o.members, c["members"], at));
+		out.push(...memberProblems(partOf(space, s.name).space, o.members, c["members"], at, shapes));
 	}
 	for (const c of space.constraints ?? []) if (!holds(c, chosen)) out.push(["constraint", `the config breaks the constraint ${describe(c)}`]);
 	return out;
 }
 /** This function gives the problems of the members of a meta option. `part` is the space of the members. */
-function memberProblems(part, rule, members, at) {
+function memberProblems(part, rule, members, at, shapes) {
 	if (!Array.isArray(members)) return [["members", `${at} is a meta option without a list of members`]];
 	const out = [];
 	if (members.length < rule.min || members.length > rule.max) out.push(["members", `${at} has ${members.length} members, not ${rule.min} to ${rule.max}`]);
 	const ids = /* @__PURE__ */ new Map();
 	members.forEach((m, k) => {
-		const inner = configProblems(part, m, true);
+		const inner = configProblems(part, m, true, shapes);
 		for (const [claim, detail] of inner) out.push([claim, `the member ${k} of ${at}: ${detail}`]);
 		if (inner.length > 0) return;
 		const id = idOf(canonicalOf(part, m, true));
@@ -1868,9 +2063,10 @@ const toBreaks = (problems, inputs = []) => problems.map(([claim, detail]) => ({
 /**
 * 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.
 */
-function checkConfig(space, config) {
-	return toBreaks(configProblems(space, config, false));
+function checkConfig(space, config, options = {}) {
+	return toBreaks(configProblems(space, config, false, options.shapes));
 }
 /**
 * This function checks a space. It gives one break for each problem. An empty list tells that the space is good.
@@ -2136,14 +2332,40 @@ function combos(space, levels, meta, limit) {
 /**
 * 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.
 */
 function spaceSize(space, options) {
 	assertSpace(space);
 	assertWhole(options.levels, "levels", 1);
-	const limit = options.maxMeta ?? 10n ** 18n;
+	assertShapes(options.shapes);
+	return sizeOf(restrict(space, options.shapes), options.levels, options.maxMeta ?? 10n ** 18n);
+}
+/**
+* This function gives the space with only the options that support each shape kind of `shapes`. Without `shapes`, it gives the same space.
+* A stage can lose all of its options. Then the space has no config with that stage.
+*/
+function restrict(space, shapes) {
+	if (shapes === void 0) return space;
+	return {
+		...space,
+		stages: space.stages.map((s) => ({
+			...s,
+			options: s.options.filter((o) => supportsShapes(o, shapes))
+		})),
+		...space.parts === void 0 ? {} : { parts: space.parts.map((p) => restrict(p, shapes)) }
+	};
+}
+/** This function throws a `RangeError` for a list of shape kinds with a kind that is not declared. */
+function assertShapes(shapes) {
+	if (shapes === void 0) return;
+	if (!Array.isArray(shapes)) throw new RangeError("The option shapes is not a list of shape kinds.");
+	for (const k of shapes) if (!isShapeKind(k)) throw new RangeError(`The shape kind ${show(k)} is not one of ${SHAPE_KIND_IDS.join(", ")}.`);
+}
+/** This function gives the count of the grid points of a space that is known to be good. */
+function sizeOf(space, levels, limit) {
 	let base = 0n;
 	let meta = 0n;
-	for (const c of combos(space, options.levels, true, limit)) if (c.base) base += c.weight;
+	for (const c of combos(space, levels, true, limit)) if (c.base) base += c.weight;
 	else meta = meta === null || c.weight === null || meta + c.weight > limit ? null : meta + c.weight;
 	return {
 		base,
@@ -2163,14 +2385,12 @@ function* product(lists, i = 0, acc = []) {
 	}
 }
 /** This function gives the configs of the grid of a space, without meta options. */
-function gridConfigs(space, levels, limit) {
-	const size = spaceSize(space, {
-		levels,
-		maxMeta: 0n
-	}).base;
+function gridConfigs(space, levels, limit, shapes) {
+	const kept = restrict(space, shapes);
+	const size = sizeOf(kept, levels, 0n).base;
 	if (size > BigInt(limit)) throw new RangeError(`The grid of the space ${space.engine} has ${size} configs, more than the limit ${limit}.`);
 	const out = [];
-	for (const c of combos(space, levels, false, 0n)) {
+	for (const c of combos(kept, levels, false, 0n)) {
 		const names = [...c.choices.keys()];
 		const lists = names.map((k) => {
 			const o = c.choices.get(k);
@@ -2218,6 +2438,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 	const lists = stages.map((s) => {
 		const list = s.options.filter((o) => meta || o.members === void 0);
 		if (s.optional) list.push(null);
+		if (list.length === 0) throw new Error(`The stage ${s.name} of the space ${space.engine} has no option for a sample. A shape filter can remove all of its options.`);
 		return list;
 	});
 	const points = [];
@@ -2294,12 +2515,14 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 * - 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.
 */
 function enumerateSpace(space, options) {
 	assertSpace(space);
+	assertShapes(options.shapes);
 	if (options.mode === "grid") {
 		assertWhole(options.levels, "levels", 1);
-		return gridConfigs(space, options.levels, options.limit ?? 1e5);
+		return gridConfigs(space, options.levels, options.limit ?? 1e5, options.shapes);
 	}
 	if (options.mode !== "sample") throw new RangeError(`The mode ${String(options.mode)} is not grid or sample.`);
 	assertWhole(options.n, "n", 0);
@@ -2307,7 +2530,15 @@ function enumerateSpace(space, options) {
 	const meta = options.meta ?? "skip";
 	if (meta !== "skip" && meta !== "sample") throw new RangeError(`The option meta is ${String(meta)}, not skip or sample.`);
 	if (options.n === 0) return [];
-	return sampleConfigs(space, options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1e3, 100 * options.n));
+	return sampleConfigs(restrict(space, options.shapes), options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1e3, 100 * options.n));
+}
+/**
+* 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.
+*/
+function spaceShapeKinds(space) {
+	assertSpace(space);
+	return SHAPE_KIND_IDS.filter((k) => sizeOf(restrict(space, [k]), 1, 0n).base > 0n);
 }
 /**
 * This function joins configs of the parts of a product space into one config of the space `space`.
@@ -2410,6 +2641,25 @@ function signP(wins, losses) {
 	}
 	return Math.min(1, 2 * tail / 2 ** n);
 }
+/** This function gives the breadth of a verdict with the side `side`: 1, -1, or 0 for no side. */
+function breadthOf(families, side) {
+	const ties = families.filter((f) => f.sign === 0).length;
+	return {
+		against: side === 0 ? 0 : families.filter((f) => f.sign === -side).length,
+		of: families.length,
+		ties
+	};
+}
+/** This function gives the line of a verdict: its label, its scope and its breadth (`docs/VERDICT.md`). */
+function summaryOf(label, side, breadth) {
+	const ties = breadth.ties === 0 ? "" : ` (${breadth.ties} ${breadth.ties === 1 ? "tie" : "ties"})`;
+	const word = side > 0 ? "better" : "worse";
+	const other = side > 0 ? "worse" : "better";
+	const count = breadth.against === 0 ? "none" : String(breadth.against);
+	if (label === "better" || label === "worse") return `${label} on these families, ${other} on ${count} of ${breadth.of}${ties}`;
+	if (side === 0) return `${label}: the family mean is 0, on ${breadth.of} families${ties}`;
+	return `${label}: ${word} on the family mean, ${other} on ${count} of ${breadth.of}${ties}`;
+}
 /** 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. */
@@ -2468,6 +2718,7 @@ function pairsOf(records, options) {
 * - `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`.
 */
@@ -2562,6 +2813,8 @@ function verdict(records, options) {
 	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";
+	const breadth = breadthOf(families, sign);
+	const summary = summaryOf(label, sign, breadth);
 	return {
 		measure: measure.id,
 		n,
@@ -2572,9 +2825,12 @@ function verdict(records, options) {
 		signTest,
 		agree,
 		label,
+		scope: "these families",
+		breadth,
+		summary,
 		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 };
+export { DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, JOINT_MEASURES, JOINT_MOVED_MIN, PACK_HARD_RULES, RECORD_EPS, RECORD_SCALE, SHAPE_KINDS, SHAPE_KIND_IDS, 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, checkShapes, checkSpace, checkSplit, compareMeasure, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, enumerateSpace, exercised, familyOf, fnv1a32, grow, isShapeKind, itemShapeOf, joinConfigs, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramLevels, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, shapeKindOf, shapeKindProblem, shapeKindsOf, shapesOf, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
 
 //# sourceMappingURL=index.js.map