@mark1russell7/layout-contract 0.2.15 → 0.2.17

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,63 @@ 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`. It does not read `bound`. */
+function ruleLevel(rule, kind) {
+	if (shapesOf(rule).includes(kind)) return "exact";
+	return rule.safe?.includes(kind) === true ? "safe" : "none";
+}
+/**
+* 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`.
+*/
+function shapeLevel(use, kind) {
+	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`.
+*/
+function shapeSupportProblems(uses) {
+	const out = [];
+	for (const use of uses) {
+		const bound = use.bound;
+		const isBound = typeof bound === "object" && bound !== null && !Array.isArray(bound);
+		if (bound !== void 0 && !isBound) out.push(`${use.id}: the bound value is not an object with shapes and a side`);
+		const boundShapes = isBound ? bound.shapes : void 0;
+		for (const [name, list] of [
+			["shapes", use.shapes],
+			["safe", use.safe],
+			["bound", boundShapes]
+		]) {
+			if (list === void 0 && (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, 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 = use.shapes === void 0 ? DEFAULT_SHAPES : Array.isArray(use.shapes) ? use.shapes : [];
+		if (Array.isArray(use.safe)) {
+			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`);
+		}
+		if (!isBound) continue;
+		const side = bound.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 = Array.isArray(use.safe) ? use.safe : [];
+		for (const k of new Set(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 = {
 	rect: "rect",
 	polygon: "polygon",
@@ -193,6 +275,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 +313,23 @@ 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` 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.
 */
-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 = shapeLevel(use, kind);
+			if (level === "exact" || level === "safe" && (options.level === "safe" || options.level === "bound") || level === "bound" && options.level === "bound") 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]
 			});
 		}
@@ -585,16 +683,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 +2194,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 +2214,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 +2296,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 +2359,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 +2620,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 +2647,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 +2661,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 +2687,31 @@ 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 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, stage, o) => o.members === void 0 || o.members.pool !== void 0 || 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, meta) => 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, kept, shapes, meta) {
+	const list = (names, one, more) => names.length === 1 ? `${one} ${names[0]}` : `${more} ${names.join(", ")}`;
+	const empty = kept.stages.filter((s) => !s.optional && !s.options.some((o) => meta || o.members === void 0)).map((s) => s.name);
+	const removed = !meta ? [] : space.stages.flatMap((s) => s.options.filter((o) => o.members !== void 0 && 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 === void 0 || !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, 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,16 +2788,27 @@ 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;
 	});
+	const usable = /* @__PURE__ */ new Map();
+	const withMembers = (s, o) => {
+		if (o === null || o === void 0 || o.members === void 0) return true;
+		if (!usable.has(o)) usable.set(o, hasMembers(space, s.name, o));
+		return usable.get(o);
+	};
 	const points = [];
 	let tries = 0;
 	for (let round = 0; points.length < n; round++) {
@@ -2656,7 +2824,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) && stages.every((s) => withMembers(s, choices.get(s.name)))) points.push(choices);
 		}
 	}
 	const values = points.map(() => stages.map(() => ({})));
@@ -2681,7 +2849,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 +2879,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 				members: members[i][k]
 			};
 		});
-		return canonicalConfig(space, {
+		return canonicalConfig(canon, {
 			space: space.engine,
 			stages: out
 		});
@@ -2725,6 +2893,8 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 * - 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.
 */
 function enumerateSpace(space, options) {
 	assertSpace(space);
@@ -2739,7 +2909,13 @@ 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));
+	const kept = restrict(space, options.shapes);
+	try {
+		return sampleConfigs(kept, options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1e3, 100 * options.n), space);
+	} catch (error) {
+		if (options.shapes !== void 0 && !hasConfig(kept, meta === "sample")) throw noSample(space, kept, options.shapes, meta === "sample");
+		throw error;
+	}
 }
 /**
 * 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 +3369,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 +3379,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 +3428,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 +3439,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 +3481,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 +3652,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 +3991,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, shapeLevel, shapeSupportProblems, shapesOf, sharedDimension, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
 
 //# sourceMappingURL=index.js.map