@mark1russell7/layout-contract 0.2.14 → 0.2.15

package/build/index.js

@@ -260,6 +260,36 @@ 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 {
@@ -271,7 +301,7 @@ function toPackInput(input) {
 	};
 }
 /** This function compares two strings by their UTF-16 code units, as `Array.prototype.sort` does without a compare function. */
-const byCode = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+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`.
@@ -279,11 +309,11 @@ const byCode = (x, y) => x < y ? -1 : x > y ? 1 : 0;
 */
 function canonicalInput(input) {
 	if (!Array.isArray(input.pairGaps)) return input;
-	const pairGaps = input.pairGaps.map((p) => byCode(p.a, p.b) > 0 ? {
+	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(x.a, y.a) || byCode(x.b, y.b));
+	} : p).sort((x, y) => byCode$1(x.a, y.a) || byCode$1(x.b, y.b));
 	return {
 		...input,
 		pairGaps
@@ -298,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. */
@@ -764,6 +800,7 @@ 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 = [];
@@ -775,12 +812,23 @@ 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 [];
@@ -2993,6 +3041,8 @@ function verdict(records, options) {
 	};
 }
 // 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. */
@@ -3141,15 +3191,118 @@ const CORPUS_DIMENSIONS = Object.freeze({
 		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. */
+/**
+* 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}".`);
-	return Object.freeze({
+	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;
@@ -3178,30 +3331,45 @@ function dimensionUnit(dim, value) {
 	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" || steps === void 0) return paramLevels(dim, 1);
+	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, a bad level or a bad `when`. */
+/** 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`);
-		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(...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`);
@@ -3213,9 +3381,11 @@ function dimensionProblems(dims) {
 /**
 * 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") {
+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 = {};
@@ -3225,6 +3395,7 @@ function resolveDimensions(dimensions, dims = {}, where = "The family") {
 		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);
@@ -3274,7 +3445,7 @@ function countOf(dimensions, levels, i = 0, values = {}) {
 	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) {
+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) => {
@@ -3283,10 +3454,46 @@ function sweepLevels(dimensions, options, where) {
 		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 = {};
@@ -3322,6 +3529,8 @@ function createFamilyRegistry(families = []) {
 		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 {
@@ -3348,46 +3557,49 @@ function createFamilyRegistry(families = []) {
 		families: () => [...list],
 		resolve(name, dims, version) {
 			const f = find(name, version);
-			return resolveDimensions(f.dimensions, ownDims(f, dims), label(f));
+			return resolveIn(f, ownDims(f, dims));
 		},
 		generate(name, seed, dims, options = {}) {
 			checkSeed(seed);
 			const f = find(name, options.version);
-			const full = resolveDimensions(f.dimensions, ownDims(f, dims), label(f));
+			const full = resolveIn(f, ownDims(f, dims));
 			const context = {
 				...streamOf(f, seed, full),
 				...options.set === void 0 ? {} : { set: options.set }
 			};
-			return f.generate(seed, full, context);
+			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, resolveDimensions(f.dimensions, ownDims(f, dims), label(f)))
+				...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)))) yield resolveDimensions(f.dimensions, values, label(f));
+			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)));
+			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 = resolveDimensions(f.dimensions, {}, label(f));
+			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;
-				for (const end of [d.min, d.max]) {
+				const span = supportedSpan(d);
+				for (const end of [span.min, span.max]) {
 					if (end === void 0) continue;
-					const cell = resolveDimensions(f.dimensions, {
+					const cell = resolveIn(f, {
 						...activation(f.dimensions, d),
 						[d.name]: end
-					}, label(f));
+					});
 					const key = JSON.stringify(cell);
 					if (!seen.has(key)) {
 						seen.add(key);
@@ -3401,7 +3613,7 @@ function createFamilyRegistry(families = []) {
 			const f = find(name, version);
 			return (seed, dims) => {
 				checkSeed(seed);
-				return streamOf(f, seed, resolveDimensions(f.dimensions, ownDims(f, dims), label(f))).random;
+				return streamOf(f, seed, resolveIn(f, ownDims(f, dims))).random;
 			};
 		},
 		familyBy() {
@@ -3440,6 +3652,7 @@ function composeFamily(base, steps, options = {}) {
 		...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 = [];
@@ -3582,6 +3795,6 @@ const RECT_SCATTERED = Object.freeze({
 		};
 	}
 });
-export { CORPUS_DIMENSIONS, DEFAULT_FAMILY_BY, DEFAULT_RNG, DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGES_STEP, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, 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, dimensionUnit, documentHash, edgeStep, enumerateSpace, exercised, familyKind, familyOf, fnv1a32, grow, isShapeKind, itemShapeOf, joinConfigs, leaveOneSeedOut, levelsOf, marginSides, minEffectOf, mulberry32, outputGroups, outputHash, overlapOf, packHard, paramActive, paramLevels, paramProblem, paramValue, pickMoves, placedRect, portfolio, productSpace, randomInt, rectInRegion, regionHitsRect, resolveDimensions, selectBest, sha256Hex, shapeKindOf, shapeKindProblem, shapeKindsOf, shapesOf, sharedDimension, spaceShapeKinds, spaceSize, splitConfig, splitFileName, splitFolds, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide, verdict };
+export { CORPUS_DIMENSIONS, DEFAULT_FAMILY_BY, DEFAULT_RNG, DEFAULT_SHAPES, DEFAULT_TOLERANCE, EDGES_STEP, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, FAMILY_ANY_KIND, INVALIDATED_FIELD, JOINT_MEASURES, JOINT_MOVED_MIN, PACK_HARD_RULES, RECORD_EPS, RECORD_SCALE, RECT_SCATTERED, SHAPE_KINDS, SHAPE_KIND_IDS, SIDES, SPLIT_SCHEMA, STRATEGY_SPACE_SCHEMA, VERDICT_DRAWS, VERDICT_EXACT_CAP, VERDICT_EXACT_MAX, VERDICT_RUNS, VERDICT_SEED, applyPack, boundsOf, 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