@mark1russell7/layout-contract 0.2.13 → 0.2.15

package/build/index.js

@@ -260,13 +260,63 @@ const DEFAULT_TOLERANCE = Object.freeze({
 	through: .5
 });
 // src/input.ts
+/**
+* This function gives the point of a port on the border of its box, relative to the top-left corner of the box.
+* A port with `x` and `y` gives that point. A port with `side` and `along` gives the point at that fraction of the side.
+* Another port gives `undefined`, because the router picks its point.
+*/
+function portPoint(box, port) {
+	if (port.x !== void 0 && port.y !== void 0) return {
+		x: port.x,
+		y: port.y
+	};
+	if (port.side === void 0 || port.along === void 0) return void 0;
+	switch (port.side) {
+		case "top": return {
+			x: port.along * box.w,
+			y: 0
+		};
+		case "bottom": return {
+			x: port.along * box.w,
+			y: box.h
+		};
+		case "left": return {
+			x: 0,
+			y: port.along * box.h
+		};
+		case "right": return {
+			x: box.w,
+			y: port.along * box.h
+		};
+	}
+}
 /** This function gives the packer input of a file. An input without a container gets `{ fixed: "none" }`, so the packer picks the size. */
 function toPackInput(input) {
 	return {
 		container: input.container ?? { fixed: "none" },
 		items: input.boxes,
 		...input.obstacles === void 0 ? {} : { obstacles: input.obstacles },
-		...input.gap === void 0 ? {} : { gap: input.gap }
+		...input.gap === void 0 ? {} : { gap: input.gap },
+		...input.pairGaps === void 0 ? {} : { pairGaps: input.pairGaps }
+	};
+}
+/** This function compares two strings by their UTF-16 code units, as `Array.prototype.sort` does without a compare function. */
+const byCode$1 = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+/**
+* This function gives the canonical form of an input. `documentHash` uses it for each `layout-input/1` document.
+* Each pair of `pairGaps` gets `a` before `b`, and the list is sorted by `a` and then by `b`.
+* An input without `pairGaps` is the same object, so its hash does not change.
+*/
+function canonicalInput(input) {
+	if (!Array.isArray(input.pairGaps)) return input;
+	const pairGaps = input.pairGaps.map((p) => byCode$1(p.a, p.b) > 0 ? {
+		...p,
+		a: p.b,
+		b: p.a
+	} : p).sort((x, y) => byCode$1(x.a, y.a) || byCode$1(x.b, y.b));
+	return {
+		...input,
+		pairGaps
 	};
 }
 // src/turn.ts
