@mark1russell7/layout-contract 0.2.15 → 0.2.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/layout-contract",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "The shared contract of the packing and highways layout engines: the input and record formats, the turn rule, margins, tolerances and hard rules.",
   "keywords": [
     "layout",

package/src/families.ts

@@ -30,6 +30,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;
 }
 
 /**
@@ -226,13 +232,14 @@ export const CORPUS_DIMENSIONS: Readonly<Record<string, CorpusDimension>> = Obje
 
 /**
  * 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 function sharedDimension(name: string, patch: Partial<CorpusDimension> = {}): CorpusDimension {
   const base = Object.hasOwn(CORPUS_DIMENSIONS, name) ? CORPUS_DIMENSIONS[name] : undefined;
   if (base === undefined) throw new RangeError(`The shared dimension table has no dimension "${name}".`);
   const dim: CorpusDimension = Object.freeze({ ...base, ...patch, name });
-  if (patch.supported !== undefined || patch.invalidates !== undefined) throwProblems(`sharedDimension: the dimension "${name}"`, ownProblems(dim));
+  if (patch.supported !== undefined || patch.invalidates !== undefined || patch.precision !== undefined)
+    throwProblems(`sharedDimension: the dimension "${name}"`, ownProblems(dim));
   return dim;
 }
 
@@ -241,7 +248,7 @@ 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 function ownerDimension(name: string, spec: OwnerDimensionSpec): CorpusDimension {
@@ -288,7 +295,7 @@ function supportedText(dim: CorpusDimension): string {
   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: CorpusDimension): string[] {
   const out: string[] = [];
   const bad = paramProblem(d, d.default);
@@ -299,6 +306,7 @@ function ownProblems(d: CorpusDimension): string[] {
   }
   out.push(...supportProblems(d, bad === undefined));
   out.push(...invalidatesProblems(d));
+  out.push(...precisionProblems(d));
   return out;
 }
 
@@ -343,6 +351,25 @@ function invalidatesProblems(d: CorpusDimension): string[] {
   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: CorpusDimension): string[] {
+  const p: unknown = d.precision;
+  if (p === undefined) 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: number, places: number): number => 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: CorpusDimension, value: ParamValue | undefined): boolean {
+  const def = paramValue(d, d.default);
+  if (d.precision === undefined || 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: SpaceParam): boolean => d.scale === "log" && (d.min ?? 0) <= 0;
 
@@ -501,12 +528,15 @@ function sweepLevels(dimensions: readonly CorpusDimension[], options: CellsOptio
   });
 }
 
-/** 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: readonly CorpusDimension[], full: DimensionValues): string[] {
   const out = new Set<string>();
   for (const d of dimensions) {
     if (d.invalidates === undefined || 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);
 }

package/src/geometry.ts

@@ -80,6 +80,34 @@ export 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 function regionArea(region: Region): number {
+  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: readonly (readonly [number, number])[]): number {
+  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`. */
 export function translate(region: Region, dx: number, dy: number): Region {
   switch (region.kind) {

package/src/measures.ts

@@ -1,4 +1,4 @@
-import { SHAPE_KIND_IDS, type ShapeKind } from "./shapes.ts";
+import { SHAPE_KIND_IDS, type ShapeBound, type ShapeKind } from "./shapes.ts";
 import { RECORD_EPS, RECORD_SCALE } from "./tolerance.ts";
 
 /** The direction of a measure: the side of the better values. */
@@ -32,6 +32,11 @@ export interface MeasureSpec<Id extends string = string> {
   readonly role?: "guard" | "change-guard" | "diagnostic" | "time";
   /** The shape kinds of the boxes that the measure supports. Without it, the measure supports only `rect`. `checkShapes` refuses the other kinds. */
   readonly shapes?: readonly ShapeKind[];
+  /**
+   * The kinds where the value is a bound of the true value, and its side. A kind is in `shapes` or in `bound.shapes`, not in the two lists.
+   * `checkShapes` refuses a bound kind by default and with `{ level: "safe" }`. With `{ level: "bound" }`, it accepts it. `docs/SHAPES.md` tells what a bound value proves for each `direction`.
+   */
+  readonly bound?: ShapeBound;
 }
 
 /** The id of a joint measure. `docs/JOINT-MEASURES.md` gives the definitions. */

package/src/rules.ts

@@ -132,11 +132,12 @@ 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 const PACK_HARD_RULES: readonly ShapeSupport<keyof PackHard>[] = Object.freeze([
-  { id: "no-overlap", shapes: ["rect"] },
-  { id: "in-container", shapes: ["rect"] },
+  { id: "no-overlap", shapes: ["rect"], safe: ["polygon", "circle", "free"] },
+  { id: "in-container", shapes: ["rect"], safe: ["polygon", "circle", "free"] },
   { id: "locked-kept", shapes: SHAPE_KIND_IDS },
   { id: "complete", shapes: SHAPE_KIND_IDS },
 ] as const);

package/src/shapes.ts

@@ -1,6 +1,6 @@
 // The shape kinds of the items (`docs/SHAPES.md`): the declared set, the kind of a box and the check of the measures and rules on a run.
 import type { ClaimBreak } from "./corpus.ts";
-import type { Region } from "./geometry.ts";
+import { regionArea, type Region } from "./geometry.ts";
 import type { LayoutBox, LayoutInput } from "./input.ts";
 
 /**
@@ -13,7 +13,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;
@@ -31,11 +31,14 @@ export interface ShapeKindSpec {
   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 const SHAPE_KINDS: readonly ShapeKindSpec[] = 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: "polygon", fields: ["points", "holes?"], regions: ["polygon"], geometry: { bounds: true, area: true, contains: false, overlap: false } },
+  { id: "circle", fields: ["cx", "cy", "r"], regions: ["circle"], geometry: { bounds: true, area: true, contains: false, overlap: false } },
   { id: "free", fields: ["w", "h", "shape?"], regions: ["rect", "polygon", "circle", "ellipse"], geometry: { bounds: true, area: false, contains: false, overlap: false } },
 ] as const);
 
@@ -48,7 +51,87 @@ export const DEFAULT_SHAPES: readonly ShapeKind[] = Object.freeze(["rect"] as co
 /** 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 kinds where the value of a measure is a bound of the true value, not the exact value. `ShapeBound` tells the side.
+   * A kind is in one list only: `shapes`, `safe` or `bound.shapes`. `docs/SHAPES.md` tells what a bound value proves.
+   */
+  readonly bound?: ShapeBound;
+}
+
+/**
+ * The kinds where a measure gives a bound of the true value, and the side of the bound.
+ * With `upper`, the value is the true value or more. With `lower`, the value is the true value or less.
+ */
+export interface ShapeBound {
+  readonly shapes: readonly ShapeKind[];
+  readonly side: "upper" | "lower";
+}
+
+/** 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`. It does not read `bound`. */
+export function ruleLevel(rule: Pick<ShapeSupport, "shapes" | "safe">, kind: ShapeKind): RuleLevel {
+  if (shapesOf(rule).includes(kind)) return "exact";
+  return rule.safe?.includes(kind) === true ? "safe" : "none";
+}
+
+/** The level of a measure or a rule on a shape kind. The level `bound` is a value on one side of the true value (`ShapeBound`). */
+export type ShapeLevel = RuleLevel | "bound";
+
+/**
+ * This function gives the level of a measure or a rule on a shape kind. It joins the lists `shapes`, `safe` and `bound.shapes`.
+ * A kind of `shapesOf` is `exact`, a kind of `safe` is `safe`, a kind of `bound.shapes` is `bound`, and another kind is `none`.
+ */
+export function shapeLevel(use: Pick<ShapeSupport, "shapes" | "safe" | "bound">, kind: ShapeKind): ShapeLevel {
+  const level = ruleLevel(use, kind);
+  if (level !== "none") return level;
+  return use.bound?.shapes.includes(kind) === true ? "bound" : "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 more than one of `shapesOf`, `safe` and `bound.shapes`.
+ * It also refuses a `bound` without a list of kinds, and a `side` that is not `upper` or `lower`.
+ */
+export function shapeSupportProblems(uses: readonly ShapeSupport[]): string[] {
+  const out: string[] = [];
+  for (const use of uses) {
+    const bound: unknown = use.bound;
+    const isBound = typeof bound === "object" && bound !== null && !Array.isArray(bound);
+    if (bound !== undefined && !isBound) out.push(`${use.id}: the bound value is not an object with shapes and a side`);
+    const boundShapes = isBound ? (bound as { readonly shapes?: unknown }).shapes : undefined;
+    for (const [name, list] of [["shapes", use.shapes], ["safe", use.safe], ["bound", boundShapes]] as const) {
+      if (list === undefined && (name !== "bound" || !isBound)) continue;
+      if (!Array.isArray(list)) {
+        out.push(`${use.id}: the ${name === "bound" ? "bound shapes" : name} value is not a list of shape kinds`);
+        continue;
+      }
+      list.forEach((k: unknown, 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`);
+      });
+    }
+    const exact: readonly unknown[] = use.shapes === undefined ? DEFAULT_SHAPES : Array.isArray(use.shapes) ? use.shapes : [];
+    if (Array.isArray(use.safe)) for (const k of new Set<unknown>(use.safe)) if (exact.includes(k)) out.push(`${use.id}: the kind ${String(k)} is in shapes and in safe`);
+    if (!isBound) continue;
+    const side: unknown = (bound as { readonly side?: unknown }).side;
+    if (side !== "upper" && side !== "lower") out.push(`${use.id}: the bound side ${String(side)} is not upper or lower`);
+    if (!Array.isArray(boundShapes)) continue;
+    const safe: readonly unknown[] = Array.isArray(use.safe) ? use.safe : [];
+    for (const k of new Set<unknown>(boundShapes)) {
+      if (exact.includes(k)) out.push(`${use.id}: the kind ${String(k)} is in shapes and in bound`);
+      if (safe.includes(k)) out.push(`${use.id}: the kind ${String(k)} is in safe and in bound`);
+    }
+  }
+  return out;
 }
 
 const REGION_KIND: Readonly<Record<Region["kind"], ShapeKind>> = { rect: "rect", polygon: "polygon", circle: "circle", ellipse: "free" };
@@ -67,6 +150,19 @@ export function shapeKindOf(box: LayoutBox): ShapeKind {
   return box.shape === undefined ? "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`.
+ */
+export function boxArea(box: LayoutBox): number | undefined {
+  const kind = shapeKindOf(box);
+  if (kind === "free") return undefined;
+  if (box.shape !== undefined) return regionArea(box.shape);
+  return kind === "rect" ? box.w * box.h : 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 function shapeKindsOf(input: Pick<LayoutInput, "boxes">): ShapeKind[] {
   const seen = new Set(input.boxes.map(shapeKindOf));
@@ -95,22 +191,38 @@ export function shapesOf(use: Pick<ShapeSupport, "shapes">): readonly ShapeKind[
   return use.shapes ?? DEFAULT_SHAPES;
 }
 
+/** The options of `checkShapes`. */
+export interface ShapeCheck {
+  /**
+   * The lowest level that `checkShapes` accepts. The default `exact` refuses a kind with only a safe count or a bound value.
+   * The value `safe` also accepts a kind of `safe`, as in 0.2.16. Use it only when the run claims that a rule has no break.
+   * The value `bound` also accepts a kind of `safe` and a kind of `bound.shapes`. Use it only when the run reads each bound value for the proofs of its side (`docs/SHAPES.md`).
+   */
+  readonly level?: "exact" | "safe" | "bound";
+}
+
 /**
  * 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` or of `bound.shapes` is a break, because the result is not exact.
+ * With the level `safe`, a kind of `safe` is not a break. With the level `bound`, a kind of `safe` and a kind of `bound.shapes` are not a break.
  */
-export function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[]): ClaimBreak[] {
+export function checkShapes(input: Pick<LayoutInput, "id" | "boxes">, uses: readonly ShapeSupport[], options: ShapeCheck = {}): ClaimBreak[] {
   const kinds = shapeKindsOf(input);
   const out: ClaimBreak[] = [];
   for (const use of uses) {
     const shapes = shapesOf(use);
     for (const kind of kinds) {
-      if (shapes.includes(kind)) continue;
+      const level = shapeLevel(use, kind);
+      const accepts = level === "exact" || (level === "safe" && (options.level === "safe" || options.level === "bound")) || (level === "bound" && options.level === "bound");
+      if (accepts) 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` : level === "bound" ? `. The value of ${use.id} is only ${use.bound!.side === "upper" ? "an upper" : "a lower"} bound for ${kind}` : "";
       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],
       });
     }

package/src/strategy-space.ts

@@ -52,6 +52,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. */
@@ -315,6 +320,8 @@ function optionProblems(stage: SpaceStage, o: StageOption): Problem[] {
     const pool: unknown = o.members.pool;
     if (pool !== undefined && (!Array.isArray(pool) || pool.length === 0 || !pool.every((entry: unknown) => Array.isArray(entry))))
       out.push(["pool", `${at} has a pool that is not a list of one or more member lists`]);
+    const view: unknown = o.members.view;
+    if (view !== undefined && view !== "bounds") out.push(["view", `${at} has the member view ${show(view)}, not "bounds"`]);
   }
   return out;
 }
@@ -337,6 +344,19 @@ function supportsProblems(supports: unknown, at: string): Problem[] {
 const supportsShapes = (o: StageOption, shapes: readonly ShapeKind[] | undefined): boolean =>
   shapes === undefined || o.supports?.shape === undefined || 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: readonly ShapeKind[] = Object.freeze(["rect"] as const);
+
+/**
+ * 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: MemberRule, shapes: readonly ShapeKind[] | undefined): readonly ShapeKind[] | undefined =>
+  rule.view === "bounds" && shapes !== undefined && shapes.length > 0 ? BOUNDS_VIEW : shapes;
+
+/** This function tells if two lists have the same shape kinds. */
+const sameKinds = (a: readonly ShapeKind[], b: readonly ShapeKind[]): boolean => 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: StageOption, params: unknown, at: string): Problem[] {
   if (params !== undefined && !isObject(params)) return [["config", `the params of ${at} are not an object`]];
@@ -411,7 +431,7 @@ function configProblems(space: StrategySpace, config: unknown, member: boolean,
       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;
@@ -473,6 +493,7 @@ const toBreaks = (problems: readonly Problem[], inputs: readonly string[] = []):
  *
  * 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 function checkConfig(space: StrategySpace, config: StrategyConfig, options: ShapeFilter = {}): ClaimBreak[] {
   return toBreaks(configProblems(space, config, false, options.shapes));
@@ -738,7 +759,9 @@ function combos(space: StrategySpace, levels: number, meta: boolean, limit: bigi
     for (const o of s.options) {
       if (o.members === undefined) continue;
       const choices = new Map<string, StageOption | null>(stages.map((x) => [x.name, x === s ? o : null]));
-      const lists = o.members.pool === undefined ? memberLists(base, o.members, limit) : BigInt(o.members.pool.length);
+      const own = memberSpaces.get(o);
+      const from = own === undefined ? base : baseCount(own, levels, limit);
+      const lists = o.members.pool === undefined ? memberLists(from, o.members, limit) : BigInt(o.members.pool.length);
       if (keeps(space, choices)) out.push({ choices, base: false, weight: times(countOf(o), lists, limit) });
     }
   return out;
@@ -761,6 +784,8 @@ export function spaceSize(space: StrategySpace, options: SpaceSizeOptions): Spac
  * 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: StrategySpace, shapes: readonly ShapeKind[] | undefined): StrategySpace {
   if (shapes === undefined) return space;
@@ -770,14 +795,61 @@ function restrict(space: StrategySpace, shapes: readonly ShapeKind[] | undefined
     ...(space.parts === undefined ? {} : { parts: space.parts.map((p) => restrict(p, shapes)) }),
   };
   const withPool = (s: SpaceStage, o: StageOption): StageOption[] => {
-    if (o.members?.pool === undefined) return [o];
-    const part = partOf(kept, s.name).space;
+    if (o.members === undefined) return [o];
+    const inner = memberShapes(o.members, shapes)!;
+    const own = sameKinds(inner, shapes) ? undefined : restrict(partOf(space, s.name).space, inner);
+    const mark = (option: StageOption): StageOption[] => {
+      if (own !== undefined) memberSpaces.set(option, own);
+      return [option];
+    };
+    if (o.members.pool === undefined) return own === undefined ? [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 ? [] : [{ ...o, members: { ...o.members, pool } }];
+    return pool.length === 0 ? [] : mark({ ...o, members: { ...o.members, pool } });
   };
   return { ...kept, stages: kept.stages.map((s) => ({ ...s, options: s.options.flatMap((o) => withPool(s, o)) })) };
 }
 
+/** 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 = new WeakMap<StageOption, StrategySpace>();
+
+/**
+ * This function tells if an option of a restricted space has a member list. A base option and a meta option with a `pool` have one.
+ * A different meta option has one when its members have a base config. `restrict` keeps only the pool entries that fit.
+ */
+const hasMembers = (space: StrategySpace, stage: string, o: StageOption): boolean =>
+  o.members === undefined || o.members.pool !== undefined || combos(memberSpaces.get(o) ?? partOf(space, stage).space, 1, false, 0n).length > 0;
+
+/** This function tells if a restricted space has a config. A base config counts. With `meta`, a meta config counts when each of its meta options has a member list. */
+const hasConfig = (space: StrategySpace, meta: boolean): boolean =>
+  combos(space, 1, meta, 0n).some((c) => c.base || [...c.choices].every(([stage, o]) => o === null || hasMembers(space, stage, o)));
+
+/** This function gives the error of a sample of a space that has no config for the shape kinds `shapes`. `kept` is the restricted space. */
+function noSample(space: StrategySpace, kept: StrategySpace, shapes: readonly ShapeKind[], meta: boolean): RangeError {
+  const list = (names: readonly string[], one: string, more: string): string => (names.length === 1 ? `${one} ${names[0]}` : `${more} ${names.join(", ")}`);
+  const empty = kept.stages.filter((s) => !s.optional && !s.options.some((o) => meta || o.members === undefined)).map((s) => s.name);
+  const removed = !meta
+    ? []
+    : space.stages.flatMap((s) =>
+        s.options
+          .filter((o) => o.members !== undefined && o.members.view !== "bounds" && supportsShapes(o, shapes))
+          .filter((o) => {
+            const own = kept.stages.find((x) => x.name === s.name)?.options.find((x) => x.id === o.id);
+            return own === undefined || !hasMembers(kept, s.name, own);
+          })
+          .map((o) => `${s.name}.${o.id}`),
+      );
+  let text = `The space ${space.engine} has no config for a sample with the shape kinds ${shapes.join(", ")}.`;
+  if (empty.length > 0) text += ` ${list(empty, "The stage", "The stages")} ${empty.length === 1 ? "has" : "have"} no option for these kinds.`;
+  if (removed.length > 0)
+    text += ` ${list(removed, "The meta option", "The meta options")} ${removed.length === 1 ? "has" : "have"} no member config for these kinds. Set members.view to "bounds" when the members see only the bounding boxes.`;
+  if (empty.length === 0 && removed.length === 0) text += " The constraints remove each config.";
+  return new RangeError(text);
+}
+
+/** This function gives the count of the base configs of a space that is known to be good. */
+const baseCount = (space: StrategySpace, levels: number, limit: bigint): bigint => 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: readonly ShapeKind[] | undefined): void {
   if (shapes === undefined) return;
@@ -854,16 +926,29 @@ function sampleValue(p: SpaceParam, u: number): ParamValue {
 /** This function gives a seed of 32 bits from a seed and a step name. */
 const subSeed = (seed: number, step: string): number => 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: StrategySpace, n: number, seed: number, meta: boolean, maxTries: number): StrategyConfig[] {
+/**
+ * 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: StrategySpace, n: number, seed: number, meta: boolean, maxTries: number, canon: StrategySpace = space): StrategyConfig[] {
   const stages = space.stages;
   const prefix = prefixes(space);
+  // A stage without options can stay empty in a part with a meta option of `view: "bounds"`, because that option replaces the stage.
+  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: (StageOption | null)[] = s.options.filter((o) => meta || o.members === undefined);
     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;
   });
+  // A meta option without a member list stays in its list, so the strata of 0.2.16 do not change. A point that chooses it draws again.
+  const usable = new Map<StageOption, boolean>();
+  const withMembers = (s: SpaceStage, o: StageOption | null | undefined): boolean => {
+    if (o === null || o === undefined || o.members === undefined) return true;
+    if (!usable.has(o)) usable.set(o, hasMembers(space, s.name, o));
+    return usable.get(o)!;
+  };
   const points: Map<string, StageOption | null>[] = [];
   let tries = 0;
   for (let round = 0; points.length < n; round++) {
@@ -882,7 +967,8 @@ function sampleConfigs(space: StrategySpace, n: number, seed: number, meta: bool
         const m = metaPart.get(prefix.get(s.name)!);
         if (m !== undefined && m !== s.name) choices.set(s.name, null);
       }
-      if (keeps(space, choices)) points.push(choices);
+      const filled = stages.every((s) => s.optional === true || choices.get(s.name) !== null || metaPart.has(prefix.get(s.name)!));
+      if (filled && keeps(space, choices) && stages.every((s) => withMembers(s, choices.get(s.name)))) points.push(choices);
     }
   }
   const values: Values[][] = points.map(() => stages.map(() => ({})));
@@ -907,7 +993,7 @@ function sampleConfigs(space: StrategySpace, n: number, seed: number, meta: bool
         });
         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 = new Set<string>();
       const pool = sampleConfigs(part, poolSize, subSeed(seed, `pool:${s.name}:${o.id}`), false, Math.max(1000, 100 * poolSize)).filter((c) => {
@@ -930,7 +1016,7 @@ function sampleConfigs(space: StrategySpace, n: number, seed: number, meta: bool
       const o = choices.get(s.name)!;
       out[s.name] = o === null ? null : o.members === undefined ? { option: o.id, params: values[i]![k]! } : { option: o.id, params: values[i]![k]!, members: members[i]![k]! };
     });
-    return canonicalConfig(space, { space: space.engine, stages: out });
+    return canonicalConfig(canon, { space: space.engine, stages: out });
   });
 }
 
@@ -942,6 +1028,8 @@ function sampleConfigs(space: StrategySpace, n: number, seed: number, meta: bool
  * - 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.
  * - A meta option with a `pool` gives only the entries of its pool. With `shapes`, only the entries whose members support each kind count.
+ * - A sample draws again when a point chooses a meta option without a member list. `spaceSize` gives such an option 0.
+ * - With `shapes`, a sample throws a `RangeError` when the space has no config for the kinds. The error names the stages without an option and the meta options without members.
  */
 export function enumerateSpace(space: StrategySpace, options: EnumerateOptions): StrategyConfig[] {
   assertSpace(space);
@@ -956,7 +1044,14 @@ export function enumerateSpace(space: StrategySpace, options: EnumerateOptions):
   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(1000, 100 * options.n));
+  const kept = restrict(space, options.shapes);
+  try {
+    return sampleConfigs(kept, options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1000, 100 * options.n), space);
+  } catch (error) {
+    // Only a space without a config for the shape kinds gives the RangeError. A different failure keeps its own error.
+    if (options.shapes !== undefined && !hasConfig(kept, meta === "sample")) throw noSample(space, kept, options.shapes, meta === "sample");
+    throw error;
+  }
 }
 
 /**