@mark1russell7/layout-contract 0.2.15 → 0.2.16

package/README.md

@@ -8,8 +8,8 @@ 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` |
+| Geometry | `Point`, `Rect`, `Region`, `Side`, `Sides`, `Margin`, `marginSides`, `grow`, `boundsOf`, `regionArea`, `translate`, `overlapOf` |
+| The shape kinds | `ShapeKind`, `SHAPE_KINDS`, `SHAPE_KIND_IDS`, `ShapeKindSpec`, `ShapeGeometry`, `DEFAULT_SHAPES`, `ShapeSupport`, `RuleLevel`, `ShapeCheck`, `isShapeKind`, `shapeKindOf`, `shapeKindsOf`, `itemShapeOf`, `shapeKindProblem`, `shapesOf`, `ruleLevel`, `shapeSupportProblems`, `boxArea`, `checkShapes` |
 | The input `layout-input/1` | `LayoutInput`, `LayoutBox` (`Item` for the packer), `Port`, `portPoint`, `LayoutEdge`, `LayoutContainer`, `Obstacle`, `LayoutCell`, `LayoutGenerator`, `PairGap`, `canonicalInput` |
 | The packer | `PackInput`, `toPackInput`, `Placement`, `PackOutput`, `StageTrace`, `applyPack` |
 | The record `layout-record/1` | `LayoutRecord`, `Stage`, `Supports`, `RunFacts`, `RunEnv`, `toLayoutRecord` |
@@ -54,6 +54,12 @@ The package has no runtime dependencies.
 - **The container rule.** `in-container` counts each box that goes out of the container made smaller by `inset`. The box counts with its margin. By default, a shaped container counts as its bounding box.
 - **The exact container.** Give `{ exactContainer: true }` to `packHard` or `countOutside`. Then a box of a shaped container with the size `fixed` must stay inside the shape. A cut corner, a notch and a hole count. A container with a free side keeps the bounding test. The default changes to the exact test at the next breaking version.
 - **The shape kinds.** An item is a `rect`, a `polygon`, a `circle` or a `free` shape. Each measure and rule declares its kinds. `checkShapes` refuses the other kinds. `docs/SHAPES.md` tells the rules.
+  - `regionArea(region)` gives the exact area of a region. `boxArea(box)` gives the exact area of a box, or `undefined` for a `free` box. A box with an ellipse shape is `free`.
+  - `ShapeSupport.safe` lists the kinds with a safe count: an upper bound that does not miss a break. `ruleLevel(rule, kind)` gives `exact`, `safe` or `none`.
+  - `no-overlap` and `in-container` are safe on `polygon`, `circle` and `free`. `checkShapes` accepts a safe kind only with `{ level: "safe" }`.
+  - `shapeSupportProblems(uses)` refuses a kind in `shapes` and in `safe`.
+  - `MemberRule.view: "bounds"` gives the members of a meta option the bounding box of each item. A shape filter then checks the members with `rect`.
+- **The corpus dimensions.** `CorpusDimension.precision` is the count of decimal places of a numeric value of a family. The registry rounds the value and the default to it before the `invalidates` compare. `docs/CORPUS.md` tells the rules.
 - **The output hash.** `outputHash` gives the first 16 hex characters of the SHA-256 of the canonical JSON of an output. Each number goes to the grid of `RECORD_EPS` first.
 - **The corpus checks.** `checkDeclared` and `checkSplit` give a list of `ClaimBreak`. An empty list tells that each claim is true. `corpusHashOf` gives the corpus hash of `packing`.
 - **The verdict.** `verdict` compares two strategies on one measure, with the family as the unit. A verdict counts only when it holds for the mean of the family means and for the mean of the inputs.

package/build/index.d.ts

@@ -54,6 +54,11 @@ export declare function marginSides(margin: Margin | undefined): Sides;
 export declare function grow(rect: Rect, margin: Margin | undefined): Rect;
 /** This function gives the bounding box of a region. */
 export declare function boundsOf(region: Region): Rect;
+/**
+ * This function gives the exact area of a region. A `rect` gives `w` by `h`, a circle gives `PI * r * r`, and an ellipse gives `PI * rx * ry`.
+ * A polygon gives the absolute value of the shoelace formula, less the area of each hole. A ring with fewer than 3 points has the area 0.
+ */
+export declare function regionArea(region: Region): number;
 /** This function gives the region moved by `dx` and `dy`. */
 export declare function translate(region: Region, dx: number, dy: number): Region;
 /**
@@ -370,7 +375,7 @@ export type ShapeKind = "rect" | "polygon" | "circle" | "free";
 export interface ShapeGeometry {
   /** The bounding box: `boundsOf` and `placedRect`. */
   readonly bounds: boolean;
-  /** The area of the shape. */
+  /** The area of the shape: `regionArea` and `boxArea`. */
   readonly area: boolean;
   /** The test that the shape is inside a region: `rectInRegion` for a `rect`. */
   readonly contains: boolean;
@@ -386,7 +391,10 @@ export interface ShapeKindSpec {
   readonly regions: readonly Region["kind"][];
   readonly geometry: ShapeGeometry;
 }
-/** The declared shape kinds, in their order. Only `rect` has all of its geometry. The other kinds have their bounding box only. */
+/**
+ * The declared shape kinds, in their order. Only `rect` has all of its geometry.
+ * `polygon` and `circle` have their bounding box and their exact area. `free` has its bounding box only.
+ */
 export declare const SHAPE_KINDS: readonly ShapeKindSpec[];
 /** The ids of `SHAPE_KINDS`, in their order. */
 export declare const SHAPE_KIND_IDS: readonly ShapeKind[];
@@ -395,8 +403,23 @@ export declare const DEFAULT_SHAPES: readonly ShapeKind[];
 /** A measure or a rule, with the shape kinds that it supports. Without `shapes`, it supports `DEFAULT_SHAPES`. */
 export interface ShapeSupport<Id extends string = string> {
   readonly id: Id;
+  /** The kinds with an exact count or value. */
   readonly shapes?: readonly ShapeKind[];
+  /**
+   * The kinds with a safe count: the rule can count a break that is not real, but it does not miss a real break.
+   * Thus a safe count of 0 tells that the rule has no break. A kind is in `shapes` or in `safe`, not in the two lists.
+   */
+  readonly safe?: readonly ShapeKind[];
 }
+/** The level of a rule on a shape kind: an exact count, a safe count (an upper bound), or no support. */
+export type RuleLevel = "exact" | "safe" | "none";
+/** This function gives the level of a rule on a shape kind. A kind of `shapesOf` is `exact`, a kind of `safe` is `safe`, and another kind is `none`. */
+export declare function ruleLevel(rule: Pick<ShapeSupport, "shapes" | "safe">, kind: ShapeKind): RuleLevel;
+/**
+ * This function gives the problems of a list of measures and rules. An empty list tells that the list is good.
+ * It refuses an unknown kind, a kind two times in one list, and a kind in `safe` that is also in `shapesOf`.
+ */
+export declare function shapeSupportProblems(uses: readonly ShapeSupport[]): string[];
 /** This function tells if a value is a declared shape kind. */
 export declare function isShapeKind(value: unknown): value is ShapeKind;
 /**
@@ -404,6 +427,13 @@ export declare function isShapeKind(value: unknown): value is ShapeKind;
  * Without it, the kind comes from `shape`: no shape is a `rect`, and an ellipse is `free`.
  */
 export declare function shapeKindOf(box: LayoutBox): ShapeKind;
+/**
+ * This function gives the exact area of a box, or `undefined` when the contract knows only its bounding box.
+ * A box with `shape` gives `regionArea` of the shape. A `rect` box without `shape` gives `w` by `h`.
+ * A box of the kind `free` gives `undefined`, also with a shape. Thus a box with an ellipse shape gives `undefined`, because `shapeKindOf` makes an ellipse `free`.
+ * A box of another kind without `shape` is a bad input, and gives `undefined`.
+ */
+export declare function boxArea(box: LayoutBox): number | undefined;
 /** This function gives the shape kinds of the boxes of an input, in the order of `SHAPE_KINDS`. An input without boxes gives an empty list. */
 export declare function shapeKindsOf(input: Pick<LayoutInput, "boxes">): ShapeKind[];
 /** This function gives the value of the cell dimension `itemShape` of an input: its one kind, `mixed` for more kinds, or `rect` without boxes. */
@@ -412,11 +442,20 @@ export declare function itemShapeOf(input: Pick<LayoutInput, "boxes">): ShapeKin
 export declare function shapeKindProblem(box: LayoutBox): string | undefined;
 /** This function gives the shape kinds that a measure or a rule supports. */
 export declare function shapesOf(use: Pick<ShapeSupport, "shapes">): readonly ShapeKind[];
+/** The options of `checkShapes`. */
+export interface ShapeCheck {
+  /**
+   * The lowest level of a rule that `checkShapes` accepts. The default `exact` refuses a kind with only a safe count.
+   * The value `safe` also accepts a kind of `safe`. Use it only when the run claims that a rule has no break.
+   */
+  readonly level?: "exact" | "safe";
+}
 /**
  * This function checks that each measure and each rule of a run supports each shape kind of the input. An empty list tells that the run is good.
  * Each break has the claim `shape`, the id of the input, and the first 5 ids of the boxes of the kind.
+ * By default, a kind of `safe` is a break, because the count of the rule is not exact. With the level `safe`, it is not a break.
  */
-export declare function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[]): ClaimBreak[];
+export declare function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[], options?: ShapeCheck): ClaimBreak[];
 /** The epsilon for the float compares in an engine. */
 export declare const EPS = 1e-6;
 /**
@@ -590,6 +629,7 @@ export interface PackHard {
 /**
  * The hard rules of a pack, with the shape kinds that each rule supports.
  * `no-overlap` and `in-container` test the bounding box of a shape. That count is exact only for a `rect`.
+ * For the other kinds, the count is safe: a shape is inside its bounding box, so the count is an upper bound. A count of 0 tells that the rule has no break.
  * `locked-kept` and `complete` read only the positions and the ids, so they support each kind.
  */
 export declare const PACK_HARD_RULES: readonly ShapeSupport<keyof PackHard>[];
@@ -991,6 +1031,11 @@ export interface MemberRule {
    * With `pool`, a config of the option has the members of one entry, and `spaceSize` counts each entry one time.
    */
   readonly pool?: readonly (readonly StrategyConfig[])[];
+  /**
+   * The view of the items that the members get. With `bounds`, the option gives its members the bounding box of each item.
+   * Then a shape filter checks the members with the kind `rect`, and the option itself with the kinds of the input. Without `view`, the members get the kinds of the input.
+   */
+  readonly view?: "bounds";
 }
 /** The inputs that an option supports. A missing field supports each value. */
 export interface OptionSupports {
@@ -1102,6 +1147,7 @@ export declare function paramValue(param: SpaceParam, value: ParamValue): ParamV
  *
  * A member list that is not an entry of the `pool` of its option gives the claim `pool`.
  * With `shapes`, an option that does not support a kind of the list gives the claim `shape`. A member of a meta option gets the same check.
+ * A member of an option with `view: "bounds"` gets the check with the kind `rect`.
  */
 export declare function checkConfig(space: StrategySpace, config: StrategyConfig, options?: ShapeFilter): ClaimBreak[];
 /**
@@ -1316,6 +1362,12 @@ export interface CorpusDimension extends SpaceParam {
    * Then `generate` of a registry removes these fields from the output, and lists them in `invalidated`.
    */
   readonly invalidates?: readonly string[];
+  /**
+   * The count of decimal places that the family uses for a value of a numeric dimension: a whole number of 0 or more.
+   * Only the `invalidates` compare reads it. The registry rounds the value and the default to it before the compare.
+   * The cells, the cell keys, `rngOf` and the value that `generate` gets do not change.
+   */
+  readonly precision?: number;
 }
 /**
  * The supported values of a dimension (`CorpusDimension.supported`).
@@ -1446,14 +1498,14 @@ export declare const DEFAULT_FAMILY_BY: FamilyBy;
 export declare const CORPUS_DIMENSIONS: Readonly<Record<string, CorpusDimension>>;
 /**
  * This function gives a dimension of `CORPUS_DIMENSIONS`, with the fields of `patch` over it. It throws a `RangeError` for an unknown name.
- * With `supported` or `invalidates` in the patch, it also throws a `RangeError` for a bad dimension, as `ownerDimension` does.
+ * With `supported`, `invalidates` or `precision` in the patch, it also throws a `RangeError` for a bad dimension, as `ownerDimension` does.
  */
 export declare function sharedDimension(name: string, patch?: Partial<CorpusDimension>): CorpusDimension;
 /** The fields of a dimension that the owner declares: each field of `CorpusDimension` but the name. */
 export type OwnerDimensionSpec = Omit<CorpusDimension, "name">;
 /**
  * This function gives a dimension that only its owner declares, for example `cut` of a family of `packing`.
- * It throws a `RangeError` for a name of `CORPUS_DIMENSIONS`, the reserved name `kind`, or a bad default, level, `supported` or `invalidates`.
+ * It throws a `RangeError` for a name of `CORPUS_DIMENSIONS`, the reserved name `kind`, or a bad default, level, `supported`, `invalidates` or `precision`.
  * The registry examines the `when` of the dimension, because it needs the earlier dimensions.
  */
 export declare function ownerDimension(name: string, spec: OwnerDimensionSpec): CorpusDimension;

package/build/index.d.ts.map

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

package/build/index.js

@@ -73,6 +73,28 @@ function boundsOf(region) {
 		}
 	}
 }
+/**
+* This function gives the exact area of a region. A `rect` gives `w` by `h`, a circle gives `PI * r * r`, and an ellipse gives `PI * rx * ry`.
+* A polygon gives the absolute value of the shoelace formula, less the area of each hole. A ring with fewer than 3 points has the area 0.
+*/
+function regionArea(region) {
+	switch (region.kind) {
+		case "rect": return region.w * region.h;
+		case "circle": return Math.PI * region.r * region.r;
+		case "ellipse": return Math.PI * region.rx * region.ry;
+		case "polygon": return (region.holes ?? []).reduce((area, hole) => area - ringArea(hole), ringArea(region.points));
+	}
+}
+/** This function gives the area of one ring of a polygon: the absolute value of the shoelace formula. */
+function ringArea(ring) {
+	let twice = 0;
+	for (let i = 0; i < ring.length; i++) {
+		const [ax, ay] = ring[i];
+		const [bx, by] = ring[(i + 1) % ring.length];
+		twice += ax * by - bx * ay;
+	}
+	return Math.abs(twice) / 2;
+}
 /** This function gives the region moved by `dx` and `dy`. */
 function translate(region, dx, dy) {
 	switch (region.kind) {
@@ -111,7 +133,10 @@ function overlapOf(a, b) {
 	};
 }
 // 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. */
+/**
+* The declared shape kinds, in their order. Only `rect` has all of its geometry.
+* `polygon` and `circle` have their bounding box and their exact area. `free` has its bounding box only.
+*/
 const SHAPE_KINDS = Object.freeze([
 	{
 		id: "rect",
@@ -130,7 +155,7 @@ const SHAPE_KINDS = Object.freeze([
 		regions: ["polygon"],
 		geometry: {
 			bounds: true,
-			area: false,
+			area: true,
 			contains: false,
 			overlap: false
 		}
@@ -145,7 +170,7 @@ const SHAPE_KINDS = Object.freeze([
 		regions: ["circle"],
 		geometry: {
 			bounds: true,
-			area: false,
+			area: true,
 			contains: false,
 			overlap: false
 		}
@@ -175,6 +200,35 @@ const SHAPE_KINDS = Object.freeze([
 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"]);
+/** This function gives the level of a rule on a shape kind. A kind of `shapesOf` is `exact`, a kind of `safe` is `safe`, and another kind is `none`. */
+function ruleLevel(rule, kind) {
+	if (shapesOf(rule).includes(kind)) return "exact";
+	return rule.safe?.includes(kind) === true ? "safe" : "none";
+}
+/**
+* This function gives the problems of a list of measures and rules. An empty list tells that the list is good.
+* It refuses an unknown kind, a kind two times in one list, and a kind in `safe` that is also in `shapesOf`.
+*/
+function shapeSupportProblems(uses) {
+	const out = [];
+	for (const use of uses) {
+		for (const [name, list] of [["shapes", use.shapes], ["safe", use.safe]]) {
+			if (list === void 0) continue;
+			if (!Array.isArray(list)) {
+				out.push(`${use.id}: the ${name} value is not a list of shape kinds`);
+				continue;
+			}
+			list.forEach((k, i) => {
+				if (!isShapeKind(k)) out.push(`${use.id}: the ${name} kind ${String(k)} is not a declared kind`);
+				else if (list.indexOf(k) !== i) out.push(`${use.id}: the ${name} list has the kind ${k} two times`);
+			});
+		}
+		if (!Array.isArray(use.safe)) continue;
+		const exact = use.shapes === void 0 ? DEFAULT_SHAPES : Array.isArray(use.shapes) ? use.shapes : [];
+		for (const k of new Set(use.safe)) if (exact.includes(k)) out.push(`${use.id}: the kind ${String(k)} is in shapes and in safe`);
+	}
+	return out;
+}
 const REGION_KIND = {
 	rect: "rect",
 	polygon: "polygon",
@@ -193,6 +247,18 @@ 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 exact area of a box, or `undefined` when the contract knows only its bounding box.
+* A box with `shape` gives `regionArea` of the shape. A `rect` box without `shape` gives `w` by `h`.
+* A box of the kind `free` gives `undefined`, also with a shape. Thus a box with an ellipse shape gives `undefined`, because `shapeKindOf` makes an ellipse `free`.
+* A box of another kind without `shape` is a bad input, and gives `undefined`.
+*/
+function boxArea(box) {
+	const kind = shapeKindOf(box);
+	if (kind === "free") return void 0;
+	if (box.shape !== void 0) return regionArea(box.shape);
+	return kind === "rect" ? box.w * box.h : void 0;
+}
 /** 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));
@@ -219,19 +285,22 @@ function shapesOf(use) {
 /**
 * This function checks that each measure and each rule of a run supports each shape kind of the input. An empty list tells that the run is good.
 * Each break has the claim `shape`, the id of the input, and the first 5 ids of the boxes of the kind.
+* By default, a kind of `safe` is a break, because the count of the rule is not exact. With the level `safe`, it is not a break.
 */
-function checkShapes(input, uses) {
+function checkShapes(input, uses, options = {}) {
 	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 level = ruleLevel(use, kind);
+			if (level === "exact" || level === "safe" && options.level === "safe") 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` : "");
+			const safe = level === "safe" ? `. The count of ${use.id} on ${kind} is only safe` : "";
 			out.push({
 				claim: "shape",
-				detail: `${use.id} supports only the shape kinds ${shapes.join(", ") || "(none)"}, but the input ${input.id} has ${kind} boxes: ${shown}`,
+				detail: `${use.id} supports only the shape kinds ${shapes.join(", ") || "(none)"}, but the input ${input.id} has ${kind} boxes: ${shown}${safe}`,
 				inputs: [input.id]
 			});
 		}
