@mark1russell7/packing 0.2.10 → 0.2.12

package/build/index.js

@@ -369,27 +369,38 @@ function readFrame(input, frame, trace, moved = [], turns) {
 	};
 }
 /**
-* This function gives the size of the container after a packing. A fixed side keeps its size. A free side goes to the
-* far edge of the items with their margins and the inset, or of the obstacles.
+* This function gives the far edges of a packing from the corner of the container. It reads the items with their margins,
+* the inset and the obstacles. With `turn`, a placement with `turn: 90` reads the turned item.
 */
-function sizeOf(input, frame, placements, moved, turns) {
+function extentOf(input, placements, moved, origin = containerBounds(input), inset = input.container.inset ?? 0, turn) {
 	const items = new Map(input.items.map((i) => [i.id, i]));
 	let right = 0;
 	let bottom = 0;
 	for (const p of placements) {
 		const given = items.get(p.id);
-		const item = p.turn === 90 && turns !== void 0 ? turns.turn(given) : given;
+		const item = p.turn === 90 && turn !== void 0 ? turn(given) : given;
 		const m = marginOf(item);
-		right = Math.max(right, p.x + item.w + m.right + frame.inset - frame.bounds.x);
-		bottom = Math.max(bottom, p.y + item.h + m.bottom + frame.inset - frame.bounds.y);
+		right = Math.max(right, p.x + item.w + m.right + inset - origin.x);
+		bottom = Math.max(bottom, p.y + item.h + m.bottom + inset - origin.y);
 	}
 	const movedById = new Map(moved.map((m) => [m.id, m]));
 	for (const o of input.obstacles ?? []) {
 		const b = boundsOf(o.region);
 		const at = movedById.get(o.id) ?? b;
-		right = Math.max(right, at.x + b.w - frame.bounds.x);
-		bottom = Math.max(bottom, at.y + b.h - frame.bounds.y);
+		right = Math.max(right, at.x + b.w - origin.x);
+		bottom = Math.max(bottom, at.y + b.h - origin.y);
 	}
+	return {
+		right,
+		bottom
+	};
+}
+/**
+* This function gives the size of the container after a packing. A fixed side keeps its size. A free side goes to the
+* far edge of the items with their margins and the inset, or of the obstacles.
+*/
+function sizeOf(input, frame, placements, moved, turns) {
+	const { right, bottom } = extentOf(input, placements, moved, frame.bounds, frame.inset, turns?.turn);
 	return {
 		w: Number.isFinite(frame.bounds.w) ? frame.bounds.w : right,
 		h: Number.isFinite(frame.bounds.h) ? frame.bounds.h : bottom
@@ -868,14 +879,18 @@ function inside(a, b) {
 function cut(free, b, minW, minH) {
 	const kept = [];
 	const parts = [];
+	const sides = [];
 	let hits = 0;
-	const add = (x0, y0, x1, y1) => {
-		if (x1 - x0 >= minW && y1 - y0 >= minH) parts.push({
-			x0,
-			y0,
-			x1,
-			y1
-		});
+	const add = (side, x0, y0, x1, y1) => {
+		if (x1 - x0 >= minW && y1 - y0 >= minH) {
+			parts.push({
+				x0,
+				y0,
+				x1,
+				y1
+			});
+			sides.push(side);
+		}
 	};
 	for (const f of free) {
 		if (b.x0 >= f.x1 || b.x1 <= f.x0 || b.y0 >= f.y1 || b.y1 <= f.y0) {
@@ -883,21 +898,54 @@ function cut(free, b, minW, minH) {
 			continue;
 		}
 		hits++;
-		if (b.x0 > f.x0) add(f.x0, f.y0, b.x0, f.y1);
-		if (b.x1 < f.x1) add(b.x1, f.y0, f.x1, f.y1);
-		if (b.y0 > f.y0) add(f.x0, f.y0, f.x1, b.y0);
-		if (b.y1 < f.y1) add(f.x0, b.y1, f.x1, f.y1);
+		if (b.x0 > f.x0) add(0, f.x0, f.y0, b.x0, f.y1);
+		if (b.x1 < f.x1) add(1, b.x1, f.y0, f.x1, f.y1);
+		if (b.y0 > f.y0) add(2, f.x0, f.y0, f.x1, b.y0);
+		if (b.y1 < f.y1) add(3, f.x0, b.y1, f.x1, f.y1);
+	}
+	if (parts.length === 0) return {
+		free: kept,
+		hits
+	};
+	const near = [
+		[],
+		[],
+		[],
+		[]
+	];
+	for (const k of kept) {
+		if (k.x1 === b.x0) near[0].push(k);
+		if (k.x0 === b.x1) near[1].push(k);
+		if (k.y1 === b.y0) near[2].push(k);
+		if (k.y0 === b.y1) near[3].push(k);
+	}
+	const order = parts.map((_, i) => i).sort((i, j) => byExtent(parts[i], parts[j]) || i - j);
+	const gone = new Uint8Array(parts.length);
+	const stay = [
+		[],
+		[],
+		[],
+		[]
+	];
+	for (const i of order) {
+		const p = parts[i];
+		const own = stay[sides[i]];
+		let drop = false;
+		for (const q of own) if (inside(p, q)) {
+			drop = true;
+			break;
+		}
+		if (drop) gone[i] = 1;
+		else own.push(p);
 	}
-	const count = kept.length;
 	for (let i = 0; i < parts.length; i++) {
+		if (gone[i] === 1) continue;
 		const p = parts[i];
 		let drop = false;
-		for (let j = 0; j < parts.length && !drop; j++) {
-			if (j === i) continue;
-			const q = parts[j];
-			if (inside(p, q) && (j < i || !inside(q, p))) drop = true;
+		for (const k of near[sides[i]]) if (inside(p, k)) {
+			drop = true;
+			break;
 		}
-		for (let k = 0; k < count && !drop; k++) if (inside(p, kept[k])) drop = true;
 		if (!drop) kept.push(p);
 	}
 	return {
@@ -905,6 +953,17 @@ function cut(free, b, minW, minH) {
 		hits
 	};
 }
+/**
+* This function orders two boxes. The smaller `x0` comes first, then the smaller `y0`, then the larger `x1`, then the
+* larger `y1`. Thus a box comes before each other box in it.
+*/
+function byExtent(a, b) {
+	if (a.x0 !== b.x0) return a.x0 < b.x0 ? -1 : 1;
+	if (a.y0 !== b.y0) return a.y0 < b.y0 ? -1 : 1;
+	if (a.x1 !== b.x1) return a.x1 > b.x1 ? -1 : 1;
+	if (a.y1 !== b.y1) return a.y1 > b.y1 ? -1 : 1;
+	return 0;
+}
 /** This function adds a range to the edges at a coordinate. */
 function addEdge(edges, at, a, b) {
 	const list = edges.get(at);
@@ -1109,22 +1168,29 @@ function runMaxRects(rects, outer, options = {}) {
 							s1 = -contact(f.x0, f.y0, bw, bh);
 							s2 = f.y0 + bh;
 					}
-					const c = {
+					const x = f.x0;
+					const y = f.y0;
+					if (best === void 0 || s1 < best.s1 || s1 === best.s1 && (s2 < best.s2 || s2 === best.s2 && (y < best.y || y === best.y && x < best.x))) best = {
 						index: i,
 						turn: t === 1,
-						x: f.x0,
-						y: f.y0,
+						x,
+						y,
 						w: bw,
 						h: bh,
 						s1,
 						s2
 					};
-					if (best === void 0 || s1 < best.s1 || s1 === best.s1 && (s2 < best.s2 || s2 === best.s2 && (c.y < best.y || c.y === best.y && c.x < best.x))) best = c;
-					const ly = f.y0 + bh;
-					if (low === void 0 || ly < low.s1 || ly === low.s1 && f.x0 < low.s2) low = {
-						...c,
+					if (rule === "bl") continue;
+					const ly = y + bh;
+					if (low === void 0 || ly < low.s1 || ly === low.s1 && x < low.s2) low = {
+						index: i,
+						turn: t === 1,
+						x,
+						y,
+						w: bw,
+						h: bh,
 						s1: ly,
-						s2: f.x0
+						s2: x
 					};
 				}
 			}
@@ -3575,6 +3641,346 @@ function toRects(output, rects, outer) {
 	}
 	return outer;
 }
+// src/check.ts
+/** This function tells if the insides of two boxes overlap by more than a tolerance on each axis. */
+function overlap(a, b, tolerance) {
+	return Math.min(a.r, b.r) - Math.max(a.l, b.l) > tolerance && Math.min(a.b, b.b) - Math.max(a.t, b.t) > tolerance;
+}
+/** This function gives the box made smaller by a tolerance on each side, as a rectangle. */
+function inner(box, tolerance) {
+	return {
+		x: box.l + tolerance,
+		y: box.t + tolerance,
+		w: box.r - box.l - 2 * tolerance,
+		h: box.b - box.t - 2 * tolerance
+	};
+}
+/**
+* This function counts the breaks of the 4 hard rules of the packer for an output.
+*
+* - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
+* - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
+*   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
+* - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no placement.
+* - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
+*
+* A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
+* `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
+*
+* The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
+* The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
+* shape is relative to the position of the item. The result has no tolerance in it.
+*
+* With `options.exactContainer`, a shaped container with the size `fixed` also uses its true outline for `in-container`.
+* A box then counts when `rectInRegion` of the contract tells that it is not in the shape, as in `packHard`.
+* For that test, the box grows by the inset and becomes smaller by `tolerance.overlap` on each side. The default is `false`.
+*/
+function checkHard(input, output, tolerance = DEFAULT_TOLERANCE, options = {}) {
+	const tol = tolerance.overlap;
+	const placements = /* @__PURE__ */ new Map();
+	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
+	const overflow = new Set(output.overflow);
+	let lockedKept = 0;
+	let complete = 0;
+	const boxes = [];
+	for (const item of input.items) {
+		if (item.locked === true && (item.x === void 0 || item.y === void 0)) continue;
+		const lockedAt = item.locked === true ? {
+			x: item.x,
+			y: item.y
+		} : void 0;
+		let p = placements.get(item.id);
+		if (p === void 0) {
+			if (lockedAt === void 0) {
+				if (!overflow.has(item.id)) complete += 1;
+				continue;
+			}
+			lockedKept += 1;
+			p = lockedAt;
+		} else if (lockedAt !== void 0) {
+			if (Math.abs(p.x - lockedAt.x) > RECORD_EPS || Math.abs(p.y - lockedAt.y) > RECORD_EPS) lockedKept += 1;
+		}
+		const placed = p.turn === 90 ? turnItem(item) : item;
+		const m = marginOf(placed);
+		const area = placed.shape === void 0 ? {
+			x: 0,
+			y: 0,
+			w: placed.w,
+			h: placed.h
+		} : boundsOf(placed.shape);
+		const l = p.x + area.x;
+		const t = p.y + area.y;
+		boxes.push({
+			l: l - m.left,
+			t: t - m.top,
+			r: l + area.w + m.right,
+			b: t + area.h + m.bottom
+		});
+	}
+	const moved = new Map(output.moved.map((m) => [m.id, m]));
+	const obstacles = (input.obstacles ?? []).map((o) => {
+		const at = moved.get(o.id);
+		if (at === void 0) return o.region;
+		const b = boundsOf(o.region);
+		return translate(o.region, at.x - b.x, at.y - b.y);
+	});
+	let overlaps = 0;
+	for (const [i, a] of boxes.entries()) {
+		for (let j = i + 1; j < boxes.length; j++) if (overlap(a, boxes[j], tol)) overlaps += 1;
+		if (obstacles.length === 0) continue;
+		const rect = inner(a, tol);
+		for (const region of obstacles) if (regionHitsRect(region, rect)) overlaps += 1;
+	}
+	const { container } = input;
+	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
+	const x = shape?.x ?? 0;
+	const y = shape?.y ?? 0;
+	const w = shape?.w ?? container.w ?? Infinity;
+	const h = shape?.h ?? container.h ?? Infinity;
+	const inset = container.inset ?? 0;
+	const fixedW = container.fixed === "size" || container.fixed === "width";
+	const fixedH = container.fixed === "size" || container.fixed === "height";
+	const exact = options.exactContainer === true && container.fixed === "size" ? container.shape : void 0;
+	let outside = 0;
+	for (const box of boxes) {
+		const outX = fixedW && (box.l < x + inset - tol || box.r > x + w - inset + tol);
+		const outY = fixedH && (box.t < y + inset - tol || box.b > y + h - inset + tol);
+		if (outX || outY) outside += 1;
+		else if (exact !== void 0 && !rectInRegion(exact, inner({
+			l: box.l - inset,
+			t: box.t - inset,
+			r: box.r + inset,
+			b: box.b + inset
+		}, tol))) outside += 1;
+	}
+	return {
+		"no-overlap": overlaps,
+		"in-container": outside,
+		"locked-kept": lockedKept,
+		complete
+	};
+}
+// src/select-key.ts
+/** This function gives the count of the hard breaks of an output: the sum of `checkHard` with `exactContainer`. */
+function hardBreaks(input, output) {
+	return Object.values(checkHard(input, output, void 0, { exactContainer: true })).reduce((sum, n) => sum + n, 0);
+}
+/** This function gives the level of a measure id with its spec of `MEASURE_SPECS`. It throws a `RangeError` for an unknown id. */
+function measureLevel(id) {
+	const spec = MEASURE_SPECS[id];
+	if (spec === void 0 || id === "hard") throw new RangeError(`A level of a key is a measure of MEASURE_SPECS, not "${id}".`);
+	return {
+		id,
+		spec
+	};
+}
+/**
+* This function makes the key of a pick: `hardBreaks`, then the measures of `levels` in order, then `outputHash`.
+*
+* - The levels read the measures after `roundMeasures`, as a record keeps them. A replay of the records gives the same pick.
+* - The measures of one output are computed one time.
+* - `view` gives the input of the measures. The default is the input. The hard breaks always read the input.
+*/
+function measureKey(levels, view = (input) => input) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const measured = (input, output) => {
+		let m = cache.get(output);
+		if (m === void 0) {
+			m = roundMeasures(measure(view(input), output));
+			cache.set(output, m);
+		}
+		return m;
+	};
+	return {
+		hard: hardBreaks,
+		levels: levels.map((level) => ({
+			id: level.id,
+			spec: level.spec,
+			value: (input, output) => measured(input, output)[level.id]
+		})),
+		hash: outputHash
+	};
+}
+// src/aspect-fit.ts
+/** The id of the trace stage of `aspectFit`. Its measure `move.aspectPick` is 1 when the pick is not the output of the wrapped strategy. */
+const ASPECT_FIT_STAGE = "aspect-fit";
+/**
+* The factors of the widths of `aspectFit`. Each width is a factor times the square root of the area of the first output
+* times the target aspect. The steps are approximately 5% of the width, thus approximately 0.1 of the aspect error.
+*/
+const ASPECT_FIT_FACTORS = Object.freeze([
+	.86,
+	.9,
+	.95,
+	1,
+	1.05,
+	1.1,
+	1.16
+]);
+/**
+* The levels of the pick of `aspectFit`, in order. Level 0 is `hard`.
+*
+* - `hard`: the count of hard breaks of `checkHard` with `exactContainer`. Lower is better, with the minimum effect 0.
+* - `pack.overflow.excessArea`: the overflow area above its bound. Lower is better.
+* - `pack.aspectError`: the distance from the target aspect. Lower is better, with the minimum effect 0.01.
+* - `pack.area`: the area of the hull. Lower is better, with the minimum effect of 1% of the area.
+*/
+const ASPECT_FIT_LEVELS = Object.freeze([
+	{
+		id: "hard",
+		spec: {
+			direction: "lower",
+			minEffect: 0
+		}
+	},
+	{
+		id: "pack.overflow.excessArea",
+		spec: MEASURE_SPECS["pack.overflow.excessArea"]
+	},
+	{
+		id: "pack.aspectError",
+		spec: MEASURE_SPECS["pack.aspectError"]
+	},
+	{
+		id: "pack.area",
+		spec: MEASURE_SPECS["pack.area"]
+	}
+]);
+/** This function gives a shape with the origin of `shape` and the width `w`. A shape that is not a rectangle keeps the holes of its polygon. */
+function stripOf(shape, w) {
+	const b = boundsOf$1(shape);
+	if (shape.kind === "rect") return {
+		kind: "rect",
+		x: b.x,
+		y: b.y,
+		w,
+		h: b.h
+	};
+	const points = [
+		[b.x, b.y],
+		[b.x + w, b.y],
+		[b.x + w, b.y + b.h],
+		[b.x, b.y + b.h]
+	];
+	return shape.kind === "polygon" && shape.holes !== void 0 ? {
+		kind: "polygon",
+		points,
+		holes: shape.holes
+	} : {
+		kind: "polygon",
+		points
+	};
+}
+/** This function gives an input with the fixed width `w` and a free height. A shape becomes a strip of the width `w`. */
+function atWidth(input, w) {
+	const c = input.container;
+	return {
+		...input,
+		container: {
+			...c,
+			fixed: "width",
+			w,
+			...c.shape === void 0 ? {} : { shape: stripOf(c.shape, w) }
+		}
+	};
+}
+/** This function gives the widths of `aspectFit` for an input and the first output. Each width is narrower than a fixed width. */
+function widthsOf(input, first, target) {
+	const area = measure(input, first)["pack.area"];
+	if (!(area > 0)) return [];
+	const inset = input.container.inset ?? 0;
+	const fixed = input.container.fixed === "width" ? containerBounds(input).w : Infinity;
+	let widest = 0;
+	for (const item of input.items) {
+		const m = marginOf(item);
+		widest = Math.max(widest, item.w + m.left + m.right);
+	}
+	const ideal = Math.sqrt(area * target);
+	const out = [];
+	for (const f of ASPECT_FIT_FACTORS) {
+		const w = Math.max(Math.round(f * ideal + 2 * inset), Math.ceil(widest + 2 * inset));
+		if (w < fixed && !out.includes(w)) out.push(w);
+	}
+	return out;
+}
+/** This function packs an input with a free height or a free size near the target aspect. */
+function fit(input, target, inner, options, context) {
+	const fresh = () => createContext(context.seed, {
+		...context.budget === void 0 ? {} : { budget: context.budget },
+		...context.previous === void 0 ? {} : { previous: context.previous }
+	});
+	const first = inner.pack(input, options, fresh());
+	const widths = widthsOf(input, first, target);
+	if (widths.length === 0) return first;
+	const origin = containerBounds(input);
+	const inset = input.container.inset ?? 0;
+	const free = input.container.fixed === "none";
+	const sized = (out) => {
+		const w = free ? extentOf(input, out.placements, out.moved, origin, inset, turnItem).right : origin.w;
+		return {
+			...out,
+			size: {
+				w,
+				h: out.size.h
+			}
+		};
+	};
+	const members = [{
+		id: inner.id,
+		run: () => first
+	}, ...widths.map((w) => ({
+		id: `${inner.id}@${w}`,
+		run: (x) => sized(inner.pack(atWidth(x, w), options, fresh()))
+	}))];
+	const view = (x) => x.container.aspect === target ? x : {
+		...x,
+		container: {
+			...x.container,
+			aspect: target
+		}
+	};
+	const got = portfolio(ASPECT_FIT_STAGE, members, measureKey(ASPECT_FIT_LEVELS.slice(1), view)).pick(input);
+	const stage = {
+		id: ASPECT_FIT_STAGE,
+		measures: { "move.aspectPick": pickMoves(got.trace).pick }
+	};
+	return {
+		...got.output,
+		trace: [...got.output.trace ?? [], stage]
+	};
+}
+/**
+* This function wraps a strategy. For a free-size container, it packs at some widths near the target aspect and keeps the best output.
+*
+* - The target is `targetAspect`, else `aspect` of the container, else 1.
+* - A container with the size `fixed` goes to the wrapped strategy without a change.
+* - The first member is the output of the wrapped strategy. Each other member packs at one fixed width of `ASPECT_FIT_FACTORS`.
+* - The key is `ASPECT_FIT_LEVELS`, then `outputHash`. The aspect error reads the target. `selectBest` of the contract picks the winner.
+* - A fixed height goes through the turn of the axes, with the target `1 / target`.
+* - The function throws a `RangeError` for a target that is not a number above 0.
+*/
+function aspectFit(inner, options = {}) {
+	const given = options.targetAspect;
+	if (given !== void 0 && !(Number.isFinite(given) && given > 0)) throw new RangeError(`The target aspect of aspectFit is a number above 0, not ${String(given)}.`);
+	return {
+		id: `aspect-fit(${inner.id})`,
+		family: inner.family,
+		catalog: [],
+		supports: inner.supports,
+		defaults: inner.defaults,
+		deterministic: inner.deterministic,
+		pack(input, o, context) {
+			const c = input.container;
+			if (c.fixed === "size") return inner.pack(input, o, context);
+			const target = given ?? c.aspect ?? 1;
+			if (c.fixed === "height") return viaAxes(input, context.previous, (turned, previous) => fit(turned, 1 / target, inner, o, {
+				...context,
+				...previous === void 0 ? {} : { previous }
+			}));
+			return fit(input, target, inner, o, context);
+		}
+	};
+}
 // src/portfolio-sets.ts
 /** The table of the per-cell portfolio: the sets of 1, 2 and 3 members of each cell, with their training scores. The run 40652567756 gives it. */
 const PORTFOLIO_SETS = {
@@ -5796,125 +6202,6 @@ function portfolioDefaultMembers(input, k, table = PORTFOLIO_SETS) {
 	const count = portfolioSetOf(input, table).sets.defaultMembers ?? 3;
 	return k === void 0 ? count : Math.min(count, k);
 }
-// src/check.ts
-/** This function tells if the insides of two boxes overlap by more than a tolerance on each axis. */
-function overlap(a, b, tolerance) {
-	return Math.min(a.r, b.r) - Math.max(a.l, b.l) > tolerance && Math.min(a.b, b.b) - Math.max(a.t, b.t) > tolerance;
-}
-/** This function gives the box made smaller by a tolerance on each side, as a rectangle. */
-function inner(box, tolerance) {
-	return {
-		x: box.l + tolerance,
-		y: box.t + tolerance,
-		w: box.r - box.l - 2 * tolerance,
-		h: box.b - box.t - 2 * tolerance
-	};
-}
-/**
-* This function counts the breaks of the 4 hard rules of the packer for an output.
-*
-* - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
-* - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
-*   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
-* - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no placement.
-* - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
-*
-* A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
-* `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
-*
-* The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
-* The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
-* shape is relative to the position of the item. The result has no tolerance in it.
-*
-* With `options.exactContainer`, a shaped container with the size `fixed` also uses its true outline for `in-container`.
-* A box then counts when `rectInRegion` of the contract tells that it is not in the shape, as in `packHard`.
-* For that test, the box grows by the inset and becomes smaller by `tolerance.overlap` on each side. The default is `false`.
-*/
-function checkHard(input, output, tolerance = DEFAULT_TOLERANCE, options = {}) {
-	const tol = tolerance.overlap;
-	const placements = /* @__PURE__ */ new Map();
-	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
-	const overflow = new Set(output.overflow);
-	let lockedKept = 0;
-	let complete = 0;
-	const boxes = [];
-	for (const item of input.items) {
-		if (item.locked === true && (item.x === void 0 || item.y === void 0)) continue;
-		const lockedAt = item.locked === true ? {
-			x: item.x,
-			y: item.y
-		} : void 0;
-		let p = placements.get(item.id);
-		if (p === void 0) {
-			if (lockedAt === void 0) {
-				if (!overflow.has(item.id)) complete += 1;
-				continue;
-			}
-			lockedKept += 1;
-			p = lockedAt;
-		} else if (lockedAt !== void 0) {
-			if (Math.abs(p.x - lockedAt.x) > RECORD_EPS || Math.abs(p.y - lockedAt.y) > RECORD_EPS) lockedKept += 1;
-		}
-		const placed = p.turn === 90 ? turnItem(item) : item;
-		const m = marginOf(placed);
-		const area = placed.shape === void 0 ? {
-			x: 0,
-			y: 0,
-			w: placed.w,
-			h: placed.h
-		} : boundsOf(placed.shape);
-		const l = p.x + area.x;
-		const t = p.y + area.y;
-		boxes.push({
-			l: l - m.left,
-			t: t - m.top,
-			r: l + area.w + m.right,
-			b: t + area.h + m.bottom
-		});
-	}
-	const moved = new Map(output.moved.map((m) => [m.id, m]));
-	const obstacles = (input.obstacles ?? []).map((o) => {
-		const at = moved.get(o.id);
-		if (at === void 0) return o.region;
-		const b = boundsOf(o.region);
-		return translate(o.region, at.x - b.x, at.y - b.y);
-	});
-	let overlaps = 0;
-	for (const [i, a] of boxes.entries()) {
-		for (let j = i + 1; j < boxes.length; j++) if (overlap(a, boxes[j], tol)) overlaps += 1;
-		if (obstacles.length === 0) continue;
-		const rect = inner(a, tol);
-		for (const region of obstacles) if (regionHitsRect(region, rect)) overlaps += 1;
-	}
-	const { container } = input;
-	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
-	const x = shape?.x ?? 0;
-	const y = shape?.y ?? 0;
-	const w = shape?.w ?? container.w ?? Infinity;
-	const h = shape?.h ?? container.h ?? Infinity;
-	const inset = container.inset ?? 0;
-	const fixedW = container.fixed === "size" || container.fixed === "width";
-	const fixedH = container.fixed === "size" || container.fixed === "height";
-	const exact = options.exactContainer === true && container.fixed === "size" ? container.shape : void 0;
-	let outside = 0;
-	for (const box of boxes) {
-		const outX = fixedW && (box.l < x + inset - tol || box.r > x + w - inset + tol);
-		const outY = fixedH && (box.t < y + inset - tol || box.b > y + h - inset + tol);
-		if (outX || outY) outside += 1;
-		else if (exact !== void 0 && !rectInRegion(exact, inner({
-			l: box.l - inset,
-			t: box.t - inset,
-			r: box.r + inset,
-			b: box.b + inset
-		}, tol))) outside += 1;
-	}
-	return {
-		"no-overlap": overlaps,
-		"in-container": outside,
-		"locked-kept": lockedKept,
-		complete
-	};
-}
 // src/portfolio.ts
 /** The id of the trace stage of `packPortfolio`. Its measure `move.pick` is 1 when the pick is not member 0. */
 const PORTFOLIO_STAGE = "portfolio";
@@ -5942,10 +6229,6 @@ const PORTFOLIO_LEVELS = Object.freeze([
 		spec: MEASURE_SPECS["pack.fill"]
 	}
 ]);
-/** This function gives the count of the hard breaks of an output: the sum of `checkHard` with `exactContainer`. */
-function hardBreaks(input, output) {
-	return Object.values(checkHard(input, output, void 0, { exactContainer: true })).reduce((sum, n) => sum + n, 0);
-}
 /**
 * This function makes an opt-in portfolio of strategies of the registry with `portfolio` of the contract.
 * Its `pick(input)` packs the input with each member and gives the output of the winner, its id and the trace.
@@ -5953,10 +6236,11 @@ function hardBreaks(input, output) {
 * - A member is a strategy id, or a `PortfolioEntry` with options. The members run in the given order.
 * - `members` is a list, or a function of the input that gives the list. The strategy `portfolio` uses the function form.
 * - The key is the hard breaks, then `pack.overflow.excessArea`, then `pack.fill`. `PORTFOLIO_LEVELS` gives the specs.
+*   The option `key` gives other measures after the hard breaks.
 * - The key reads the measures after `roundMeasures`, as a record keeps them. A replay of the records gives the same pick.
 * - The hash of the key is `outputHash`. `selectBest` of the contract picks the winner.
 * - The output of the winner gets the trace stage `portfolio` with `move.pick` of `pickMoves`.
-* - The function throws a `RangeError` for an unknown strategy, an empty list and two members with the same id.
+* - The function throws a `RangeError` for an unknown strategy, an empty list, two members with the same id and an unknown measure of `key`.
 *   With the function form, `pick` throws this error for the list of an input.
 */
 function packPortfolio(members, options = {}) {
@@ -5973,24 +6257,7 @@ function packPortfolio(members, options = {}) {
 		};
 	});
 	const list = typeof members === "function" ? (input) => toMembers(members(input)) : toMembers(members);
-	const cache = /* @__PURE__ */ new WeakMap();
-	const measured = (input, output) => {
-		let m = cache.get(output);
-		if (m === void 0) {
-			m = roundMeasures(measure(input, output));
-			cache.set(output, m);
-		}
-		return m;
-	};
-	const key = {
-		hard: hardBreaks,
-		levels: PORTFOLIO_LEVELS.slice(1).map((level) => ({
-			id: level.id,
-			spec: level.spec,
-			value: (input, output) => measured(input, output)[level.id]
-		})),
-		hash: outputHash
-	};
+	const key = measureKey(options.key === void 0 ? PORTFOLIO_LEVELS.slice(1) : options.key.map(measureLevel));
 	const limits = {
 		...options.budgetMs !== void 0 ? { budgetMs: options.budgetMs } : {},
 		...options.maxMembers !== void 0 ? { maxMembers: options.maxMembers } : {},
@@ -6044,7 +6311,8 @@ function unionSupports() {
 *   The default output thus does not depend on the clock.
 * - A member that does not support the cell of an input throws, and it does not win. When each member throws, the strategy throws the first error.
 * - The option `budgetMs` goes to `portfolio` of the contract. The first member always runs.
-* - The strategy throws a `RangeError` for a `k` other than 2 or 3.
+* - With `members`, each input gets these members, and `maxMembers` has no default. The id of the portfolio stays `portfolio`.
+* - The strategy throws a `RangeError` for a `k` other than 2 or 3, and for `k` with `members`.
 */
 const portfolioStrategy = {
 	id: "portfolio",
@@ -6054,15 +6322,17 @@ const portfolioStrategy = {
 	defaults: {},
 	deterministic: true,
 	pack(input, options, context) {
-		const { k, maxMembers, budgetMs } = options;
+		const { k, maxMembers, budgetMs, members, key } = options;
 		if (k !== void 0 && k !== 2 && k !== 3) throw new RangeError(`The option k of the strategy portfolio is 2 or 3, not ${String(k)}.`);
+		if (k !== void 0 && members !== void 0) throw new RangeError("The strategy portfolio takes the option k or the option members, not the two.");
 		const size = k ?? 3;
-		const count = maxMembers ?? (k === void 0 ? portfolioDefaultMembers(input) : void 0);
+		const count = maxMembers ?? (k === void 0 && members === void 0 ? portfolioDefaultMembers(input) : void 0);
 		const limits = {
 			...count === void 0 ? {} : { maxMembers: count },
-			...budgetMs === void 0 ? {} : { budgetMs }
+			...budgetMs === void 0 ? {} : { budgetMs },
+			...key === void 0 ? {} : { key }
 		};
-		return packPortfolio((x) => portfolioMembers(x, size), {
+		return packPortfolio(members ?? ((x) => portfolioMembers(x, size)), {
 			id: k === void 0 ? "portfolio" : `portfolio-k${k}`,
 			seed: context.seed,
 			...limits
@@ -6078,11 +6348,42 @@ const strategies = Object.freeze([
 	push,
 	maxrects
 ]);
+/** This function gives the union of the supports of some strategies. */
+function unionOf(list) {
+	const out = {};
+	for (const s of list) for (const [dim, values] of Object.entries(s.supports)) {
+		const own = out[dim] ??= [];
+		for (const v of values) if (!own.includes(v)) own.push(v);
+	}
+	return out;
+}
+/**
+* The strategy `aspect-fit`: `aspectFit` of roadmap item k62 around the strategy of the option `strategy`. Its supports are
+* the union of the supports of the single strategies. A cell that the wrapped strategy does not support throws its error.
+* The strategy throws a `RangeError` without the option `strategy`.
+*/
+const aspectFitStrategy = {
+	id: "aspect-fit",
+	family: "aspect-fit",
+	catalog: [],
+	supports: unionOf(strategies),
+	defaults: {},
+	deterministic: true,
+	pack(input, options, context) {
+		if (options.strategy === void 0) throw new RangeError("The strategy aspect-fit needs the option strategy.");
+		const inner = strategy(options.strategy);
+		const merged = {
+			...inner.defaults,
+			...options.options
+		};
+		return aspectFit(inner, options.targetAspect === void 0 ? {} : { targetAspect: options.targetAspect }).pack(input, merged, context);
+	}
+};
 /**
 * The composite strategies of the registry: each one packs an input with other strategies. They are not in `strategies`.
-* Since 0.2.7, the list has `portfolio` of roadmap item k20.
+* Since 0.2.7, the list has `portfolio` of roadmap item k20. Roadmap item k62 adds `aspect-fit`.
 */
-const composites = Object.freeze([portfolioStrategy]);
+const composites = Object.freeze([portfolioStrategy, aspectFitStrategy]);
 /** This function gives the strategy with an id, also a composite strategy. It throws a `RangeError` for an id that the registry does not have. */
 function strategy(id) {
 	const found = strategies.find((s) => s.id === id) ?? composites.find((s) => s.id === id);
@@ -6669,19 +6970,67 @@ const rectGrid = defineGenerator({
 	},
 	family: (p) => `rect-grid.${p.containerSize}.${p.containerShape}.${p.obstacles}.${p.sizes}.n${p.count}`,
 	cell: (p) => cellWith(p.containerSize, p.containerShape, p.obstacles, p.sizes, p.count),
+	build: gridOf
+});
+/** This function builds an input of `rect-grid`: the container, then the obstacles, then the boxes. */
+function gridOf(seed, p) {
+	let r = stepRandom(seed, "container");
+	const w = int(r, 600, 1e3);
+	const h = int(r, 400, 800);
+	const { region, frame } = shapeOf(r, p.containerShape, w, h);
+	const container = containerOf(p.containerSize, w, h, region);
+	r = stepRandom(seed, "obstacles");
+	const obstacles = obstaclesOf(r, p.obstacles, frame);
+	r = stepRandom(seed, "boxes");
+	return {
+		container,
+		obstacles,
+		boxes: boxesOf(r, p.sizes, p.count, frame)
+	};
+}
+/**
+* The generator `rect-grid`, version 2: the inputs of version 1 with the parameter `order`. With `soft`, each box gets a
+* rank, a random permutation of the box indexes. With `free`, the boxes have no rank.
+*/
+const rectGridV2 = defineGenerator({
+	name: "rect-grid",
+	version: 2,
+	set: "corpus-v1",
+	defaults: {
+		containerSize: "fixed",
+		containerShape: "rect",
+		obstacles: "none",
+		sizes: "uniform",
+		order: "free",
+		count: 100
+	},
+	values: {
+		containerSize: CONTAINER_SIZES,
+		containerShape: CONTAINER_SHAPES,
+		obstacles: OBSTACLE_LAYOUTS,
+		sizes: SIZE_DISTRIBUTIONS,
+		order: ["free", "soft"]
+	},
+	family: (p) => `rect-grid.${p.containerSize}.${p.containerShape}.${p.obstacles}.${p.sizes}.${p.order}.n${p.count}`,
+	cell: (p) => ({
+		...cellWith(p.containerSize, p.containerShape, p.obstacles, p.sizes, p.count),
+		order: p.order
+	}),
 	build(seed, p) {
-		let r = stepRandom(seed, "container");
-		const w = int(r, 600, 1e3);
-		const h = int(r, 400, 800);
-		const { region, frame } = shapeOf(r, p.containerShape, w, h);
-		const container = containerOf(p.containerSize, w, h, region);
-		r = stepRandom(seed, "obstacles");
-		const obstacles = obstaclesOf(r, p.obstacles, frame);
-		r = stepRandom(seed, "boxes");
+		const built = gridOf(seed, p);
+		if (p.order === "free") return built;
+		const r = stepRandom(seed, "order");
+		const ranks = built.boxes.map((_, i) => i);
+		for (let i = ranks.length - 1; i > 0; i--) {
+			const j = Math.floor(r() * (i + 1));
+			[ranks[i], ranks[j]] = [ranks[j], ranks[i]];
+		}
 		return {
-			container,
-			obstacles,
-			boxes: boxesOf(r, p.sizes, p.count, frame)
+			...built,
+			boxes: built.boxes.map((b, i) => ({
+				...b,
+				rank: ranks[i]
+			}))
 		};
 	}
 });
@@ -6961,16 +7310,23 @@ const edgeCases = defineGenerator({
 const generators = Object.freeze([
 	rectScattered,
 	rectGrid,
+	rectGridV2,
 	gallery,
 	dashboard,
 	cards,
 	wordCloud,
 	edgeCases
 ]);
-/** This function gives the generator with a name. It throws a `RangeError` for a name that the package does not have. */
-function generator(name) {
-	const found = generators.find((g) => g.name === name);
-	if (found === void 0) throw new RangeError(`The package has no generator "${name}".`);
+/**
+* This function gives the generator with a name and a version. Without a version, it gives the first generator of the name
+* in `generators`: version 1 of `rect-grid`. It throws a `RangeError` for a name or a version that the package does not have.
+*/
+function generator(name, version) {
+	const named = generators.filter((g) => g.name === name);
+	if (named.length === 0) throw new RangeError(`The package has no generator "${name}".`);
+	if (version === void 0) return named[0];
+	const found = named.find((g) => g.version === version);
+	if (found === void 0) throw new RangeError(`The generator "${name}" has the versions ${named.map((g) => g.version).join(", ")}, not ${version}.`);
 	return found;
 }
 // src/corpus.ts
@@ -6988,8 +7344,7 @@ function corpus(name, specs) {
 	const inputs = [];
 	const ids = /* @__PURE__ */ new Set();
 	for (const spec of specs) {
-		const gen = generator(spec.generator);
-		if (spec.version !== void 0 && spec.version !== gen.version) throw new RangeError(`The generator "${gen.name}" has the version ${gen.version}, not ${spec.version}.`);
+		const gen = generator(spec.generator, spec.version);
 		const params = gen.withDefaults(spec.params);
 		const cell = gen.cell(params);
 		manifest.specs.push({
@@ -7015,6 +7370,6 @@ function corpus(name, specs) {
 		inputs
 	};
 }
-export { DEFAULT_TOLERANCE, EPS, MAXRECTS_BANDS, MAXRECTS_RULES, MEASURE_SPECS, PORTFOLIO_FRAME_MS, PORTFOLIO_LEVELS, PORTFOLIO_SETS, PORTFOLIO_STAGE, RECORD_EPS, Rect, SHELF_FITS, SORT_ORDERS, SPREAD_THRESHOLDS, THIN_INPUTS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellKey, cellOf, checkHard, checkInput, compareRects, composites, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, freeSpace, fromRects, gallery, generator, generators, hardBreaks, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, maxrects, measure, measureChange, medianRatio, mulberry32, outputHash, pack, packFree, packMaxRects, packPortfolio, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, portfolioCell, portfolioDefaultMembers, portfolioMembers, portfolioSetOf, portfolioStrategy, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, spreadBand, spreadOf, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
+export { ASPECT_FIT_FACTORS, ASPECT_FIT_LEVELS, ASPECT_FIT_STAGE, DEFAULT_TOLERANCE, EPS, MAXRECTS_BANDS, MAXRECTS_RULES, MEASURE_SPECS, PORTFOLIO_FRAME_MS, PORTFOLIO_LEVELS, PORTFOLIO_SETS, PORTFOLIO_STAGE, RECORD_EPS, Rect, SHELF_FITS, SORT_ORDERS, SPREAD_THRESHOLDS, THIN_INPUTS, UnsupportedCell, Vector, aspectError, aspectFit, aspectFitStrategy, assertSupported, canonicalJson, cards, cellKey, cellOf, checkHard, checkInput, compareRects, composites, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, freeSpace, fromRects, gallery, generator, generators, hardBreaks, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, maxrects, measure, measureChange, medianRatio, mulberry32, outputHash, pack, packFree, packMaxRects, packPortfolio, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, portfolioCell, portfolioDefaultMembers, portfolioMembers, portfolioSetOf, portfolioStrategy, push, pushCascade, quantile, rectGrid, rectGridV2, rectScattered, round3, roundMeasures, rows, shelf, skyline, spreadBand, spreadOf, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
 
 //# sourceMappingURL=index.js.map