@mark1russell7/layout-contract 0.2.9 → 0.2.10

package/build/index.js

@@ -1404,7 +1404,7 @@ function declaredCounts(inputs, declares, ids = []) {
 	return out;
 }
 /** This function tells if a value is a plain object. */
-const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const isObject$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 /**
 * This function reads the field `claims.declared` of a manifest. A manifest without it gives `undefined`.
 * It throws an `Error` for a claim without a whole `minCount`, a list `thin` of ids and a whole count for each id.
@@ -1412,14 +1412,14 @@ const isObject = (value) => value !== null && typeof value === "object" && !Arra
 function declaredClaimOf(manifest) {
 	const claims = manifest["claims"];
 	if (claims === void 0) return void 0;
-	if (!isObject(claims)) throw new Error("The field claims of a corpus file is an object.");
+	if (!isObject$1(claims)) throw new Error("The field claims of a corpus file is an object.");
 	const declared = claims["declared"];
 	if (declared === void 0) return void 0;
-	if (!isObject(declared)) throw new Error("The field claims.declared of a corpus file is an object.");
+	if (!isObject$1(declared)) throw new Error("The field claims.declared of a corpus file is an object.");
 	const { minCount, thin, counts } = declared;
 	if (!Number.isInteger(minCount) || minCount < 0) throw new Error("The field claims.declared.minCount is a whole number of 0 or more.");
 	if (!Array.isArray(thin) || !thin.every((id) => typeof id === "string")) throw new Error("The field claims.declared.thin is a list of property ids.");
-	if (!isObject(counts) || !Object.values(counts).every((n) => Number.isInteger(n) && n >= 0)) throw new Error("The field claims.declared.counts gives a whole count for each property id.");
+	if (!isObject$1(counts) || !Object.values(counts).every((n) => Number.isInteger(n) && n >= 0)) throw new Error("The field claims.declared.counts gives a whole count for each property id.");
 	return {
 		minCount,
 		thin: [...thin],
@@ -1540,6 +1540,724 @@ function leaveOneSeedOut(seeds) {
 		heldOut: [s]
 	}));
 }
-export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, SIDES, SPLIT_SCHEMA, applyPack, boundsOf, canonicalJson, checkDeclared, checkInput, checkSplit, compareMeasure, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, exercised, fnv1a32, grow, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, pickMoves, placedRect, portfolio, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
+// src/strategy-space.ts
+/** The schema of a strategy space. */
+const STRATEGY_SPACE_SCHEMA = "strategy-space/1";
+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 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 refMatches = (ref, choices) => (choices.get(ref.stage) ?? null) === ref.option;
+/** This function tells if the option choices keep a constraint. */
+function holds(c, choices) {
+	if (!refMatches(c.if, choices)) return true;
+	return "not" in c.then ? !refMatches(c.then.not, choices) : refMatches(c.then, choices);
+}
+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 gives the problems of one stage option. */
+function optionProblems(stage, o) {
+	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.members !== void 0) {
+		const { min, max, ordered } = o.members;
+		if (!Number.isInteger(min) || !Number.isInteger(max) || min < 1 || min > max || typeof ordered !== "boolean") out.push(["members", `${at} has a member rule without whole counts 1 <= min <= max and a boolean ordered`]);
+	}
+	return out;
+}
+/** This function gives the problems of the 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) {
+	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 (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));
+	}
+	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) {
+	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);
+		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);
+	});
+	return out;
+}
+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`.
+*/
+function checkConfig(space, config) {
+	return toBreaks(configProblems(space, config, false));
+}
+/**
+* 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.
+* The `inputs` of a break of a named config have the name of the config.
+*/
+function checkSpace(space) {
+	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));
+		});
+		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)) 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 [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)).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) {
+	const breaks = checkSpace(space);
+	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 count of the member lists of a meta option 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 walk = (i, choices, weight) => {
+		if (i === stages.length) {
+			if (keeps(space, choices)) 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);
+			walk(i + 1, choices, o === null ? weight : weight * countOf(o));
+		}
+		choices.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]));
+		if (keeps(space, choices)) out.push({
+			choices,
+			base: false,
+			weight: times(countOf(o), memberLists(base, o.members, limit), 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.
+*/
+function spaceSize(space, options) {
+	assertSpace(space);
+	assertWhole(options.levels, "levels", 1);
+	const limit = options.maxMeta ?? 10n ** 18n;
+	let base = 0n;
+	let meta = 0n;
+	for (const c of combos(space, options.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) {
+	const size = spaceSize(space, {
+		levels,
+		maxMeta: 0n
+	}).base;
+	if (size > BigInt(limit)) throw new RangeError(`The grid of the space ${space.engine} has ${size} configs, more than the limit ${limit}.`);
+	const out = [];
+	for (const c of combos(space, levels, false, 0n)) {
+		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. */
+function sampleConfigs(space, n, seed, meta, maxTries) {
+	const stages = space.stages;
+	const prefix = prefixes(space);
+	const lists = stages.map((s) => {
+		const list = s.options.filter((o) => meta || o.members === void 0);
+		if (s.optional) list.push(null);
+		return list;
+	});
+	const points = [];
+	let tries = 0;
+	for (let round = 0; points.length < n; round++) {
+		const r = stepRandom(seed, `options:${round}`);
+		const columns = 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.`);
+			tries++;
+			const choices = 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 (keeps(space, choices)) 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) continue;
+			const part = 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) => {
+				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(space, {
+			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.
+*/
+function enumerateSpace(space, options) {
+	assertSpace(space);
+	if (options.mode === "grid") {
+		assertWhole(options.levels, "levels", 1);
+		return gridConfigs(space, options.levels, options.limit ?? 1e5);
+	}
+	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.`);
+	if (options.n === 0) return [];
+	return sampleConfigs(space, options.n, options.seed, meta === "sample", options.maxTries ?? Math.max(1e3, 100 * options.n));
+}
+/**
+* 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 { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, RECORD_SCALE, SIDES, SPLIT_SCHEMA, STRATEGY_SPACE_SCHEMA, applyPack, boundsOf, canonicalConfig, canonicalJson, checkConfig, checkDeclared, checkInput, checkSpace, checkSplit, compareMeasure, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, enumerateSpace, exercised, fnv1a32, grow, joinConfigs, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramLevels, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
 
 //# sourceMappingURL=index.js.map