@@ -585,16 +654,27 @@ function countPortsOffBorder(boxes, eps = RECORD_EPS) {
 /**
 * The hard rules of a pack, with the shape kinds that each rule supports.
 * `no-overlap` and `in-container` test the bounding box of a shape. That count is exact only for a `rect`.
+* For the other kinds, the count is safe: a shape is inside its bounding box, so the count is an upper bound. A count of 0 tells that the rule has no break.
 * `locked-kept` and `complete` read only the positions and the ids, so they support each kind.
 */
 const PACK_HARD_RULES = Object.freeze([
 	{
 		id: "no-overlap",
-		shapes: ["rect"]
+		shapes: ["rect"],
+		safe: [
+			"polygon",
+			"circle",
+			"free"
+		]
 	},
 	{
 		id: "in-container",
-		shapes: ["rect"]
+		shapes: ["rect"],
+		safe: [
+			"polygon",
+			"circle",
+			"free"
+		]
 	},
 	{
 		id: "locked-kept",
@@ -2085,6 +2165,8 @@ function optionProblems(stage, o) {
 		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`]);
 		const pool = o.members.pool;
 		if (pool !== void 0 && (!Array.isArray(pool) || pool.length === 0 || !pool.every((entry) => Array.isArray(entry)))) out.push(["pool", `${at} has a pool that is not a list of one or more member lists`]);
+		const view = o.members.view;
+		if (view !== void 0 && view !== "bounds") out.push(["view", `${at} has the member view ${show(view)}, not "bounds"`]);
 	}
 	return out;
 }
@@ -2103,6 +2185,15 @@ function supportsProblems(supports, at) {
 }
 /** 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));
+/** The shape kinds that the members of an option with `view: "bounds"` see: a bounding box is a `rect`. */
+const BOUNDS_VIEW = Object.freeze(["rect"]);
+/**
+* This function gives the shape kinds of the members of a meta option. With `view: "bounds"`, a list with a kind becomes `BOUNDS_VIEW`.
+* Without a list, or with an empty list, the value does not change.
+*/
+const memberShapes = (rule, shapes) => rule.view === "bounds" && shapes !== void 0 && shapes.length > 0 ? BOUNDS_VIEW : shapes;
+/** This function tells if two lists have the same shape kinds. */
+const sameKinds = (a, b) => a.every((k) => b.includes(k)) && b.every((k) => a.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`]];
@@ -2176,7 +2267,7 @@ function configProblems(space, config, member, shapes) {
 			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, shapes));
+		out.push(...memberProblems(partOf(space, s.name).space, o.members, c["members"], at, memberShapes(o.members, shapes)));
 	}
 	for (const c of space.constraints ?? []) if (!holds(c, chosen)) out.push(["constraint", `the config breaks the constraint ${describe(c)}`]);
 	return out;
@@ -2239,6 +2330,7 @@ const toBreaks = (problems, inputs = []) => problems.map(([claim, detail]) => ({
 *
 * A member list that is not an entry of the `pool` of its option gives the claim `pool`.
 * With `shapes`, an option that does not support a kind of the list gives the claim `shape`. A member of a meta option gets the same check.
+* A member of an option with `view: "bounds"` gets the check with the kind `rect`.
 */
 function checkConfig(space, config, options = {}) {
 	return toBreaks(configProblems(space, config, false, options.shapes));
@@ -2499,7 +2591,9 @@ function combos(space, levels, meta, limit) {
 	for (const s of stages) for (const o of s.options) {
 		if (o.members === void 0) continue;
 		const choices = new Map(stages.map((x) => [x.name, x === s ? o : null]));
-		const lists = o.members.pool === void 0 ? memberLists(base, o.members, limit) : BigInt(o.members.pool.length);
+		const own = memberSpaces.get(o);
+		const from = own === void 0 ? base : baseCount(own, levels, limit);
+		const lists = o.members.pool === void 0 ? memberLists(from, o.members, limit) : BigInt(o.members.pool.length);
 		if (keeps(space, choices)) out.push({
 			choices,
 			base: false,
@@ -2524,6 +2618,8 @@ function spaceSize(space, options) {
 * 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.
 * A pool keeps only the entries whose members fit the smaller space. A meta option without such an entry goes out.
+*
+* The members of an option with `view: "bounds"` come from the space for the kinds of `memberShapes`. `memberSpaces` keeps that space.
 */
 function restrict(space, shapes) {
 	if (shapes === void 0) return space;
@@ -2536,16 +2632,23 @@ function restrict(space, shapes) {
 		...space.parts === void 0 ? {} : { parts: space.parts.map((p) => restrict(p, shapes)) }
 	};
 	const withPool = (s, o) => {
-		if (o.members?.pool === void 0) return [o];
-		const part = partOf(kept, s.name).space;
+		if (o.members === void 0) return [o];
+		const inner = memberShapes(o.members, shapes);
+		const own = sameKinds(inner, shapes) ? void 0 : restrict(partOf(space, s.name).space, inner);
+		const mark = (option) => {
+			if (own !== void 0) memberSpaces.set(option, own);
+			return [option];
+		};
+		if (o.members.pool === void 0) return own === void 0 ? [o] : mark({ ...o });
+		const part = own ?? partOf(kept, s.name).space;
 		const pool = o.members.pool.filter((entry) => fits(part, entry));
-		return pool.length === 0 ? [] : [{
+		return pool.length === 0 ? [] : mark({
 			...o,
 			members: {
 				...o.members,
 				pool
 			}
-		}];
+		});
 	};
 	return {
 		...kept,
@@ -2555,6 +2658,10 @@ function restrict(space, shapes) {
 		}))
 	};
 }
+/** The space of the members of a meta option of a restricted space, when it is not the part of the option. Only `view: "bounds"` makes such a space. */
+const memberSpaces = /* @__PURE__ */ new WeakMap();
+/** This function gives the count of the base configs of a space that is known to be good. */
+const baseCount = (space, levels, limit) => combos(space, levels, false, limit).reduce((sum, c) => sum + c.weight, 0n);
 /** 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;
@@ -2631,13 +2738,18 @@ function sampleValue(p, u) {
 }
 /** This function gives a seed of 32 bits from a seed and a step name. */
 const subSeed = (seed, step) => Math.floor(stepRandom(seed, step)() * 4294967296);
-/** This function gives a sample of a space: Latin hypercube strata over the options, the params and the member counts. */
-function sampleConfigs(space, n, seed, meta, maxTries) {
+/**
+* This function gives a sample of a space: Latin hypercube strata over the options, the params and the member counts.
+* `canon` is the space of `canonicalConfig`: the space before a shape filter. A member of an option with `view: "bounds"` can have an option that the filter removed.
+*/
+function sampleConfigs(space, n, seed, meta, maxTries, canon = space) {
 	const stages = space.stages;
 	const prefix = prefixes(space);
+	const bounded = new Set(stages.filter((s) => meta && s.options.some((o) => memberSpaces.has(o))).map((s) => prefix.get(s.name)));
 	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 && bounded.has(prefix.get(s.name))) 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;
 	});
@@ -2656,7 +2768,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 				const m = metaPart.get(prefix.get(s.name));
 				if (m !== void 0 && m !== s.name) choices.set(s.name, null);
 			}
-			if (keeps(space, choices)) points.push(choices);
+			if (stages.every((s) => s.optional === true || choices.get(s.name) !== null || metaPart.has(prefix.get(s.name))) && keeps(space, choices)) points.push(choices);
 		}
 	}
 	const values = points.map(() => stages.map(() => ({})));
@@ -2681,7 +2793,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 				});
 				continue;
 			}
-			const part = partOf(space, s.name).space;
+			const part = memberSpaces.get(o) ?? partOf(space, s.name).space;
 			const poolSize = Math.max(n, 4 * o.members.max, 8);
 			const seen = /* @__PURE__ */ new Set();
 			const pool = sampleConfigs(part, poolSize, subSeed(seed, `pool:${s.name}:${o.id}`), false, Math.max(1e3, 100 * poolSize)).filter((c) => {
@@ -2711,7 +2823,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 				members: members[i][k]
 			};
 		});