@@ -278,14 +328,20 @@ function turnSide(side) {
 function turnPoint(x, y, h) {
 	return [h - y, x];
 }
-/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */
+/**
+* This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`.
+* The start of a side is its top end or its left end. Thus `left` goes to `top` and `right` goes to `bottom` with `along` changed to `1 - along`.
+* `top` goes to `right` and `bottom` goes to `left` with the same `along`.
+*/
 function turnPort(port, h) {
-	const { side, x, y, ...rest } = port;
+	const { side, x, y, along, ...rest } = port;
+	const flips = side === "left" || side === "right";
 	return {
 		...rest,
 		...side === void 0 ? {} : { side: turnSide(side) },
 		...y === void 0 ? {} : { x: h - y },
-		...x === void 0 ? {} : { y: x }
+		...x === void 0 ? {} : { y: x },
+		...along === void 0 ? {} : { along: flips ? 1 - along : along }
 	};
 }
 /** This function gives a margin after the turn: the value of each side moves one side clockwise. */
@@ -423,20 +479,53 @@ function placedRect(box) {
 /**
 * This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.
 * A box with a shape counts as its bounding box. That area is larger, thus the count is safe.
+*
+* A pair of `pairGaps`, in either order, uses its `gap` in place of the two margins. One box grows by the gap, and the other box does not grow.
+* Thus the pair breaks the rule only when the boxes are nearer than the gap on each axis. The other pairs do not change.
 */
-function countOverlaps(boxes, tolerance = DEFAULT_TOLERANCE.overlap) {
+function countOverlaps(boxes, tolerance = DEFAULT_TOLERANCE.overlap, pairGaps) {
+	if (pairGaps === void 0 || pairGaps.length === 0) return marginOverlaps(boxes, tolerance, void 0);
+	const gaps = /* @__PURE__ */ new Map();
+	for (const p of pairGaps) {
+		const key = pairKey(p.a, p.b);
+		if (p.a !== p.b && !gaps.has(key)) gaps.set(key, p.gap);
+	}
+	const raw = /* @__PURE__ */ new Map();
+	for (const box of boxes) {
+		const r = placedRect(box);
+		if (r !== void 0 && !raw.has(box.id)) raw.set(box.id, r);
+	}
+	let count = marginOverlaps(boxes, tolerance, gaps);
+	for (const [key, gap] of gaps) {
+		const [a, b] = JSON.parse(key);
+		const ra = raw.get(a);
+		const rb = raw.get(b);
+		if (ra === void 0 || rb === void 0) continue;
+		const o = overlapOf(grow(ra, gap), rb);
+		if (o.x > tolerance && o.y > tolerance) count++;
+	}
+	return count;
+}
+/** This function gives the key of a pair of box ids, with the same key for each order. */
+const pairKey = (a, b) => JSON.stringify(a < b ? [a, b] : [b, a]);
+/** This function counts the overlaps of the boxes with their margins. It skips the pairs of `skip`. Without `skip`, it is the rule of 0.2.13. */
+function marginOverlaps(boxes, tolerance, skip) {
 	const rects = [];
 	for (const box of boxes) {
 		const r = placedRect(box);
-		if (r !== void 0) rects.push(grow(r, box.margin));
+		if (r !== void 0) rects.push({
+			id: box.id,
+			r: grow(r, box.margin)
+		});
 	}
-	rects.sort((a, b) => a.x - b.x);
+	rects.sort((a, b) => a.r.x - b.r.x);
 	let count = 0;
 	for (let i = 0; i < rects.length; i++) {
-		const a = rects[i];
+		const a = rects[i].r;
 		for (let j = i + 1; j < rects.length; j++) {
-			const b = rects[j];
+			const b = rects[j].r;
 			if (b.x >= a.x + a.w - tolerance) break;
+			if (skip !== void 0 && skip.has(pairKey(rects[i].id, rects[j].id))) continue;
 			const o = overlapOf(a, b);
 			if (o.x > tolerance && o.y > tolerance) count++;
 		}
@@ -671,7 +760,8 @@ function countObstacleHits(boxes, obstacles, tolerance = DEFAULT_TOLERANCE.overl
 /**
 * This function gives the count of each hard rule of the output of a packer.
 * It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.
-* `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle.
+* `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle. A pair of `pairGaps` uses its gap in place of the margins.
+*
 * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.
 * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.
 * Another box without a placement that is not in `overflow` breaks `complete`.
@@ -697,7 +787,7 @@ function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap, options
 		else if (!out.has(box.id)) incomplete++;
 	}
 	return {
-		"no-overlap": countOverlaps(kept, tolerance) + countObstacleHits(kept, after.obstacles, tolerance),
+		"no-overlap": countOverlaps(kept, tolerance, input.pairGaps) + countObstacleHits(kept, after.obstacles, tolerance),
 		"in-container": countOutside({
 			...after,
 			boxes: kept
@@ -709,6 +799,8 @@ function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap, options
 /**
 * This function gives the problems of an input file. An empty list tells that the file is good.
 * A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.
+* In `pairGaps`, an unknown box, a pair of one box, a repeated pair in either order, a bad `gap` and bad `lanes` are problems.
+* A port with `along` and no `side`, with `x` or `y`, or with a value outside [0, 1] is a problem.
 */
 function checkInput(input) {
 	const problems = [];
@@ -720,9 +812,44 @@ function checkInput(input) {
 		if (box.locked === true && (box.x === void 0 || box.y === void 0)) problems.push(`box ${box.id}: a locked box has no position`);
 		const shape = shapeKindProblem(box);
 		if (shape !== void 0) problems.push(shape);
+		for (const port of box.ports ?? []) problems.push(...alongProblems(box.id, port));
 	}
 	if (countPortsOffBorder(input.boxes) > 0) problems.push("a fixed port is not on the border of its box");
 	for (const edge of input.edges ?? []) if (!ids.has(edge.source) || !ids.has(edge.target)) problems.push(`edge ${edge.id}: a box of the edge is not in the input`);
+	problems.push(...pairGapProblems(input.pairGaps, ids));
+	return problems;
+}
+/** This function gives the problems of the `along` of a port: no side, a value outside [0, 1], or `x` or `y` with it. A port without `along` has no problem. */
+function alongProblems(boxId, port) {
+	if (port.along === void 0) return [];
+	const at = `box ${boxId} port ${port.id}`;
+	const problems = [];
+	if (port.side === void 0) problems.push(`${at}: a port with along has no side`);
+	if (typeof port.along !== "number" || !Number.isFinite(port.along) || port.along < 0 || port.along > 1) problems.push(`${at}: the along value ${String(port.along)} is not a finite number from 0 to 1`);
+	if (port.x !== void 0 || port.y !== void 0) problems.push(`${at}: a port with along also has x or y`);
+	return problems;
+}
+/** This function gives the problems of the `pairGaps` of an input. `ids` has the ids of the boxes. */
+function pairGapProblems(pairGaps, ids) {
+	if (pairGaps === void 0) return [];
+	if (!Array.isArray(pairGaps)) return ["pairGaps: the value is not a list"];
+	const problems = [];
+	const seen = /* @__PURE__ */ new Map();
+	pairGaps.forEach((p, i) => {
+		const at = `pair gap ${i} (${String(p?.a)}, ${String(p?.b)})`;
+		if (typeof p !== "object" || p === null || typeof p.a !== "string" || typeof p.b !== "string") {
+			problems.push(`pair gap ${i}: the entry has no string ids a and b`);
+			return;
+		}
+		for (const id of [p.a, p.b]) if (!ids.has(id)) problems.push(`${at}: the box ${id} is not in the input`);
+		if (p.a === p.b) problems.push(`${at}: the two ids are the same box`);
+		if (typeof p.gap !== "number" || !Number.isFinite(p.gap) || p.gap < 0) problems.push(`${at}: the gap ${String(p.gap)} is not a finite number of 0 or more`);
+		if (p.lanes !== void 0 && (typeof p.lanes !== "number" || !Number.isInteger(p.lanes) || p.lanes < 0)) problems.push(`${at}: the lanes value ${String(p.lanes)} is not a whole number of 0 or more`);
+		const key = JSON.stringify(p.a < p.b ? [p.a, p.b] : [p.b, p.a]);
+		const first = seen.get(key);
+		if (first !== void 0) problems.push(`${at}: the pair is also pair gap ${first}`);
+		else seen.set(key, i);
+	});
 	return problems;
 }
 // src/measures.ts
@@ -1287,10 +1414,11 @@ function outputHash(value, options = {}) {
 /**
 * This function gives the hash of a document. It uses the rule of `outputHash`, but the form does not include the field `hash` of the document.
 * With the default grid, it is the input hash of `docs/FORMAT.md` of `packing`.
+* A document with the schema `layout-input/1` goes through `canonicalInput` first. Thus the order of its `pairGaps` does not change the hash.
 */
 function documentHash(doc, options = {}) {
 	const { hash: _hash, ...rest } = doc;
-	return outputHash(rest, options);
+	return outputHash(rest.schema === "layout-input/1" ? canonicalInput(rest) : rest, options);
 }
 /**
 * This function gives the output groups of the candidates. The key of `hashes` is the id of a candidate.
@@ -1858,6 +1986,18 @@ function isActive(p, values) {
 	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 ?? []) {
@@ -1943,6 +2083,8 @@ function optionProblems(stage, o) {
 	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`]);
+		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`]);
 	}
 	return out;
 }
@@ -2053,8 +2195,39 @@ function memberProblems(part, rule, members, at, shapes) {
 		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,
@@ -2063,6 +2236,8 @@ const toBreaks = (problems, inputs = []) => problems.map(([claim, detail]) => ({
 /**
 * 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.
 */
 function checkConfig(space, config, options = {}) {
@@ -2071,6 +2246,7 @@ function checkConfig(space, config, options = {}) {
 /**
 * 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.
 */
 function checkSpace(space) {
@@ -2109,6 +2285,8 @@ function checkSpace(space) {
 	}
 	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;
 }
@@ -2244,7 +2422,7 @@ function* gridParams(params, levels, i = 0, values = {}) {
 }
 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`. */
+/** 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++) {
@@ -2321,10 +2499,11 @@ 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);
 		if (keeps(space, choices)) out.push({
 			choices,
 			base: false,
-			weight: times(countOf(o), memberLists(base, o.members, limit), limit)
+			weight: times(countOf(o), lists, limit)
 		});
 	}
 	return out;
@@ -2332,6 +2511,7 @@ function combos(space, levels, meta, limit) {
 /**
 * 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) {
@@ -2343,10 +2523,11 @@ 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.
 */
 function restrict(space, shapes) {
 	if (shapes === void 0) return space;
-	return {
+	const kept = {
 		...space,
 		stages: space.stages.map((s) => ({
 			...s,
@@ -2354,6 +2535,25 @@ 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;
+		const pool = o.members.pool.filter((entry) => fits(part, entry));
+		return pool.length === 0 ? [] : [{
+			...o,
+			members: {
+				...o.members,
+				pool
+			}
+		}];
+	};
+	return {
+		...kept,
+		stages: kept.stages.map((s) => ({
+			...s,
+			options: s.options.flatMap((o) => withPool(s, o))
+		}))
+	};
 }
 /** This function throws a `RangeError` for a list of shape kinds with a kind that is not declared. */
 function assertShapes(shapes) {
@@ -2473,6 +2673,14 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 				});
 			}
 			if (o.members === void 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 = partOf(space, s.name).space;
 			const poolSize = Math.max(n, 4 * o.members.max, 8);
 			const seen = /* @__PURE__ */ new Set();
@@ -2516,6 +2724,7 @@ function sampleConfigs(space, n, seed, meta, maxTries) {
 * - 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 `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.
 */
 function enumerateSpace(space, options) {
 	assertSpace(space);
@@ -2831,6 +3040,761 @@ function verdict(records, options) {
 		dropped
 	};
 }
-export { DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, JOINT_MEASURES, JOINT_MOVED_MIN, PACK_HARD_RULES, RECORD_EPS, RECORD_SCALE, 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, canonicalJson, checkConfig, checkDeclared, checkInput, checkShapes, checkSpace, checkSplit, compareMeasure, configId, corpusHashOf, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, declaredClaimOf, declaredCounts, documentHash, edgeStep, enumerateSpace, exercised, familyOf, fnv1a32, grow, isShapeKind, itemShapeOf, joinConfigs, leaveOneSeedOut, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramLevels, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, selectBest, sha256Hex, shapeKindOf, shapeKindProblem, shapeKindsOf, shapesOf, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
+// src/families.ts
+/** The name of the output field that lists the fields that `generate` of a registry removed. */
+const INVALIDATED_FIELD = "invalidated";
+/** The random numbers of the default factory: `mulberry32` of `random.ts`. Its stream is pinned in `families.test.ts`. */
+const DEFAULT_RNG = mulberry32;
+/** This function gives the `kind` of the cells of a version of a family: `<name>@<version>`, for example `rect-grid@2`. Thus two versions do not share a family key. */
+function familyKind(name, version) {
+	return `${name}@${version}`;
+}
+/** The default key of a family in a manifest: the kind of the cell alone. It is the map form of `FamilyBy` with the entry `"*"`. */
+const DEFAULT_FAMILY_BY = Object.freeze({ "*": Object.freeze([]) });
+/** This function gives an `enum` dimension. */
+const choice = (name, values, value, meaning, engines) => Object.freeze({
+	name,
+	kind: "enum",
+	values: Object.freeze([...values]),
+	default: value,
+	meaning,
+	engines: Object.freeze([...engines])
+});
+/** This function gives an `int` or a `real` dimension. */
+const range = (name, kind, limits, meaning, engines) => Object.freeze({
+	name,
+	kind,
+	min: limits.min,
+	max: limits.max,
+	default: limits.value,
+	scale: limits.scale ?? "linear",
+	...limits.levels === void 0 ? {} : { levels: Object.freeze([...limits.levels]) },
+	meaning,
+	engines: Object.freeze([...engines])
+});
+const P = "packing";
+const H = "highways";
+const J = "joint";
+/**
+* The shared dimension table. A family takes a dimension of it with `sharedDimension`, or declares its own dimension.
+* The coverage table of each dimension and each engine is in `docs/CORPUS.md`.
+*/
+const CORPUS_DIMENSIONS = Object.freeze({
+	count: range("count", "int", {
+		min: 0,
+		max: 1e5,
+		value: 100,
+		scale: "log",
+		levels: [
+			1,
+			10,
+			100,
+			1e3,
+			1e4
+		]
+	}, "The count of the items (n) of an input.", [
+		P,
+		H,
+		J
+	]),
+	sizes: choice("sizes", [
+		"identical",
+		"nearIdentical",
+		"uniform",
+		"heavyTail",
+		"bimodal",
+		"extremeAspect"
+	], "uniform", "The distribution of the sizes of the items.", [P, J]),
+	aspect: range("aspect", "real", {
+		min: .25,
+		max: 4,
+		value: 1,
+		scale: "log"
+	}, "The width over the height of a container with no fixed size.", [P]),
+	density: range("density", "real", {
+		min: .05,
+		max: 1,
+		value: .4,
+		scale: "linear"
+	}, "The area of the items over the area of the frame of the container.", [P]),
+	obstacles: choice("obstacles", [
+		"none",
+		"center",
+		"scattered",
+		"wall",
+		"corridors",
+		"touching",
+		"edge"
+	], "none", "The layout of the fixed obstacles.", [P, J]),
+	containerSize: choice("containerSize", [
+		"fixed",
+		"freeHeight",
+		"freeWidth",
+		"freeAspect",
+		"freeArea"
+	], "fixed", "The sides of the container that the engine can change.", [P, J]),
+	containerShape: choice("containerShape", [
+		"rect",
+		"convex",
+		"polygon",
+		"circle",
+		"ellipse",
+		"holes"
+	], "rect", "The kind of the shape of the container.", [P, J]),
+	shape: choice("shape", SHAPE_KIND_IDS, "rect", "The shape kind of each item: a `ShapeKind` of `shapes.ts`.", [P]),
+	order: choice("order", ["free", "soft"], "free", "The reading order of the items: no order, or a rank on each item.", [P]),
+	groups: choice("groups", [
+		"none",
+		"flat",
+		"nested"
+	], "none", "The groups of the items: no groups, one level, or groups in groups.", [H, J]),
+	edgeDensity: choice("edgeDensity", [
+		"sparse",
+		"medium",
+		"dense"
+	], "medium", "The mean count of the edges of each item: 0.5, 1.5 or 4.", [H, J]),
+	edgeShape: choice("edgeShape", [
+		"random",
+		"clustered",
+		"hubChain",
+		"hubs",
+		"longRange",
+		"tree",
+		"bundled"
+	], "random", "The topology of the edges.", [H, J]),
+	ports: choice("ports", [
+		"free",
+		"sides",
+		"fixed"
+	], "free", "The ports of the edges: free, a side for each end, or fixed ports.", [H, J]),
+	hubBy: Object.freeze({
+		...choice("hubBy", ["area", "random"], "area", "The order of the hubs of the shapes hubs and tree: the largest item first, or random.", [J]),
+		when: Object.freeze({
+			param: "edgeShape",
+			in: Object.freeze(["hubs", "tree"])
+		})
+	}),
+	spacing: choice("spacing", [
+		"stress",
+		"gap",
+		"margin",
+		"both"
+	], "both", "The split of the route clearance between the margins and the gap. `stress` has neither.", [J]),
+	margin: range("margin", "real", {
+		min: 0,
+		max: 32,
+		value: 0
+	}, "The margin of each item, in units.", [P, J]),
+	gap: range("gap", "real", {
+		min: 0,
+		max: 32,
+		value: 0
+	}, "The free space between two items, in units.", [P, J])
+});
+/**
+* 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.
+*/
+function sharedDimension(name, patch = {}) {
+	const base = Object.hasOwn(CORPUS_DIMENSIONS, name) ? CORPUS_DIMENSIONS[name] : void 0;
+	if (base === void 0) throw new RangeError(`The shared dimension table has no dimension "${name}".`);
+	const dim = Object.freeze({
+		...base,
+		...patch,
+		name
+	});
+	if (patch.supported !== void 0 || patch.invalidates !== 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`.
+* The registry examines the `when` of the dimension, because it needs the earlier dimensions.
+*/
+function ownerDimension(name, spec) {
+	const where = `ownerDimension: the dimension "${name}"`;
+	if (typeof name !== "string" || name === "") throw new RangeError("ownerDimension: the name of a dimension is a text that is not empty.");
+	if (name === "kind") throw new RangeError(`${where} has a reserved name: the cell of \`cellOf\` has the \`familyKind\` of the family in \`kind\`.`);
+	if (Object.hasOwn(CORPUS_DIMENSIONS, name)) throw new RangeError(`${where} is in the shared dimension table. Use sharedDimension("${name}") for it.`);
+	const dim = Object.freeze({
+		...spec,
+		name
+	});
+	throwProblems(where, ownProblems(dim));
+	return dim;
+}
+/** This function throws a `RangeError` with each problem of a list. An empty list throws nothing. */
+function throwProblems(where, problems) {
+	if (problems.length > 0) throw new RangeError(`${where} is not good: ${problems.join("; ")}.`);
+}
+/** This function tells if a value of the stable form of a dimension is in its `supported` values. Without `supported`, each value is in them. */
+function inSupported(dim, value) {
+	const s = dim.supported;
+	if (s === void 0) return true;
+	if (isSupportedList(s)) return s.some((v) => paramValue(dim, v) === value);
+	if (typeof value !== "number") return false;
+	return (s.min === void 0 || value >= s.min) && (s.max === void 0 || value <= s.max);
+}
+/** This function tells if `SupportedValues` has the list form. */
+const isSupportedList = (s) => Array.isArray(s);
+/**
+* This function tells if a family accepts a value of a dimension. A site uses it to show the values that a family does not support.
+* It gives `false` for a bad value, and for a value outside `supported`. Without `supported`, it gives `true` for each good value.
+*/
+function dimensionSupports(dim, value) {
+	if (paramProblem(dim, value) !== void 0) return false;
+	return inSupported(dim, paramValue(dim, value));
+}
+/** This function gives the text of the supported values of a dimension, for a message. */
+function supportedText(dim) {
+	const s = dim.supported;
+	if (s === void 0) return "each value";
+	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`. */
+function ownProblems(d) {
+	const out = [];
+	const bad = paramProblem(d, d.default);
+	if (bad !== void 0) out.push(`the default of "${d.name}" is bad: ${bad}`);
+	for (const v of d.levels ?? []) {
+		const p = paramProblem(d, v);
+		if (p !== void 0) out.push(`a level of "${d.name}" is bad: ${p}`);
+	}
+	out.push(...supportProblems(d, bad === void 0));
+	out.push(...invalidatesProblems(d));
+	return out;
+}
+/** This function gives the problems of the `supported` values of a dimension. `goodDefault` tells that the default is a good value. */
+function supportProblems(d, goodDefault) {
+	const s = d.supported;
+	if (s === void 0) return [];
+	const out = [];
+	const numeric = d.kind === "int" || d.kind === "real";
+	if (isSupportedList(s)) {
+		if (numeric) return [`the supported values of "${d.name}" are a range with min and max, because the dimension is numeric`];
+		if (s.length === 0) return [`the supported values of "${d.name}" are an empty list`];
+		for (const v of s) {
+			const p = paramProblem(d, v);
+			if (p !== void 0) out.push(`a supported value of "${d.name}" is bad: ${p}`);
+		}
+		if (new Set(s).size !== s.length) out.push(`the supported values of "${d.name}" have a value two times`);
+	} else {
+		if (s === null || typeof s !== "object") return [`the supported values of "${d.name}" are a list or a range`];
+		if (!numeric) return [`the supported values of "${d.name}" are a list, because the dimension is not numeric`];
+		for (const end of [s.min, s.max]) {
+			if (end === void 0) continue;
+			const p = paramProblem(d, end);
+			if (p !== void 0) out.push(`an end of the supported range of "${d.name}" is bad: ${p}`);
+		}
+		if (s.min !== void 0 && s.max !== void 0 && s.min > s.max) out.push(`the supported range of "${d.name}" has a min above its max`);
+	}
+	if (out.length > 0) return out;
+	if (goodDefault && !inSupported(d, paramValue(d, d.default))) out.push(`the default of "${d.name}" is not a supported value`);
+	for (const v of d.levels ?? []) if (paramProblem(d, v) === void 0 && !inSupported(d, paramValue(d, v))) out.push(`the level ${JSON.stringify(v)} of "${d.name}" is not a supported value`);
+	return out;
+}
+/** This function gives the problems of the `invalidates` fields of a dimension. */
+function invalidatesProblems(d) {
+	const list = d.invalidates;
+	if (list === void 0) return [];
+	if (!Array.isArray(list) || !list.every((f) => typeof f === "string" && f !== "")) return [`the invalidates of "${d.name}" is not a list of field names`];
+	const out = [];
+	if (new Set(list).size !== list.length) out.push(`the invalidates of "${d.name}" has a field two times`);
+	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 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;
+/**
+* This function gives the value at the fraction `t` of the range of a numeric dimension, on its scale. A slider of a site uses it.
+* A log scale with a `min` of 0 or less is the log of `1 + x - min`. An `int` dimension gives a whole number.
+*/
+function dimensionAt(dim, t) {
+	const min = dim.min ?? 0;
+	const max = dim.max ?? min;
+	const u = Math.min(1, Math.max(0, t));
+	let v;
+	if (dim.scale !== "log") v = min + u * (max - min);
+	else if (fromZero(dim)) v = min + Math.expm1(u * Math.log1p(max - min));
+	else v = Math.exp(Math.log(min) + u * (Math.log(max) - Math.log(min)));
+	v = Math.min(max, Math.max(min, v));
+	return dim.kind === "int" ? Math.round(v) : paramValue(dim, v);
+}
+/** This function gives the fraction of the range of a numeric dimension at a value, on its scale. It is the inverse of `dimensionAt`. */
+function dimensionUnit(dim, value) {
+	const min = dim.min ?? 0;
+	const max = dim.max ?? min;
+	if (max === min) return 0;
+	const v = Math.min(max, Math.max(min, value));
+	if (dim.scale !== "log") return (v - min) / (max - min);
+	if (fromZero(dim)) return Math.log1p(v - min) / Math.log1p(max - min);
+	return (Math.log(v) - Math.log(min)) / (Math.log(max) - Math.log(min));
+}
+/** This function gives the range of the supported values of a numeric dimension: its own `min` and `max` in place of the ends of `supported`. */
+function supportedSpan(dim) {
+	const s = dim.supported;
+	const range = s === void 0 || isSupportedList(s) ? {} : s;
+	return {
+		min: range.min ?? dim.min,
+		max: range.max ?? dim.max
+	};
+}
+/**
+* This function gives the values of a sweep of a dimension. `levels` of the dimension come first. Then an `enum` gives its values, and a `bool` gives `false` and `true`.
+* With `steps`, a numeric dimension gives `steps` points from `min` to `max` on its scale. Else it gives its default.
+* With `supported`, an `enum` and a `bool` give only the supported values, and the points of a numeric dimension stay in the supported range.
+*/
+function levelsOf(dim, steps) {
+	if (dim.levels !== void 0) return [...dim.levels];
+	if (dim.kind === "enum" || dim.kind === "bool") return paramLevels(dim, 1).filter((v) => inSupported(dim, paramValue(dim, v)));
+	if (steps === void 0) return paramLevels(dim, 1);
+	if (dim.supported !== void 0) {
+		const { supported: _supported, ...rest } = dim;
+		const span = supportedSpan(dim);
+		return levelsOf({
+			...rest,
+			...span.min === void 0 ? {} : { min: span.min },
+			...span.max === void 0 ? {} : { max: span.max }
+		}, steps);
+	}
+	if (!fromZero(dim)) return paramLevels(dim, steps);
+	if (!Number.isInteger(steps) || steps < 1) throw new RangeError(`The steps of a sweep are a whole number of 1 or more, not ${steps}.`);
+	if (steps === 1) return [paramValue(dim, dim.default)];
+	return [...new Set(Array.from({ length: steps }, (_, j) => dimensionAt(dim, j / (steps - 1))))];
+}
+/** This function gives the problems of the dimensions of a family: a repeated name, a bad default, level, `supported`, `invalidates` or `when`. */
+function dimensionProblems(dims) {
+	const out = [];
+	const names = dims.map((d) => d.name);
+	dims.forEach((d, i) => {
+		if (names.indexOf(d.name) !== i) out.push(`the dimension "${d.name}" is in the list two times`);
+		out.push(...ownProblems(d));
+		if (d.when === void 0) return;
+		const j = names.indexOf(d.when.param);
+		if (j < 0 || j >= i) out.push(`the when of "${d.name}" names "${d.when.param}", which is not an earlier dimension`);
+		else if (d.when.in.length === 0) out.push(`the when of "${d.name}" has no values`);
+		else for (const v of d.when.in) if (paramProblem(dims[j], v) !== void 0) out.push(`the when of "${d.name}" has a value that "${d.when.param}" does not have`);
+	});
+	return out;
+}
+/**
+* This function gives the full dimension values of an input. A missing dimension gets its default. An inactive dimension of `when` also gets its default.
+* Thus a default that the caller gives, a missing value and an inactive value give the same values. A real number gets its stable form.
+*
+* The function throws a `RangeError` for an unknown dimension or a bad value, also for a bad value of an inactive dimension.
+* It also throws a `RangeError` for a value outside `supported`, with the text "not supported by" and `by`.
+*/
+function resolveDimensions(dimensions, dims = {}, where = "The family", by = "the family") {
+	const known = new Set(dimensions.map((d) => d.name));
+	for (const key of Object.keys(dims)) if (!known.has(key)) throw new RangeError(`${where} has no dimension "${key}".`);
+	const active = {};
+	const out = {};
+	for (const d of dimensions) {
+		const given = Object.hasOwn(dims, d.name) ? dims[d.name] : void 0;
+		if (given !== void 0) {
+			const bad = paramProblem(d, given);
+			if (bad !== void 0) throw new RangeError(`${where}: the dimension "${d.name}" is bad: ${bad}.`);
+			if (!inSupported(d, paramValue(d, given))) throw new RangeError(`${where}: the value ${JSON.stringify(given)} of the dimension "${d.name}" is not supported by ${by}. The supported values are ${supportedText(d)}.`);
+		}
+		const on = paramActive(d, active);
+		const value = paramValue(d, on && given !== void 0 ? given : d.default);
+		if (on) active[d.name] = value;
+		out[d.name] = value;
+	}
+	return out;
+}
+/** This function gives the values of the active dimensions only. */
+function activeValues(dimensions, full) {
+	const active = {};
+	for (const d of dimensions) if (paramActive(d, active)) active[d.name] = full[d.name];
+	return active;
+}
+/** This function gives the active values of each cell of a sweep, in the order of the dimensions. The last dimension changes first. */
+function* sweepOf(dimensions, levels, i = 0, values = {}) {
+	if (i === dimensions.length) {
+		yield { ...values };
+		return;
+	}
+	const d = dimensions[i];
+	const lv = levels[i];
+	if (lv === void 0 || !paramActive(d, values)) {
+		yield* sweepOf(dimensions, levels, i + 1, paramActive(d, values) ? {
+			...values,
+			[d.name]: paramValue(d, d.default)
+		} : values);
+		return;
+	}
+	for (const v of lv) yield* sweepOf(dimensions, levels, i + 1, {
+		...values,
+		[d.name]: paramValue(d, v)
+	});
+}
+/** This function counts the cells of a sweep with no list of the cells. A dimension that a later `when` reads splits the count. */
+function countOf(dimensions, levels, i = 0, values = {}) {
+	if (i === dimensions.length) return 1;
+	const d = dimensions[i];
+	if (!paramActive(d, values)) return countOf(dimensions, levels, i + 1, values);
+	const lv = levels[i] ?? [d.default];
+	if (!dimensions.slice(i + 1).some((q) => q.when?.param === d.name)) return lv.length * countOf(dimensions, levels, i + 1, values);
+	let sum = 0;
+	for (const v of lv) sum += countOf(dimensions, levels, i + 1, {
+		...values,
+		[d.name]: paramValue(d, v)
+	});
+	return sum;
+}
+/** This function gives the levels of each dimension of a sweep. A dimension outside the sweep has `undefined`, so it keeps its default. */
+function sweepLevels(dimensions, options, where, by) {
+	const names = new Set(dimensions.map((d) => d.name));
+	for (const name of [...options.sweep ?? [], ...Object.keys(options.levels ?? {})]) if (!names.has(name)) throw new RangeError(`${where} has no dimension "${name}".`);
+	return dimensions.map((d) => {
+		if (options.sweep !== void 0 && !options.sweep.includes(d.name)) return void 0;
+		const lv = options.levels !== void 0 && Object.hasOwn(options.levels, d.name) ? options.levels[d.name] : levelsOf(d);
+		for (const v of lv) {
+			const bad = paramProblem(d, v);
+			if (bad !== void 0) throw new RangeError(`${where}: a level of "${d.name}" is bad: ${bad}.`);
+			if (!inSupported(d, paramValue(d, v))) throw new RangeError(`${where}: the level ${JSON.stringify(v)} of "${d.name}" is not supported by ${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. */
+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);
+	}
+	return [...out].sort(byCode);
+}
+/** This function compares two strings by their UTF-16 code units. */
+const byCode = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+/**
+* This function removes the fields of `fields` from an output, and adds their names to its field `invalidated`, sorted.
+* Only a field of the output counts. The `hash` of text gets the value of `hash` again. An output with none of the fields is the same object.
+*/
+function dropFields(output, fields, hash, where) {
+	if (fields.length === 0) return output;
+	if (output === null || typeof output !== "object" || Array.isArray(output)) throw new RangeError(`${where} invalidates the fields ${fields.join(", ")}, but its output is not an object.`);
+	const o = output;
+	const dropped = fields.filter((f) => Object.hasOwn(o, f));
+	if (dropped.length === 0) return output;
+	const before = o[INVALIDATED_FIELD];
+	const prior = Array.isArray(before) ? before.filter((f) => typeof f === "string") : [];
+	const body = {};
+	for (const key of Object.keys(o)) if (key !== "hash" && key !== "invalidated" && !dropped.includes(key)) body[key] = o[key];
+	body[INVALIDATED_FIELD] = [.../* @__PURE__ */ new Set([...prior, ...dropped])].sort(byCode);
+	if (typeof o["hash"] !== "string") return Object.hasOwn(o, "hash") ? {
+		...body,
+		hash: o["hash"]
+	} : body;
+	return {
+		...body,
+		hash: hash(body)
+	};
+}
+/** This function gives the values that make a dimension active: the first value of its `when`, and the values that make that dimension active. */
+function activation(dimensions, dim) {
+	const out = {};
+	let d = dim;
+	while (d?.when !== void 0) {
+		const param = d.when.param;
+		out[param] = d.when.in[0];
+		d = dimensions.find((q) => q.name === param);
+	}
+	return out;
+}
+/** This function throws a `RangeError` when a seed is not a whole number of 0 or more. */
+function checkSeed(seed) {
+	if (!Number.isSafeInteger(seed) || seed < 0) throw new RangeError(`The seed is a whole number of 0 or more, not ${seed}.`);
+}
+/** This function gives a new registry with the families of the list. Each engine gives the list of its families. An import registers nothing. */
+function createFamilyRegistry(families = []) {
+	const list = [];
+	const label = (f) => `The family "${f.name}" version ${f.version}`;
+	const find = (name, version) => {
+		const named = list.filter((f) => f.name === name);
+		if (named.length === 0) throw new RangeError(`The registry has no family "${name}".`);
+		if (version === void 0) return named[0];
+		const found = named.find((f) => f.version === version);
+		if (found === void 0) throw new RangeError(`The family "${name}" has the versions ${named.map((f) => f.version).join(", ")}, not ${version}.`);
+		return found;
+	};
+	/** This function removes the `kind` of a cell of `cellOf` when it is the `familyKind` of `f`. It throws a `RangeError` for another kind. */
+	const ownDims = (f, dims) => {
+		if (dims === void 0 || !Object.hasOwn(dims, "kind")) return dims;
+		const kind = familyKind(f.name, f.version);
+		if (dims["kind"] !== kind) throw new RangeError(`${label(f)} has the kind "${kind}", not the kind ${JSON.stringify(dims["kind"])} of the cell.`);
+		const { kind: _kind, ...rest } = dims;
+		return rest;
+	};
+	/** This function gives the full dimension values of an input of `f`. A message names the family as `familyKind` gives it. */
+	const resolveIn = (f, dims) => resolveDimensions(f.dimensions, dims, label(f), familyKind(f.name, f.version));
+	const streamOf = (f, seed, full) => {
+		const rng = f.rng ?? DEFAULT_RNG;
+		return {
+			rng,
+			random: rng(f.rngSeed === void 0 ? seed : f.rngSeed(seed, full))
+		};
+	};
+	const registry = {
+		register(family) {
+			if (!Number.isInteger(family.version) || family.version < 1) throw new RangeError(`${label(family)} has a version that is not a whole number of 1 or more.`);
+			if (list.some((f) => f.name === family.name && f.version === family.version)) throw new RangeError(`${label(family)} is in the registry already.`);
+			const problems = dimensionProblems(family.dimensions);
+			if (family.dimensions.map((d) => d.name).includes("kind")) problems.push("the dimension name \"kind\" is reserved: the cell of `cellOf` has the `familyKind` of the family in `kind`");
+			for (const key of family.familyBy ?? []) {
+				const d = family.dimensions.find((q) => q.name === key);
+				if (d === void 0) problems.push(`the familyBy dimension "${key}" is not a dimension of the family`);
+				else if (d.when !== void 0) problems.push(`the familyBy dimension "${key}" has a when, so a cell without it has no family key`);
+			}
+			if (problems.length > 0) throw new RangeError(`${label(family)} is not good: ${problems.join("; ")}.`);
+			list.push(family);
+			return registry;
+		},
+		family: find,
+		families: () => [...list],
+		resolve(name, dims, version) {
+			const f = find(name, version);
+			return resolveIn(f, ownDims(f, dims));
+		},
+		generate(name, seed, dims, options = {}) {
+			checkSeed(seed);
+			const f = find(name, options.version);
+			const full = resolveIn(f, ownDims(f, dims));
+			const context = {
+				...streamOf(f, seed, full),
+				...options.set === void 0 ? {} : { set: options.set }
+			};
+			const output = f.generate(seed, full, context);
+			const hash = f.hash ?? documentHash;
+			return dropFields(output, invalidFields(f.dimensions, full), hash, label(f));
+		},
+		cellOf(name, dims, version) {
+			const f = find(name, version);
+			return {
+				kind: familyKind(f.name, f.version),
+				...activeValues(f.dimensions, resolveIn(f, ownDims(f, dims)))
+			};
+		},
+		*cells(name, options = {}) {
+			const f = find(name, options.version);
+			for (const values of sweepOf(f.dimensions, sweepLevels(f.dimensions, options, label(f), familyKind(f.name, f.version)))) yield resolveIn(f, values);
+		},
+		cellCount(name, options = {}) {
+			const f = find(name, options.version);
+			return countOf(f.dimensions, sweepLevels(f.dimensions, options, label(f), familyKind(f.name, f.version)));
+		},
+		boundaryCells(name, version) {
+			const f = find(name, version);
+			const base = resolveIn(f, {});
+			const out = [base];
+			const seen = /* @__PURE__ */ new Set([JSON.stringify(base)]);
+			for (const d of f.dimensions) {
+				if (d.kind !== "int" && d.kind !== "real") continue;
+				const span = supportedSpan(d);
+				for (const end of [span.min, span.max]) {
+					if (end === void 0) continue;
+					const cell = resolveIn(f, {
+						...activation(f.dimensions, d),
+						[d.name]: end
+					});
+					const key = JSON.stringify(cell);
+					if (!seen.has(key)) {
+						seen.add(key);
+						out.push(cell);
+					}
+				}
+			}
+			return out;
+		},
+		rngOf(name, version) {
+			const f = find(name, version);
+			return (seed, dims) => {
+				checkSeed(seed);
+				return streamOf(f, seed, resolveIn(f, ownDims(f, dims))).random;
+			};
+		},
+		familyBy() {
+			const out = {};
+			for (const f of list) out[familyKind(f.name, f.version)] = [...f.familyBy ?? []];
+			return out;
+		}
+	};
+	for (const f of families) registry.register(f);
+	return registry;
+}
+/** This function gives the values of a list of dimensions from the full values. */
+const pick = (dims, full) => Object.fromEntries(dims.map((d) => [d.name, full[d.name]]));
+/**
+* This function gives a family that runs the base family and then each step, with the same seed.
+* The family of the input gets the part of each step after a dot. The id becomes `<set>/<family>/s<seed>`, and the input gets the hash of `options.hash`.
+* The function throws a `RangeError` when a step has a dimension with the name of an earlier dimension.
+*/
+function composeFamily(base, steps, options = {}) {
+	const dimensions = [...base.dimensions, ...steps.flatMap((s) => s.dimensions)];
+	const seen = /* @__PURE__ */ new Set();
+	for (const d of dimensions) {
+		if (seen.has(d.name)) throw new RangeError(`composeFamily: the dimension "${d.name}" is in the base family or in an earlier step already.`);
+		seen.add(d.name);
+	}
+	const hash = options.hash ?? documentHash;
+	const libm = base.crossEngine === "libm-dependent" || steps.some((s) => s.crossEngine === "libm-dependent");
+	return Object.freeze({
+		name: options.name ?? [base.name, ...steps.map((s) => s.name)].join("+"),
+		version: base.version,
+		owner: options.owner ?? base.owner,
+		meaning: options.meaning ?? `${base.meaning} Then the steps ${steps.map((s) => s.name).join(", ")}.`,
+		dimensions,
+		seeding: [base.seeding, ...steps.map((s) => `${s.name}: ${s.seeding}`)].join(" "),
+		crossEngine: libm ? "libm-dependent" : "exact",
+		...base.rng === void 0 ? {} : { rng: base.rng },
+		...base.rngSeed === void 0 ? {} : { rngSeed: (seed, full) => base.rngSeed(seed, pick(base.dimensions, full)) },
+		...base.familyBy === void 0 ? {} : { familyBy: base.familyBy },
+		...options.hash === void 0 ? {} : { hash: options.hash },
+		generate(seed, full, context) {
+			let input = base.generate(seed, pick(base.dimensions, full), context);
+			const parts = [];
+			for (const step of steps) {
+				const values = pick(step.dimensions, full);
+				input = step.apply(input, seed, values);
+				if (step.familyPart !== void 0) parts.push(step.familyPart(values));
+			}
+			const family = [input.family ?? base.name, ...parts].join(".");
+			const set = input.set ?? context.set;
+			const id = `${set === void 0 ? "" : `${set}/`}${family}/s${seed}`;
+			const stepped = {
+				...input,
+				id,
+				family
+			};
+			return {
+				...stepped,
+				hash: hash(stepped)
+			};
+		}
+	});
+}
+/** The dimensions of `EDGES_STEP`: the parameters of `edgeStep`, from the shared table. */
+const EDGE_DIMENSIONS = Object.freeze([
+	"edgeDensity",
+	"edgeShape",
+	"groups",
+	"ports",
+	"hubBy"
+].map((n) => CORPUS_DIMENSIONS[n]));
+/** This function gives the parameters of `edgeStep` from the values of the dimensions. It throws a `RangeError` for a missing or a bad value. */
+function edgeParams(d) {
+	const text = (name) => {
+		const dim = EDGE_DIMENSIONS.find((q) => q.name === name);
+		const value = Object.hasOwn(d, name) ? d[name] : void 0;
+		const bad = value === void 0 ? "the value is missing" : paramProblem(dim, value);
+		if (bad !== void 0 || typeof value !== "string") throw new RangeError(`EDGES_STEP: the dimension "${name}" is bad: ${bad ?? "it is not text"}.`);
+		return value;
+	};
+	return {
+		edgeDensity: text("edgeDensity"),
+		edgeShape: text("edgeShape"),
+		groups: text("groups"),
+		ports: text("ports"),
+		hubBy: text("hubBy")
+	};
+}
+/**
+* The step `edges` of `edgeStep` (version 1), as a corpus step. Its family part is `e-<edgeDensity>.<edgeShape>.<groups>.<ports>`.
+* The value `random` of `hubBy` adds the part `.hub-random`.
+*/
+const EDGES_STEP = Object.freeze({
+	name: "edges",
+	version: 1,
+	owner: "layout-contract",
+	meaning: "The edges, the groups and the ports of an input, from its topology alone.",
+	dimensions: EDGE_DIMENSIONS,
+	seeding: "stepRandom(seed, step) for the steps edges and ports.",
+	crossEngine: "libm-dependent",
+	familyPart: (d) => `e-${d["edgeDensity"]}.${d["edgeShape"]}.${d["groups"]}.${d["ports"]}${d["hubBy"] === "random" ? ".hub-random" : ""}`,
+	apply: (input, seed, d) => edgeStep(input, edgeParams(d), seed)
+});
+/** The set of `RECT_SCATTERED` when the caller gives no set. */
+const XCHECK_SET = "xcheck-v1";
+/**
+* The shared family `rect-scattered`, version 1: a fixed rectangle container, rectangle obstacles at random places and boxes without positions.
+* It is the one copy of the generator of `docs/FORMAT.md` of `packing`. Its input is the input of `packing`, byte for byte.
+* The steps `container`, `obstacles` and `boxes` each have a stream of `stepRandom`. Each value is a whole number, so the family is `exact`.
+*/
+const RECT_SCATTERED = Object.freeze({
+	name: "rect-scattered",
+	version: 1,
+	owner: "layout-contract",
+	meaning: "Rectangle obstacles at random places in a fixed rectangle container, and boxes of random sizes.",
+	dimensions: Object.freeze([sharedDimension("count", { default: 40 })]),
+	seeding: "stepRandom(seed, container) gives w and h. stepRandom(seed, obstacles) gives n, then ow, oh, x and y of each obstacle. stepRandom(seed, boxes) gives bw and bh of each box.",
+	crossEngine: "exact",
+	generate(seed, dims, context) {
+		const count = dims["count"];
+		if (typeof count !== "number" || !Number.isInteger(count) || count < 0) throw new RangeError(`rect-scattered: the count is a whole number of 0 or more, not ${String(count)}.`);
+		const set = context.set ?? XCHECK_SET;
+		let r = stepRandom(seed, "container");
+		const w = randomInt(r, 600, 1e3);
+		const h = randomInt(r, 400, 800);
+		r = stepRandom(seed, "obstacles");
+		const n = randomInt(r, 3, 8);
+		const obstacles = [];
+		for (let i = 0; i < n; i++) {
+			const ow = randomInt(r, 40, 160);
+			const oh = randomInt(r, 40, 160);
+			const x = randomInt(r, 0, w - ow);
+			const y = randomInt(r, 0, h - oh);
+			obstacles.push({
+				id: `o${i}`,
+				region: {
+					kind: "rect",
+					x,
+					y,
+					w: ow,
+					h: oh
+				}
+			});
+		}
+		r = stepRandom(seed, "boxes");
+		const boxes = Array.from({ length: count }, (_, i) => {
+			const bw = randomInt(r, 20, 120);
+			const bh = randomInt(r, 20, 80);
+			return {
+				id: `b${i}`,
+				w: bw,
+				h: bh
+			};
+		});
+		const body = {
+			schema: "layout-input/1",
+			id: `${set}/rect-scattered/s${seed}`,
+			set,
+			family: "rect-scattered",
+			seed,
+			source: "made-up",
+			generator: {
+				name: "rect-scattered",
+				version: 1,
+				params: { count },
+				seed
+			},
+			container: {
+				w,
+				h,
+				fixed: "size"
+			},
+			obstacles,
+			boxes,
+			edges: []
+		};
+		return {
+			...body,
+			hash: documentHash(body)
+		};
+	}
+});
+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 };
 
 //# sourceMappingURL=index.js.map