@mark1russell7/strategy-space 0.0.0-stage → 0.0.1

package/build/strategy-space.js

@@ -0,0 +1,1029 @@
+import { holds, walkPlan, walkPoint } from "./space-walk.js";
+import { canonicalJson, fnv1a32, mulberry32, sha256Hex } from "@mark1russell7/rigor-generators";
+// src/strategy-space.ts
+/** The schema of a strategy space. */
+const STRATEGY_SPACE_SCHEMA = "strategy-space/1";
+/**
+* This function gives the generator of one step of a seeded draw: `mulberry32` of the `fnv1a32` hash of `"<seed>:<step>"`.
+* The hash reads the WTF-8 bytes, so a lone surrogate in a name gives the same stream as `stepRandom` of `layout-contract`.
+*/
+const stepRandom = (seed, step) => mulberry32(fnv1a32(`${seed}:${step}`, { input: "wtf8" }));
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const show = (value) => typeof value === "string" ? `"${value}"` : String(value);
+const isNumeric = (p) => p.kind === "int" || p.kind === "real";
+const zero = (v) => v === 0 ? 0 : v;
+/** This function gives the stable form of a real number: 12 significant digits, with `-0` as `0`. */
+const realForm = (v, digits = 12) => zero(Number(v.toPrecision(digits)));
+/** This function gives the stable form of a value of a param. */
+function normalize(p, v) {
+	if (typeof v !== "number") return v;
+	if (p.kind !== "real") return zero(v);
+	return Math.min(p.max ?? Infinity, Math.max(p.min ?? -Infinity, realForm(v)));
+}
+/** This function tells if a value is on the step of a param. */
+function onStep(p, v) {
+	if (p.step === void 0 || p.min === void 0) return true;
+	const q = (v - p.min) / p.step;
+	return Math.abs(q - Math.round(q)) <= 1e-9 * Math.max(1, Math.abs(q));
+}
+/** This function gives the problem of a value of a param, or `undefined` for a value in the range. */
+function valueProblem(p, v) {
+	if (p.kind === "bool") return typeof v === "boolean" ? void 0 : `${show(v)} is not true or false`;
+	if (p.kind === "enum") return (p.values ?? []).some((x) => x === v) ? void 0 : `${show(v)} is not one of ${(p.values ?? []).map(show).join(", ")}`;
+	if (typeof v !== "number" || !Number.isFinite(v)) return `${show(v)} is not a finite number`;
+	if (p.kind === "int" && !Number.isInteger(v)) return `${v} is not a whole number`;
+	if (p.min !== void 0 && v < p.min) return `${v} is less than the min ${p.min}`;
+	if (p.max !== void 0 && v > p.max) return `${v} is more than the max ${p.max}`;
+	if (!onStep(p, v)) return `${v} is not on the step ${p.step} from ${p.min}`;
+}
+/** This function tells if a param is active for the values of the earlier params. */
+function isActive(p, values) {
+	if (p.when === void 0) return true;
+	if (!Object.hasOwn(values, p.when.param)) return false;
+	const v = values[p.when.param];
+	return p.when.in.some((x) => x === v);
+}
+/** This function gives the problem of a value of a param, or `undefined` for a value in its range. The corpus dimensions of `families.ts` use it. */
+function paramProblem(param, value) {
+	return valueProblem(param, value);
+}
+/** This function tells if a param is active for the values of the earlier params. A param without `when` is always active. */
+function paramActive(param, values) {
+	return isActive(param, values);
+}
+/** This function gives the stable form of a value of a param: a real number gets 12 significant digits, and `-0` becomes `0`. */
+function paramValue(param, value) {
+	return normalize(param, value);
+}
+/** This function gives the part of a space that has a stage, and the prefix of the names of its stages. */
+function partOf(space, stage) {
+	for (const part of space.parts ?? []) {
+		const head = `${part.engine}.`;
+		if (stage.startsWith(head)) {
+			const inner = partOf(part, stage.slice(head.length));
+			return {
+				space: inner.space,
+				prefix: head + inner.prefix
+			};
+		}
+	}
+	return {
+		space,
+		prefix: ""
+	};
+}
+/** This function gives the prefix of the innermost part of each stage. */
+const prefixes = (space) => new Map(space.stages.map((s) => [s.name, partOf(space, s.name).prefix]));
+const describe = (c) => {
+	const ref = (r) => `${r.stage}=${r.option ?? "null"}`;
+	return "not" in c.then ? `if ${ref(c.if)} then not ${ref(c.then.not)}` : `if ${ref(c.if)} then ${ref(c.then)}`;
+};
+/** This function gives the problems of the range and the default of one param. */
+function paramProblems(p, at) {
+	const out = [];
+	if (isNumeric(p)) {
+		const { min, max, step } = p;
+		if (typeof min !== "number" || typeof max !== "number" || !Number.isFinite(min) || !Number.isFinite(max)) {
+			out.push(["range", `${at} has no finite min and max`]);
+			return out;
+		}
+		if (min > max) out.push(["range", `${at} has an empty range: the min ${min} is more than the max ${max}`]);
+		if (p.kind === "int" && (!Number.isInteger(min) || !Number.isInteger(max))) out.push(["range", `${at} is an int with a min or a max that is not whole`]);
+		if (step !== void 0 && (!Number.isFinite(step) || step <= 0 || p.kind === "int" && !Number.isInteger(step))) out.push(["range", `${at} has the step ${step}, which is not a ${p.kind === "int" ? "whole " : ""}number above 0`]);
+		if (p.scale === "log" && min <= 0) out.push(["scale", `${at} has the scale log with the min ${min}, which is not above 0`]);
+	} else {
+		if (p.scale !== void 0) out.push(["scale", `${at} is a ${p.kind} param with a scale`]);
+		if (p.kind === "enum") {
+			if (!Array.isArray(p.values) || p.values.length === 0) out.push(["values", `${at} is an enum without values`]);
+			else {
+				const seen = /* @__PURE__ */ new Set();
+				for (const v of p.values) {
+					if (seen.has(v)) out.push(["duplicate", `${at} has the value ${show(v)} two times`]);
+					seen.add(v);
+				}
+			}
+		}
+	}
+	if (out.length === 0) {
+		const problem = valueProblem(p, p.default);
+		if (problem !== void 0) out.push(["default", `the default of ${at} is not in its range: ${problem}`]);
+	}
+	return out;
+}
+/** This function tells why a value is not a known shape kind, or gives `undefined` for a good kind. */
+function kindProblem(k, kinds) {
+	if (typeof k !== "string" || k === "") return "is not a string with text";
+	if (kinds !== void 0 && !kinds.includes(k)) return `is not one of ${kinds.join(", ")}`;
+}
+/** This function gives the problems of one stage option. */
+function optionProblems(stage, o, kinds) {
+	const out = [];
+	const at = `the option ${stage.name}.${o.id}`;
+	if (!Array.isArray(o.params)) return [["config", `${at} has no list of params`]];
+	const names = o.params.map((p) => p.name);
+	o.params.forEach((p, i) => {
+		const pat = `the param ${stage.name}.${o.id}.${p.name}`;
+		if (names.indexOf(p.name) !== i) out.push(["duplicate", `${at} has the param ${p.name} two times`]);
+		out.push(...paramProblems(p, pat));
+		if (p.when === void 0) return;
+		const j = names.indexOf(p.when.param);
+		if (j < 0) out.push(["unknown", `${pat} has a when with the unknown param ${p.when.param}`]);
+		else if (j >= i) out.push(["when", `${pat} has a when with the param ${p.when.param}, which does not come before it`]);
+		else if (!Array.isArray(p.when.in) || p.when.in.length === 0) out.push(["when", `${pat} has a when with no values`]);
+		else for (const v of p.when.in) {
+			const problem = valueProblem(o.params[j], v);
+			if (problem !== void 0) out.push(["when", `${pat} has a when value that is not a value of ${p.when.param}: ${problem}`]);
+		}
+	});
+	if (o.supports !== void 0) out.push(...supportsProblems(o.supports, at, kinds));
+	if (o.members !== void 0) {
+		const { min, max, ordered } = o.members;
+		const noList = min === 0 && max === 0;
+		if (!Number.isInteger(min) || !Number.isInteger(max) || !noList && (min < 1 || min > max) || typeof ordered !== "boolean") out.push(["members", `${at} has a member rule without whole counts 1 <= min <= max or min = max = 0, and a boolean ordered`]);
+		if (noList && (o.members.pool !== void 0 || o.members.view !== void 0)) out.push(["members", `${at} has no member list, so its member rule cannot have a pool or a view`]);
+		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;
+}
+/** This function gives the problems of the `supports` of an option. */
+function supportsProblems(supports, at, kinds) {
+	if (!isObject(supports)) return [["shape", `the supports of ${at} are not an object`]];
+	const shape = supports["shape"];
+	if (shape === void 0) return [];
+	if (!Array.isArray(shape) || shape.length === 0) return [["shape", `${at} supports no shape kind. Remove shape to support each kind`]];
+	const out = [];
+	shape.forEach((k, i) => {
+		const problem = kindProblem(k, kinds);
+		if (problem !== void 0) out.push(["shape", `${at} supports the shape kind ${show(k)}, which ${problem}`]);
+		else if (shape.indexOf(k) !== i) out.push(["duplicate", `${at} has the shape kind ${k} two times`]);
+	});
+	return out;
+}
+/** This function tells if an option supports each shape kind of the list. */
+const supportsShapes = (o, shapes) => shapes === void 0 || o.supports?.shape === void 0 || shapes.every((k) => o.supports.shape.includes(k));
+/** The shape kinds that the members of an option with `view: "bounds"` see: a bounding box is a `rect`. */
+const BOUNDS_VIEW = /* @__PURE__ */ 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`]];
+	const given = params ?? {};
+	const out = [];
+	for (const key of Object.keys(given)) if (!o.params.some((p) => p.name === key)) out.push(["unknown", `${at} has the unknown param ${key}`]);
+	const values = {};
+	for (const p of o.params) {
+		const has = Object.hasOwn(given, p.name);
+		if (!isActive(p, values)) {
+			if (has) out.push(["inactive", `${at} sets the param ${p.name}, which is not active`]);
+			continue;
+		}
+		const v = has ? given[p.name] : p.default;
+		const problem = valueProblem(p, v);
+		if (problem !== void 0) out.push(["param", `the param ${p.name} of ${at} is not in its range: ${problem}`]);
+		else values[p.name] = normalize(p, v);
+	}
+	return out;
+}
+/** This function gives the problems of a config of a space. A member of a meta option has `member: true`. */
+function configProblems(space, config, member, shapes) {
+	if (!isObject(config) || !isObject(config["stages"])) return [["config", "the config is not an object with stages"]];
+	const out = [];
+	const stages = config["stages"];
+	if (config["space"] !== space.engine) out.push(["space", `the space of the config is ${show(config["space"])}, not ${show(space.engine)}`]);
+	for (const key of Object.keys(stages)) if (!space.stages.some((s) => s.name === key)) out.push(["unknown", `the config has the unknown stage ${key}`]);
+	const optionOf = (s) => {
+		const c = stages[s.name];
+		return isObject(c) ? s.options.find((o) => o.id === c["option"]) : void 0;
+	};
+	const prefix = prefixes(space);
+	const metaStage = /* @__PURE__ */ new Map();
+	for (const s of space.stages) {
+		if (optionOf(s)?.members === void 0) continue;
+		const p = prefix.get(s.name);
+		if (metaStage.has(p)) out.push(["meta", `the stages ${metaStage.get(p)} and ${s.name} both have a meta option`]);
+		else metaStage.set(p, s.name);
+	}
+	const chosen = /* @__PURE__ */ new Map();
+	for (const s of space.stages) {
+		const c = Object.hasOwn(stages, s.name) ? stages[s.name] : void 0;
+		const meta = metaStage.get(prefix.get(s.name));
+		chosen.set(s.name, null);
+		if (c === void 0 || c === null) {
+			if (!s.optional && meta === void 0) out.push(["missing", `the config has no option for the stage ${s.name}`]);
+			continue;
+		}
+		if (!isObject(c) || typeof c["option"] !== "string") {
+			out.push(["config", `the choice of the stage ${s.name} has no option`]);
+			continue;
+		}
+		const o = s.options.find((x) => x.id === c["option"]);
+		if (o === void 0) {
+			out.push(["unknown", `the stage ${s.name} has no option ${c["option"]}`]);
+			continue;
+		}
+		chosen.set(s.name, o.id);
+		const at = `the option ${s.name}.${o.id}`;
+		if (!supportsShapes(o, shapes)) {
+			const missing = shapes.filter((k) => !o.supports.shape.includes(k));
+			out.push(["shape", `${at} supports the shape kinds ${o.supports.shape.join(", ")}, not ${missing.join(", ")}`]);
+		}
+		if (meta !== void 0 && meta !== s.name) out.push(["meta", `the stage ${s.name} is set, but the meta option of ${meta} replaces the other stages of its part`]);
+		out.push(...choiceParamProblems(o, c["params"], at));
+		if (o.members === void 0) {
+			if (c["members"] !== void 0) out.push(["members", `${at} is not a meta option, but the config gives members`]);
+			continue;
+		}
+		if (member) {
+			out.push(["depth", `a member has the meta option ${s.name}.${o.id}. The depth of a meta config is 1`]);
+			continue;
+		}
+		out.push(...memberProblems(partOf(space, s.name).space, o.members, c["members"], at, 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;
+}
+/** This function gives the problems of the members of a meta option. `part` is the space of the members. */
+function memberProblems(part, rule, members, at, shapes) {
+	if (!Array.isArray(members)) return [["members", `${at} is a meta option without a list of members`]];
+	const out = [];
+	if (members.length < rule.min || members.length > rule.max) out.push(["members", `${at} has ${members.length} members, not ${rule.min} to ${rule.max}`]);
+	const ids = /* @__PURE__ */ new Map();
+	members.forEach((m, k) => {
+		const inner = configProblems(part, m, true, shapes);
+		for (const [claim, detail] of inner) out.push([claim, `the member ${k} of ${at}: ${detail}`]);
+		if (inner.length > 0) return;
+		const id = idOf(canonicalOf(part, m, true));
+		if (ids.has(id)) out.push(["duplicate", `the members ${ids.get(id)} and ${k} of ${at} are the same config ${id}`]);
+		else ids.set(id, k);
+	});
+	if (rule.pool !== void 0 && out.length === 0) {
+		const key = memberKey(part, rule, members);
+		if (!rule.pool.some((entry) => memberKey(part, rule, entry) === key)) out.push(["pool", `${at} has a member list that is not in its pool of ${rule.pool.length} ${rule.pool.length === 1 ? "list" : "lists"}`]);
+	}
+	return out;
+}
+/** This function gives the key of a good member list: the `configId` of each member, sorted when the rule is not ordered. */
+function memberKey(part, rule, members) {
+	const ids = members.map((m) => idOf(canonicalOf(part, m, true)));
+	if (!rule.ordered) ids.sort();
+	return ids.join(",");
+}
+/** This function gives the problems of the pool of a meta option of a good space. `part` is the space of the members. */
+function poolProblems(part, rule, at) {
+	const out = [];
+	const keys = /* @__PURE__ */ new Map();
+	const plain = {
+		min: rule.min,
+		max: rule.max,
+		ordered: rule.ordered
+	};
+	(rule.pool ?? []).forEach((entry, j) => {
+		const inner = memberProblems(part, plain, entry, `the pool entry ${j} of ${at}`);
+		out.push(...inner);
+		if (inner.length > 0) return;
+		const key = memberKey(part, rule, entry);
+		if (keys.has(key)) out.push(["duplicate", `the pool entries ${keys.get(key)} and ${j} of ${at} have the same members`]);
+		else keys.set(key, j);
+	});
+	return out;
+}
+/** This function tells if a member list fits a space: each member is a good config of the space. A shape filter removes options from the space. */
+const fits = (part, entry) => entry.every((m) => configProblems(part, m, true).length === 0);
+const toBreaks = (problems, inputs = []) => problems.map(([claim, detail]) => ({
+	claim,
+	detail,
+	inputs
+}));
+/**
+* This function checks one config of a space. It gives one break for each problem. An empty list tells that the config is good.
+* The `claim` of a break is the kind of the problem, for example `missing`, `unknown`, `inactive`, `param`, `constraint`, `members` or `depth`.
+*
+* 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));
+}
+/**
+* This function checks a space. It gives one break for each problem. An empty list tells that the space is good.
+* It finds duplicate names, empty ranges, defaults out of range, enums without values, bad log scales, unknown names and bad named configs.
+* It also checks each entry of a `pool`: the count of its members, each member and a repeated entry.
+* The `inputs` of a break of a named config have the name of the config.
+* With `kinds`, a shape kind of a `supports` that is not in the list gives the claim `shape`.
+*/
+function checkSpace(space, kindOptions = {}) {
+	if (!isObject(space) || !Array.isArray(space.stages)) return toBreaks([["schema", "the space is not an object with stages"]]);
+	const out = [];
+	if (space.schema !== "strategy-space/1") out.push(["schema", `the schema is ${show(space.schema)}, not ${STRATEGY_SPACE_SCHEMA}`]);
+	if (typeof space.engine !== "string" || space.engine === "") out.push(["schema", "the space has no engine name"]);
+	if (typeof space.version !== "string") out.push(["schema", "the space has no version"]);
+	const names = space.stages.map((s) => s.name);
+	space.stages.forEach((s, i) => {
+		if (names.indexOf(s.name) !== i) out.push(["duplicate", `the space has the stage ${s.name} two times`]);
+		const options = Array.isArray(s.options) ? s.options : [];
+		if (options.length === 0) {
+			out.push(["options", `the stage ${s.name} has no options`]);
+			return;
+		}
+		const ids = options.map((o) => o.id);
+		options.forEach((o, j) => {
+			if (ids.indexOf(o.id) !== j) out.push(["duplicate", `the stage ${s.name} has the option ${o.id} two times`]);
+			out.push(...optionProblems(s, o, kindOptions.kinds));
+		});
+		if (!s.optional && options.every((o) => o.members !== void 0)) out.push(["meta", `the stage ${s.name} is not optional and has only meta options, so no base config exists`]);
+	});
+	const known = (ref, at) => {
+		const s = space.stages.find((x) => x.name === ref?.stage);
+		if (s === void 0) out.push(["unknown", `${at} has the unknown stage ${ref?.stage}`]);
+		else if (ref.option === null ? !s.optional : !s.options.some((o) => o.id === ref.option)) out.push(["unknown", `${at} has the unknown option ${s.name}=${ref.option ?? "null"}`]);
+	};
+	(space.constraints ?? []).forEach((c, k) => {
+		known(c.if, `the constraint ${k}`);
+		known("not" in c.then ? c.then.not : c.then, `the constraint ${k}`);
+	});
+	for (const part of space.parts ?? []) for (const b of checkSpace(part, kindOptions)) out.push([b.claim, `the part ${part.engine}: ${b.detail}`]);
+	if (space.parts !== void 0) {
+		for (const s of space.stages) if (partOf(space, s.name).prefix === "") out.push(["parts", `the stage ${s.name} is not a stage of a part`]);
+	}
+	const breaks = toBreaks(out);
+	if (breaks.length > 0) return breaks;
+	for (const s of space.stages) for (const o of s.options) if (o.members?.pool !== void 0) breaks.push(...toBreaks(poolProblems(partOf(space, s.name).space, o.members, `the option ${s.name}.${o.id}`)));
+	if (breaks.length > 0) return breaks;
+	for (const [name, config] of Object.entries(space.named ?? {})) breaks.push(...toBreaks(configProblems(space, config, false).map(([c, d]) => [c, `the named config ${name}: ${d}`]), [name]));
+	return breaks;
+}
+/** This function gives the canonical form of a config that is known to be good. */
+function canonicalOf(space, config, member) {
+	const stages = {};
+	for (const s of space.stages) {
+		const c = Object.hasOwn(config.stages, s.name) ? config.stages[s.name] : void 0;
+		if (c === void 0 || c === null) {
+			stages[s.name] = null;
+			continue;
+		}
+		const o = s.options.find((x) => x.id === c.option);
+		const given = c.params ?? {};
+		const params = {};
+		for (const p of o.params) if (isActive(p, params)) params[p.name] = normalize(p, Object.hasOwn(given, p.name) ? given[p.name] : p.default);
+		if (o.members === void 0 || member) {
+			stages[s.name] = {
+				option: o.id,
+				params
+			};
+			continue;
+		}
+		const part = partOf(space, s.name).space;
+		const members = (c.members ?? []).map((m) => canonicalOf(part, m, true));
+		if (!o.members.ordered) members.sort((a, b) => idOf(a) < idOf(b) ? -1 : idOf(a) > idOf(b) ? 1 : 0);
+		stages[s.name] = {
+			option: o.id,
+			params,
+			members
+		};
+	}
+	return {
+		space: space.engine,
+		stages
+	};
+}
+const idOf = (canonical) => sha256Hex(canonicalJson(canonical, { form: "json" }), { input: "wtf8" }).slice(0, 16);
+/**
+* This function gives the canonical form of a config: each stage of the space, the active params only, the defaults, and stable numbers.
+* An unused optional stage is `null`. The members of an unordered meta option are sorted by their `configId`.
+* It throws an `Error` for a config with a break of `checkConfig`.
+*/
+function canonicalConfig(space, config) {
+	const problems = configProblems(space, config, false);
+	if (problems.length > 0) throw new Error(`The config of the space ${space.engine} is not good: ${problems.map((p) => p[1]).join("; ")}.`);
+	return canonicalOf(space, config, false);
+}
+/**
+* This function gives the id of a config: the first 16 hex characters of the SHA-256 of `canonicalJson` of `canonicalConfig`.
+* Two spellings of one config get one id. The version of the space is not part of the id.
+*/
+function configId(space, config) {
+	return idOf(canonicalConfig(space, config));
+}
+/** This function throws an `Error` for a space with a break of `checkSpace`. */
+function assertSpace(space, kinds) {
+	const breaks = checkSpace(space, kinds === void 0 ? {} : { kinds });
+	if (breaks.length > 0) throw new Error(`The space ${String(space?.engine)} is not good: ${breaks.map((b) => b.detail).join("; ")}.`);
+}
+/** This function throws a `RangeError` when a value is not a whole number of `min` or more. */
+function assertWhole(value, name, min) {
+	if (!Number.isInteger(value) || value < min) throw new RangeError(`The option ${name} is ${value}, not a whole number of ${min} or more.`);
+}
+/** This function gives the last point of the step grid of a numeric param. */
+function lastPoint(p) {
+	const min = p.min;
+	const step = p.step ?? (p.kind === "int" ? 1 : void 0);
+	if (step === void 0) return p.max;
+	return min + Math.floor((p.max - min) / step + 1e-9) * step;
+}
+/** This function moves a value of a numeric param onto its step and into its range. */
+function snap(p, x, digits) {
+	const min = p.min;
+	const step = p.step ?? (p.kind === "int" ? 1 : void 0);
+	let v = step === void 0 ? x : min + Math.round((x - min) / step) * step;
+	v = Math.min(lastPoint(p), Math.max(min, v));
+	return p.kind === "int" ? zero(Math.round(v)) : Math.min(p.max, Math.max(min, realForm(v, digits)));
+}
+/** This function gives the point at the fraction `t` of the range of a numeric param, on its scale. */
+function at01(p, t) {
+	const min = p.min;
+	const max = p.max;
+	if (p.scale === "log") return Math.exp(Math.log(min) + t * (Math.log(max) - Math.log(min)));
+	return min + t * (max - min);
+}
+/**
+* This function gives the grid values of one param, in increasing order. An `enum` gives its values, and a `bool` gives `false` and `true`.
+* With 1 level, a numeric param gives its default. With k levels, it gives k points from `min` to `max` on its scale and step, without repeats.
+*/
+function paramLevels(param, levels) {
+	assertWhole(levels, "levels", 1);
+	if (param.kind === "bool") return [false, true];
+	if (param.kind === "enum") return [...param.values ?? []];
+	if (levels === 1 || param.min === param.max) return [normalize(param, param.default)];
+	const out = [];
+	const steps = param.kind === "int" || param.step !== void 0 ? Math.round((lastPoint(param) - param.min) / (param.step ?? 1)) + 1 : Infinity;
+	if (steps <= levels && param.scale !== "log") for (let j = 0; j < steps; j++) out.push(snap(param, param.min + j * (param.step ?? 1), 12));
+	else for (let j = 0; j < levels; j++) out.push(snap(param, at01(param, j / (levels - 1)), 12));
+	return [...new Set(out)];
+}
+/** This function tells if a later param of the list reads a param in its `when`. */
+const readLater = (params, i) => params.slice(i + 1).some((q) => q.when?.param === params[i].name);
+/** This function gives the count of the grid assignments of the params of an option, with only the active params. */
+function countParams(params, levels, i = 0, values = {}) {
+	if (i === params.length) return 1n;
+	const p = params[i];
+	if (!isActive(p, values)) return countParams(params, levels, i + 1, values);
+	const lv = paramLevels(p, levels);
+	if (!readLater(params, i)) return BigInt(lv.length) * countParams(params, levels, i + 1, values);
+	let sum = 0n;
+	for (const v of lv) sum += countParams(params, levels, i + 1, {
+		...values,
+		[p.name]: v
+	});
+	return sum;
+}
+/** This function gives the grid assignments of the params of an option, in a stable order. */
+function* gridParams(params, levels, i = 0, values = {}) {
+	if (i === params.length) {
+		yield { ...values };
+		return;
+	}
+	const p = params[i];
+	if (!isActive(p, values)) {
+		yield* gridParams(params, levels, i + 1, values);
+		return;
+	}
+	for (const v of paramLevels(p, levels)) yield* gridParams(params, levels, i + 1, {
+		...values,
+		[p.name]: v
+	});
+}
+const optionIds = (choices) => new Map([...choices].map(([k, o]) => [k, o?.id ?? null]));
+const keeps = (space, choices) => (space.constraints ?? []).every((c) => holds(c, optionIds(choices)));
+/**
+* This function gives the constraints of a space for each stage: a constraint goes to the last stage that it names.
+* The last list holds each constraint that names a stage outside the space, so a walk examines it at the end.
+*/
+function constraintsByStage(space) {
+	const place = new Map(space.stages.map((s, i) => [s.name, i]));
+	const lists = Array.from({ length: space.stages.length + 1 }, () => []);
+	for (const c of space.constraints ?? []) {
+		const named = [c.if.stage, "not" in c.then ? c.then.not.stage : c.then.stage];
+		lists[Math.max(...named.map((name) => place.get(name) ?? space.stages.length))].push(c);
+	}
+	return lists;
+}
+/** This function gives the count of the member lists of a meta option without a pool from `base` base configs, or `null` above `limit`. */
+function memberLists(base, rule, limit) {
+	let sum = 0n;
+	for (let m = rule.min; m <= rule.max; m++) {
+		let n = 1n;
+		for (let k = 0; k < m; k++) {
+			n = n * (base - BigInt(k)) / (rule.ordered ? 1n : BigInt(k + 1));
+			if (n <= 0n) break;
+		}
+		if (n <= 0n) break;
+		sum += n;
+		if (sum > limit) return null;
+	}
+	return sum;
+}
+/** This function multiplies two counts. A `null` count or a product above `limit` gives `null`. */
+const times = (a, b, limit) => a === null || b === null ? null : a * b > limit ? null : a * b;
+/**
+* This function gives the combinations of options of a space and their grid counts.
+* A product space joins the combinations of its parts. Each combination keeps the constraints.
+*/
+function combos(space, levels, meta, limit) {
+	if (space.parts !== void 0 && space.parts.length > 0) {
+		let acc = [{
+			choices: /* @__PURE__ */ new Map(),
+			base: true,
+			weight: 1n
+		}];
+		for (const part of space.parts) {
+			const head = `${part.engine}.`;
+			const own = combos(part, levels, meta, limit);
+			const next = [];
+			for (const a of acc) for (const b of own) {
+				const choices = new Map(a.choices);
+				for (const [k, o] of b.choices) choices.set(head + k, o);
+				const base = a.base && b.base;
+				next.push({
+					choices,
+					base,
+					weight: base ? a.weight * b.weight : times(a.weight, b.weight, limit)
+				});
+			}
+			acc = next;
+		}
+		return acc.filter((c) => keeps(space, c.choices));
+	}
+	const counts = /* @__PURE__ */ new Map();
+	const countOf = (o) => {
+		if (!counts.has(o)) counts.set(o, countParams(o.params, levels));
+		return counts.get(o);
+	};
+	const out = [];
+	const stages = space.stages;
+	const checks = constraintsByStage(space);
+	const ids = /* @__PURE__ */ new Map();
+	const walk = (i, choices, weight) => {
+		if (i === stages.length) {
+			if (checks[i].every((c) => holds(c, ids))) out.push({
+				choices: new Map(choices),
+				base: true,
+				weight
+			});
+			return;
+		}
+		const s = stages[i];
+		const list = s.options.filter((o) => o.members === void 0);
+		if (s.optional) list.push(null);
+		for (const o of list) {
+			choices.set(s.name, o);
+			ids.set(s.name, o?.id ?? null);
+			if (checks[i].every((c) => holds(c, ids))) walk(i + 1, choices, o === null ? weight : weight * countOf(o));
+		}
+		choices.delete(s.name);
+		ids.delete(s.name);
+	};
+	walk(0, /* @__PURE__ */ new Map(), 1n);
+	if (!meta) return out;
+	const base = out.reduce((sum, c) => sum + c.weight, 0n);
+	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 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,
+			weight: times(countOf(o), lists, limit)
+		});
+	}
+	return out;
+}
+/**
+* This function gives the count of the grid points of a space, with `levels` levels for each numeric param.
+* It counts only the active params and the combinations that keep the constraints. It gives the meta configs apart.
+* A meta option with a `pool` counts each entry of the pool one time.
+* With `shapes`, it counts only the options that support each kind of the list.
+*/
+function spaceSize(space, options) {
+	assertSpace(space, options.kinds);
+	assertWhole(options.levels, "levels", 1);
+	assertShapes(options.shapes, options.kinds);
+	return sizeOf(restrict(space, options.shapes), options.levels, options.maxMeta ?? 10n ** 18n);
+}
+/**
+* This function gives the space with only the options that support each shape kind of `shapes`. Without `shapes`, it gives the same space.
+* A stage can lose all of its options. Then the space has no config with that stage.
+* 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;
+	const kept = {
+		...space,
+		stages: space.stages.map((s) => ({
+			...s,
+			options: s.options.filter((o) => supportsShapes(o, shapes))
+		})),
+		...space.parts === void 0 ? {} : { parts: space.parts.map((p) => restrict(p, shapes)) }
+	};
+	const withPool = (s, o) => {
+		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 ? [] : 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 = /* @__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.max === 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 a constraint in words, for the reason of an error. */
+function constraintText(c) {
+	const ref = (r) => `${r.stage} ${r.option === null ? "has no option" : `is ${r.option}`}`;
+	return "not" in c.then ? `if ${ref(c.if)}, then not ${ref(c.then.not)}` : `if ${ref(c.if)}, then ${ref(c.then)}`;
+}
+/**
+* This function throws a `RangeError` for a bad `fixed` option of a sample. A stage or an option that the space does not have is bad.
+* A meta option without `meta: "sample"` is bad, and so are two fixed options that a constraint forbids.
+*/
+function assertFixed(space, fixed, meta) {
+	for (const [stage, id] of Object.entries(fixed)) {
+		const s = space.stages.find((x) => x.name === stage);
+		if (s === void 0) throw new RangeError(`The option fixed names the stage ${stage}, and the space ${space.engine} has no such stage.`);
+		const o = s.options.find((x) => x.id === id);
+		if (o === void 0) throw new RangeError(`The option fixed names the option ${String(id)} of the stage ${stage}, and the stage has no such option.`);
+		if (o.members !== void 0 && !meta) throw new RangeError(`The option fixed names the meta option ${stage}.${id}, and a sample with meta skip has no meta option. Set meta to "sample".`);
+	}
+	const ids = new Map(Object.entries(fixed));
+	const other = (c) => "not" in c.then ? c.then.not.stage : c.then.stage;
+	const broken = (space.constraints ?? []).filter((c) => ids.has(c.if.stage) && ids.has(other(c)) && !holds(c, ids));
+	if (broken.length > 0) {
+		const names = Object.entries(fixed).map(([stage, id]) => `${stage}.${id}`);
+		throw new RangeError(`The constraints of the space ${space.engine} forbid the fixed options ${names.join(", ")}. The broken constraints: ${broken.map(constraintText).join("; ")}.`);
+	}
+}
+/**
+* This function gives the restricted space `kept` with only the fixed option at each fixed stage. A fixed stage that was optional stops being optional.
+* A meta option of another stage of the part of a fixed stage goes out. A sample gives no option to the other stages of the part of its meta option.
+*/
+function fixStages(space, kept, fixed, shapes) {
+	const prefix = prefixes(kept);
+	const parts = new Set(Object.keys(fixed).map((stage) => prefix.get(stage)));
+	const stages = kept.stages.map((s) => {
+		const id = fixed[s.name];
+		if (id === void 0) return parts.has(prefix.get(s.name)) ? {
+			...s,
+			options: s.options.filter((o) => o.members === void 0)
+		} : s;
+		const options = s.options.filter((o) => o.id === id).map((o) => o.members === void 0 ? o : withMemberSpace(o, memberSpaces.get(o) ?? partOf(kept, s.name).space));
+		if (options.length === 0) throw new RangeError(`The fixed option ${s.name}.${id} of the space ${space.engine} does not support the shape kinds ${(shapes ?? []).join(", ")}.`);
+		return {
+			...s,
+			options,
+			optional: false
+		};
+	});
+	return {
+		...kept,
+		stages
+	};
+}
+/** This function gives a copy of a meta option whose members come from `members`. */
+function withMemberSpace(o, members) {
+	const copy = { ...o };
+	memberSpaces.set(copy, members);
+	return copy;
+}
+/** This function gives the error of a sample whose fixed options keep each constraint between them. The constraints with the other stages remove each config. */
+function noFixedSample(space, fixed) {
+	const names = Object.entries(fixed).map(([stage, id]) => `${stage}.${id}`);
+	return /* @__PURE__ */ new RangeError(`The space ${space.engine} has no config with the fixed options ${names.join(", ")}. No constraint between two fixed options breaks, so the constraints with the other stages remove each config.`);
+}
+/** 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 known. */
+function assertShapes(shapes, kinds) {
+	if (shapes === void 0) return;
+	if (!Array.isArray(shapes)) throw new RangeError("The option shapes is not a list of shape kinds.");
+	for (const k of shapes) {
+		const problem = kindProblem(k, kinds);
+		if (problem !== void 0) throw new RangeError(`The shape kind ${show(k)} ${problem}.`);
+	}
+}
+/** This function gives the count of the grid points of a space that is known to be good. */
+function sizeOf(space, levels, limit) {
+	let base = 0n;
+	let meta = 0n;
+	for (const c of combos(space, levels, true, limit)) if (c.base) base += c.weight;
+	else meta = meta === null || c.weight === null || meta + c.weight > limit ? null : meta + c.weight;
+	return {
+		base,
+		meta
+	};
+}
+/** This function gives the cartesian product of lists, with the last list as the fastest. */
+function* product(lists, i = 0, acc = []) {
+	if (i === lists.length) {
+		yield [...acc];
+		return;
+	}
+	for (const x of lists[i]) {
+		acc.push(x);
+		yield* product(lists, i + 1, acc);
+		acc.pop();
+	}
+}
+/** This function gives the configs of the grid of a space, without meta options. */
+function gridConfigs(space, levels, limit, shapes) {
+	const kept = restrict(space, shapes);
+	const size = sizeOf(kept, levels, 0n).base;
+	if (size > BigInt(limit)) throw new RangeError(`The grid of the space ${space.engine} has ${size} configs, more than the limit ${limit}.`);
+	const out = [];
+	for (const c of combos(kept, levels, false, 0n)) {
+		const names = [...c.choices.keys()];
+		const lists = names.map((k) => {
+			const o = c.choices.get(k);
+			return o === null ? [null] : [...gridParams(o.params, levels)].map((params) => ({
+				option: o.id,
+				params
+			}));
+		});
+		for (const row of product(lists)) out.push(canonicalOf(space, {
+			space: space.engine,
+			stages: Object.fromEntries(names.map((k, i) => [k, row[i]]))
+		}, false));
+	}
+	return out;
+}
+/** This function gives a random order of the numbers from 0 to `n - 1`. */
+function permutation(n, r) {
+	const out = Array.from({ length: n }, (_, i) => i);
+	for (let i = n - 1; i > 0; i--) {
+		const j = Math.floor(r() * (i + 1));
+		[out[i], out[j]] = [out[j], out[i]];
+	}
+	return out;
+}
+/** This function gives the value of a param at the fraction `u` of its range. A sampled real number has 6 significant digits. */
+function sampleValue(p, u) {
+	if (p.kind === "bool") return u >= .5;
+	if (p.kind === "enum") {
+		const values = p.values;
+		return values[Math.min(values.length - 1, Math.floor(u * values.length))];
+	}
+	if (p.min === p.max) return normalize(p, p.min);
+	if (p.scale !== "log" && (p.kind === "int" || p.step !== void 0)) {
+		const steps = Math.round((lastPoint(p) - p.min) / (p.step ?? 1)) + 1;
+		return snap(p, p.min + Math.min(steps - 1, Math.floor(u * steps)) * (p.step ?? 1), 6);
+	}
+	return snap(p, at01(p, u), 6);
+}
+/** 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.
+* `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, walk = false, first = /* @__PURE__ */ new Set()) {
+	const stages = space.stages;
+	const prefix = prefixes(space);
+	const bounded = new Set(stages.filter((s) => meta && s.options.some((o) => memberSpaces.has(o) || o.members?.max === 0)).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 plan = walk ? walkPlan(stages, lists, space.constraints ?? [], n, first) : null;
+	const points = [];
+	let tries = 0;
+	for (let round = 0; points.length < n; round++) {
+		const r = stepRandom(seed, `options:${round}`);
+		const picks = walk ? lists.map(() => permutation(n, r)) : [];
+		const columns = walk ? [] : lists.map((list) => permutation(n, r).map((p) => list[Math.floor(p * list.length / n)]));
+		for (let i = 0; i < n && points.length < n; i++) {
+			if (tries >= maxTries) throw new Error(`The constraints of the space ${space.engine} remove too many points: ${points.length} of ${n} configs after ${tries} tries.${walk ? "" : " The option draw: \"walk\" gets a sample of a space with many constraints."}`);
+			tries++;
+			const choices = plan !== null ? walkPoint(plan, picks, i) : new Map(stages.map((s, k) => [s.name, columns[k][i]]));
+			const metaPart = /* @__PURE__ */ new Map();
+			for (const s of stages) if (choices.get(s.name)?.members !== void 0 && !metaPart.has(prefix.get(s.name))) metaPart.set(prefix.get(s.name), s.name);
+			for (const s of stages) {
+				const m = metaPart.get(prefix.get(s.name));
+				if (m !== void 0 && m !== s.name) choices.set(s.name, null);
+			}
+			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(() => ({})));
+	const members = points.map(() => stages.map(() => []));
+	stages.forEach((s, k) => {
+		for (const o of s.options) {
+			const users = points.flatMap((c, i) => c.get(s.name) === o ? [i] : []);
+			if (users.length === 0) continue;
+			for (const p of o.params) {
+				const active = users.filter((i) => isActive(p, values[i][k]));
+				const r = stepRandom(seed, `param:${s.name}:${o.id}:${p.name}`);
+				permutation(active.length, r).forEach((stratum, j) => {
+					values[active[j]][k][p.name] = sampleValue(p, (stratum + r()) / active.length);
+				});
+			}
+			if (o.members === void 0 || o.members.max === 0) continue;
+			const fixed = o.members.pool;
+			if (fixed !== void 0) {
+				const r = stepRandom(seed, `pool-entry:${s.name}:${o.id}`);
+				permutation(users.length, r).forEach((stratum, j) => {
+					members[users[j]][k] = [...fixed[Math.min(fixed.length - 1, Math.floor((stratum + r()) / users.length * fixed.length))]];
+				});
+				continue;
+			}
+			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), part, walk).filter((c) => {
+				const id = idOf(c);
+				return seen.has(id) ? false : (seen.add(id), true);
+			});
+			const r = stepRandom(seed, `members:${s.name}:${o.id}`);
+			const { min, max } = o.members;
+			permutation(users.length, r).forEach((stratum, j) => {
+				const count = min + Math.min(max - min, Math.floor((stratum + r()) / users.length * (max - min + 1)));
+				if (pool.length < count) throw new Error(`The space ${part.engine} has only ${pool.length} distinct base samples, fewer than the ${count} members of ${s.name}.${o.id}.`);
+				const picked = permutation(pool.length, r).slice(0, count);
+				members[users[j]][k] = picked.map((x) => pool[x]);
+			});
+		}
+	});
+	return points.map((choices, i) => {
+		const out = {};
+		stages.forEach((s, k) => {
+			const o = choices.get(s.name);
+			out[s.name] = o === null ? null : o.members === void 0 ? {
+				option: o.id,
+				params: values[i][k]
+			} : {
+				option: o.id,
+				params: values[i][k],
+				members: members[i][k]
+			};
+		});
+		return canonicalConfig(canon, {
+			space: space.engine,
+			stages: out
+		});
+	});
+}
+/**
+* This function gives configs of a space, in their canonical form. Each config keeps the constraints. The result is deterministic.
+*
+* - The mode `grid` gives each grid point without a meta option, in a stable order. Stages, options and values go in the order of the space.
+* - The mode `sample` gives `n` configs of a seeded Latin hypercube. The options of a stage get equal strata, and each active param gets its own strata.
+* - A sample draws again when a point breaks a constraint. After `maxTries` draws, it throws an `Error`. Two sampled configs can be equal.
+* - With `draw: "walk"`, each stage draws only from the options that keep the constraints with the stages before it. The largest stage keeps its equal strata.
+* - 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.
+* - With `fixed`, each config has the fixed option at each named stage. A fixed option that the space, the shape filter or the constraints do not permit gets a `RangeError` with the reason.
+*/
+function enumerateSpace(space, options) {
+	assertSpace(space, options.kinds);
+	assertShapes(options.shapes, options.kinds);
+	if (options.mode === "grid") {
+		assertWhole(options.levels, "levels", 1);
+		return gridConfigs(space, options.levels, options.limit ?? 1e5, options.shapes);
+	}
+	if (options.mode !== "sample") throw new RangeError(`The mode ${String(options.mode)} is not grid or sample.`);
+	assertWhole(options.n, "n", 0);
+	if (!Number.isInteger(options.seed)) throw new RangeError(`The seed ${options.seed} is not a whole number.`);
+	const meta = options.meta ?? "skip";
+	if (meta !== "skip" && meta !== "sample") throw new RangeError(`The option meta is ${String(meta)}, not skip or sample.`);
+	const draw = options.draw ?? "reject";
+	if (draw !== "reject" && draw !== "walk") throw new RangeError(`The option draw is ${String(draw)}, not reject or walk.`);
+	const fixed = options.fixed;
+	if (fixed !== void 0) assertFixed(space, fixed, meta === "sample");
+	if (options.n === 0) return [];
+	const kept = restrict(space, options.shapes);
+	const drawn = fixed === void 0 ? kept : fixStages(space, kept, fixed, options.shapes);
+	try {
+		return sampleConfigs(drawn, options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1e3, 100 * options.n), space, draw === "walk", new Set(Object.keys(fixed ?? {})));
+	} catch (error) {
+		if (options.shapes !== void 0 && !hasConfig(kept, meta === "sample")) throw noSample(space, kept, options.shapes, meta === "sample");
+		if (fixed !== void 0 && !hasConfig(drawn, meta === "sample")) throw noFixedSample(space, fixed);
+		throw error;
+	}
+}
+/**
+* This function gives the shape kinds that a space accepts. The value comes from the `supports` of the options.
+* A space accepts a kind when it has at least one config without a meta option on that kind.
+* With `kinds`, it examines the kinds of that list, in its order. Without `kinds`, it examines the kinds that the `supports` of the space name, in the order of their first use.
+*/
+function spaceShapeKinds(space, options = {}) {
+	assertSpace(space, options.kinds);
+	const named = [...new Set(space.stages.flatMap((s) => s.options.flatMap((o) => o.supports?.shape ?? [])))];
+	return (options.kinds ?? named).filter((k) => sizeOf(restrict(space, [k]), 1, 0n).base > 0n);
+}
+/**
+* This function joins configs of the parts of a product space into one config of the space `space`.
+* The name of each stage gets the prefix `<space of the part>.`. The members of a meta option do not change.
+*/
+function joinConfigs(space, parts) {
+	const stages = {};
+	for (const part of parts) for (const [k, c] of Object.entries(part.stages)) stages[`${part.space}.${k}`] = c;
+	return {
+		space,
+		stages
+	};
+}
+/** This function gives the config of the part `engine` of a joint config. It throws a `RangeError` when no stage has the prefix `<engine>.`. */
+function splitConfig(config, engine) {
+	const head = `${engine}.`;
+	const entries = Object.entries(config.stages).filter(([k]) => k.startsWith(head));
+	if (entries.length === 0) throw new RangeError(`The config of the space ${config.space} has no stage of the part ${engine}.`);
+	return {
+		space: engine,
+		stages: Object.fromEntries(entries.map(([k, c]) => [k.slice(head.length), c]))
+	};
+}
+/**
+* This function joins two spaces, for example a packer and a router, into the space `name`. The stages of `a` and `b` get the prefixes `<a.engine>.` and `<b.engine>.`.
+* The constraints get the same prefixes. The named configs are the pairs `<name of a>+<name of b>`. It throws a `RangeError` when the two engines have the same name.
+*/
+function productSpace(a, b, name) {
+	if (a.engine === b.engine) throw new RangeError(`The two spaces have the same engine ${a.engine}.`);
+	if (name === "") throw new RangeError("The product space has no name.");
+	const stagesOf = (s) => s.stages.map((x) => ({
+		...x,
+		name: `${s.engine}.${x.name}`
+	}));
+	const ref = (s, r) => ({
+		stage: `${s.engine}.${r.stage}`,
+		option: r.option
+	});
+	const constraintsOf = (s) => (s.constraints ?? []).map((c) => ({
+		if: ref(s, c.if),
+		then: "not" in c.then ? { not: ref(s, c.then.not) } : ref(s, c.then)
+	}));
+	const named = {};
+	for (const [ka, ca] of Object.entries(a.named ?? {})) for (const [kb, cb] of Object.entries(b.named ?? {})) named[`${ka}+${kb}`] = joinConfigs(name, [ca, cb]);
+	const constraints = [...constraintsOf(a), ...constraintsOf(b)];
+	return {
+		schema: STRATEGY_SPACE_SCHEMA,
+		engine: name,
+		version: `${a.engine}@${a.version}+${b.engine}@${b.version}`,
+		stages: [...stagesOf(a), ...stagesOf(b)],
+		...constraints.length > 0 ? { constraints } : {},
+		...Object.keys(named).length > 0 ? { named } : {},
+		parts: [a, b]
+	};
+}
+export { STRATEGY_SPACE_SCHEMA, canonicalConfig, checkConfig, checkSpace, configId, enumerateSpace, joinConfigs, paramActive, paramLevels, paramProblem, paramValue, productSpace, spaceShapeKinds, spaceSize, splitConfig };
+
+//# sourceMappingURL=strategy-space.js.map