-		return canonicalConfig(space, {
+		return canonicalConfig(canon, {
 			space: space.engine,
 			stages: out
 		});
@@ -2739,7 +2851,7 @@ 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(restrict(space, options.shapes), 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), space);
 }
 /**
 * 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.
@@ -3193,7 +3305,7 @@ const CORPUS_DIMENSIONS = Object.freeze({
 });
 /**
 * This function gives a dimension of `CORPUS_DIMENSIONS`, with the fields of `patch` over it. It throws a `RangeError` for an unknown name.
-* With `supported` or `invalidates` in the patch, it also throws a `RangeError` for a bad dimension, as `ownerDimension` does.
+* With `supported`, `invalidates` or `precision` in the patch, it also throws a `RangeError` for a bad dimension, as `ownerDimension` does.
 */
 function sharedDimension(name, patch = {}) {
 	const base = Object.hasOwn(CORPUS_DIMENSIONS, name) ? CORPUS_DIMENSIONS[name] : void 0;
@@ -3203,12 +3315,12 @@ function sharedDimension(name, patch = {}) {
 		...patch,
 		name
 	});
-	if (patch.supported !== void 0 || patch.invalidates !== void 0) throwProblems(`sharedDimension: the dimension "${name}"`, ownProblems(dim));
+	if (patch.supported !== void 0 || patch.invalidates !== void 0 || patch.precision !== void 0) throwProblems(`sharedDimension: the dimension "${name}"`, ownProblems(dim));
 	return dim;
 }
 /**
 * This function gives a dimension that only its owner declares, for example `cut` of a family of `packing`.
-* It throws a `RangeError` for a name of `CORPUS_DIMENSIONS`, the reserved name `kind`, or a bad default, level, `supported` or `invalidates`.
+* It throws a `RangeError` for a name of `CORPUS_DIMENSIONS`, the reserved name `kind`, or a bad default, level, `supported`, `invalidates` or `precision`.
 * The registry examines the `when` of the dimension, because it needs the earlier dimensions.
 */
 function ownerDimension(name, spec) {
@@ -3252,7 +3364,7 @@ function supportedText(dim) {
 	if (isSupportedList(s)) return s.map((v) => JSON.stringify(v)).join(", ");
 	return `the values from ${s.min ?? dim.min} to ${s.max ?? dim.max}`;
 }
-/** This function gives the problems of one dimension that need no other dimension: the default, the levels, `supported` and `invalidates`. */
+/** This function gives the problems of one dimension that need no other dimension: the default, the levels, `supported`, `invalidates` and `precision`. */
 function ownProblems(d) {
 	const out = [];
 	const bad = paramProblem(d, d.default);
@@ -3263,6 +3375,7 @@ function ownProblems(d) {
 	}
 	out.push(...supportProblems(d, bad === void 0));
 	out.push(...invalidatesProblems(d));
+	out.push(...precisionProblems(d));
 	return out;
 }
 /** This function gives the problems of the `supported` values of a dimension. `goodDefault` tells that the default is a good value. */
@@ -3304,6 +3417,22 @@ function invalidatesProblems(d) {
 	for (const f of ["hash", INVALIDATED_FIELD]) if (list.includes(f)) out.push(`the invalidates of "${d.name}" has the field "${f}", which the registry writes`);
 	return out;
 }
+/** This function gives the problems of the `precision` of a dimension. A bad value and a dimension that is not numeric are problems. */
+function precisionProblems(d) {
+	const p = d.precision;
+	if (p === void 0) return [];
+	if (typeof p !== "number" || !Number.isInteger(p) || p < 0) return [`the precision of "${d.name}" is ${JSON.stringify(p)}, not a whole number of 0 or more`];
+	if (d.kind !== "int" && d.kind !== "real") return [`the precision of "${d.name}" is for a numeric dimension, but the dimension is a ${d.kind}`];
+	return [];
+}
+/** This function rounds a number to `places` decimal places: `Math.round(v * 10 ** places) / 10 ** places`. */
+const roundTo = (v, places) => Math.round(v * 10 ** places) / 10 ** places;
+/** This function tells if a value is the default of a dimension. With `precision`, it compares the two numbers after it rounds them. */
+function isDefault(d, value) {
+	const def = paramValue(d, d.default);
+	if (d.precision === void 0 || typeof value !== "number" || typeof def !== "number") return value === def;
+	return roundTo(value, d.precision) === roundTo(def, d.precision);
+}
 /** This function tells if a log scale of a range starts at 0. Then the scale is the log of `1 + x - min`. */
 const fromZero = (d) => d.scale === "log" && (d.min ?? 0) <= 0;
 /**
@@ -3459,12 +3588,15 @@ function sweepLevels(dimensions, options, where, by) {
 		return lv;
 	});
 }
-/** This function gives the output fields that the values make wrong: the `invalidates` of each dimension with a value other than its default, sorted. */
+/**
+* This function gives the output fields that the values make wrong: the `invalidates` of each dimension with a value other than its default, sorted.
+* A dimension with `precision` compares the rounded value with the rounded default.
+*/
 function invalidFields(dimensions, full) {
 	const out = /* @__PURE__ */ new Set();
 	for (const d of dimensions) {
 		if (d.invalidates === void 0 || d.invalidates.length === 0) continue;
-		if (full[d.name] !== paramValue(d, d.default)) for (const f of d.invalidates) out.add(f);
+		if (!isDefault(d, full[d.name])) for (const f of d.invalidates) out.add(f);
 	}
 	return [...out].sort(byCode);
 }
@@ -3795,6 +3927,6 @@ const RECT_SCATTERED = Object.freeze({
 		};
 	}
 });
-export { CORPUS_DIMENSIONS, DEFAULT_FAMILY_BY, DEFAULT_RNG, DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGES_STEP, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, INVALIDATED_FIELD, JOINT_MEASURES, JOINT_MOVED_MIN, PACK_HARD_RULES, RECORD_EPS, RECORD_SCALE, RECT_SCATTERED, 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, canonicalInput, canonicalJson, checkConfig, checkDeclared, checkInput, checkShapes, checkSpace, checkSplit, compareMeasure, composeFamily, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, createFamilyRegistry, declaredClaimOf, declaredCounts, dimensionAt, dimensionSupports, dimensionUnit, documentHash, edgeStep, enumerateSpace, exercised, familyKind, familyOf, fnv1a32, grow, isShapeKind, itemShapeOf, joinConfigs, leaveOneSeedOut, levelsOf, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, ownerDimension, packHard, paramActive, paramLevels, paramProblem, paramValue, pickMoves, placedRect, portPoint, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, resolveDimensions, selectBest, sha256Hex, shapeKindOf, shapeKindProblem, shapeKindsOf, shapesOf, sharedDimension, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
+export { CORPUS_DIMENSIONS, DEFAULT_FAMILY_BY, DEFAULT_RNG, DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGES_STEP, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, INVALIDATED_FIELD, JOINT_MEASURES, JOINT_MOVED_MIN, PACK_HARD_RULES, RECORD_EPS, RECORD_SCALE, RECT_SCATTERED, 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, boxArea, canonicalConfig, canonicalInput, canonicalJson, checkConfig, checkDeclared, checkInput, checkShapes, checkSpace, checkSplit, compareMeasure, composeFamily, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, createFamilyRegistry, declaredClaimOf, declaredCounts, dimensionAt, dimensionSupports, dimensionUnit, documentHash, edgeStep, enumerateSpace, exercised, familyKind, familyOf, fnv1a32, grow, isShapeKind, itemShapeOf, joinConfigs, leaveOneSeedOut, levelsOf, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, ownerDimension, packHard, paramActive, paramLevels, paramProblem, paramValue, pickMoves, placedRect, portPoint, portfolio, productSpace, randomInt, rectInRegion, regionArea, regionHitsRect, resolveDimensions, ruleLevel, selectBest, sha256Hex, shapeKindOf, shapeKindProblem, shapeKindsOf, shapeSupportProblems, shapesOf, sharedDimension, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
 
 //# sourceMappingURL=index.js.map