@mark1russell7/packing 0.1.6 → 0.2.0

package/build/index.js

@@ -1,3 +1,4 @@
+import { DEFAULT_TOLERANCE, EPS, RECORD_EPS, boundsOf, boundsOf as boundsOf$1, checkInput, marginSides, regionHitsRect, translate, turnBox, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
 // src/vector.ts
 /** A mutable two-dimensional vector. */
 var Vector = class Vector {
@@ -599,24 +600,9 @@ function pushCascade(placed, rects, options = {}) {
 	return [...moved];
 }
 // src/contract.ts
-/** The tolerance for the comparison of two numbers in an engine. */
-const EPS = 1e-6;
-/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
-const RECORD_EPS = .001;
-/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
-const DEFAULT_TOLERANCE = Object.freeze({
-	overlap: .001,
-	through: .5
-});
 /** This function gives the margin of an item on each side. A number is the same margin on each side. */
 function marginOf(item) {
-	const m = item.margin ?? 0;
-	if (typeof m === "number") return {
-		top: m,
-		right: m,
-		bottom: m,
-		left: m
-	};
+	const m = marginSides(item.margin);
 	return {
 		top: m.top,
 		right: m.right,
@@ -624,94 +610,14 @@ function marginOf(item) {
 		left: m.left
 	};
 }
-/** The side of a port after a turn of 90 degrees clockwise. */
-const TURNED_SIDE = {
-	top: "right",
-	right: "bottom",
-	bottom: "left",
-	left: "top"
-};
-/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
-function turnPoint(px, py, h) {
-	return [h - py, px];
-}
-/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
-function turnPort(port, h) {
-	const turned = {
-		id: port.id,
-		side: TURNED_SIDE[port.side]
-	};
-	if (port.x !== void 0 && port.y !== void 0) {
-		const [x, y] = turnPoint(port.x, port.y, h);
-		turned.x = x;
-		turned.y = y;
-	} else if (port.x !== void 0) turned.y = port.x;
-	else if (port.y !== void 0) turned.x = h - port.y;
-	return turned;
-}
-/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
-function turnRegion(region, h) {
-	switch (region.kind) {
-		case "rect": return {
-			kind: "rect",
-			x: h - region.y - region.h,
-			y: region.x,
-			w: region.h,
-			h: region.w
-		};
-		case "circle": {
-			const [cx, cy] = turnPoint(region.cx, region.cy, h);
-			return {
-				kind: "circle",
-				cx,
-				cy,
-				r: region.r
-			};
-		}
-		case "ellipse": {
-			const [cx, cy] = turnPoint(region.cx, region.cy, h);
-			return {
-				kind: "ellipse",
-				cx,
-				cy,
-				rx: region.ry,
-				ry: region.rx
-			};
-		}
-		case "polygon": {
-			const turnRing = (ring) => ring.map(([x, y]) => turnPoint(x, y, h));
-			const turned = {
-				kind: "polygon",
-				points: turnRing(region.points)
-			};
-			if (region.holes) turned.holes = region.holes.map(turnRing);
-			return turned;
-		}
-	}
-}
 /**
 * This function gives an item after a turn of 90 degrees clockwise, with the y axis down (decision 1 of
 * `docs/PACKER.md`). The width and the height change places. The top-left corner, the id and the other fields stay.
 * The ports, the shape and the margin turn with the item. The function does not change its argument.
+* It is `turnBox` of the contract.
 */
 function turnItem(item) {
-	const turned = {
-		...item,
-		w: item.h,
-		h: item.w
-	};
-	if (item.ports) turned.ports = item.ports.map((p) => turnPort(p, item.h));
-	if (item.shape) turned.shape = turnRegion(item.shape, item.h);
-	if (item.margin !== void 0 && typeof item.margin !== "number") {
-		const m = item.margin;
-		turned.margin = {
-			top: m.left,
-			right: m.top,
-			bottom: m.right,
-			left: m.bottom
-		};
-	}
-	return turned;
+	return turnBox(item);
 }
 // src/sha256.ts
 /** The round constants of SHA-256. */
@@ -888,8 +794,7 @@ function canonicalJson(value) {
 }
 /** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
 function hashInput(file) {
-	const rest = { ...file };
-	delete rest.hash;
+	const { hash: _hash, ...rest } = file;
 	return sha256Hex(canonicalJson(rest)).slice(0, 16);
 }
 /** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
@@ -900,39 +805,63 @@ function countCell(count) {
 	if (count <= 3162) return "1k";
 	return "10k";
 }
-/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
+/**
+* This function gives the packing input of a file. The boxes become the items, and the edges go.
+* A file without a container gets `{ fixed: "none" }`, so the packer picks the size. It is `toPackInput` of the contract.
+*/
 function toPackInput(file) {
-	const input = {
-		container: file.container,
-		items: file.boxes
+	return {
+		container: file.container ?? { fixed: "none" },
+		items: file.boxes,
+		...file.obstacles === void 0 ? {} : { obstacles: file.obstacles },
+		...file.gap === void 0 ? {} : { gap: file.gap }
 	};
-	if (file.obstacles !== void 0) input.obstacles = file.obstacles;
-	if (file.gap !== void 0) input.gap = file.gap;
-	return input;
 }
 // src/measures.ts
-const spec = (id, family, unit, direction, min, max) => ({
+const spec = (id, family, unit, direction, min, max, guard) => ({
 	id,
 	family,
 	unit,
 	direction,
 	min,
-	max
+	max,
+	...guard
 });
-/** The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. */
+/**
+* The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. This record is the source of the floor
+* and the tolerance of each guard of the packer.
+*/
 const MEASURE_SPECS = Object.freeze({
 	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity),
 	"pack.fill": spec("pack.fill", "density", "share", "higher", 0, 1),
 	"pack.whitespace": spec("pack.whitespace", "density", "share", "lower", 0, 1),
 	"pack.aspect": spec("pack.aspect", "aspect", "ratio", "lower", 1, Infinity),
-	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity),
-	"pack.order.inversions": spec("pack.order.inversions", "order", "share", "lower", 0, 1),
+	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity, {
+		floor: 0,
+		tol: .01
+	}),
+	"pack.order.inversions": spec("pack.order.inversions", "order", "share", "lower", 0, 1, {
+		floor: 0,
+		tol: 0
+	}),
 	"pack.order.breaks": spec("pack.order.breaks", "order", "count", "lower", 0, Infinity),
 	"pack.raggedness": spec("pack.raggedness", "raggedness", "share", "lower", 0, 1),
-	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity),
-	"pack.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1),
-	"pack.stability.mean": spec("pack.stability.mean", "stability", "container widths", "lower", 0, Infinity),
-	"pack.stability.q95": spec("pack.stability.q95", "stability", "container widths", "lower", 0, Infinity),
+	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity, {
+		floor: 0,
+		tol: 0
+	}),
+	"pack.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1, {
+		floor: 0,
+		tol: .02
+	}),
+	"pack.stability.mean": spec("pack.stability.mean", "stability", "container widths", "lower", 0, Infinity, {
+		floor: 0,
+		tol: .005
+	}),
+	"pack.stability.q95": spec("pack.stability.q95", "stability", "container widths", "lower", 0, Infinity, {
+		floor: 0,
+		tol: .01
+	}),
 	"pack.deterministic": spec("pack.deterministic", "determinism", "boolean", "higher", 0, 1),
 	"pack.search.widths": spec("pack.search.widths", "speed", "count", "lower", 0, Infinity),
 	"pack.search.ms": spec("pack.search.ms", "speed", "milliseconds", "lower", 0, Infinity)
@@ -1008,13 +937,13 @@ function boxesOf$1(input, output) {
 * `RECORD_EPS` are on one line, and the left box comes first. Otherwise the upper box comes first.
 */
 function readsBefore(a, b) {
-	if (Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > .001) return a.x + RECORD_EPS < b.x;
+	if (Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > RECORD_EPS) return a.x + RECORD_EPS < b.x;
 	return a.y < b.y;
 }
 /** This function sums one measure over the stages of a trace. A trace without the measure gives 0. */
 function traceSum(output, id) {
 	let sum = 0;
-	for (const stage of output.trace) sum += stage.measures[id] ?? 0;
+	for (const stage of output.trace ?? []) sum += stage.measures?.[id] ?? 0;
 	return sum;
 }
 /**
@@ -1100,7 +1029,7 @@ function measureChange(baseInput, baseOutput, changeInput, changeOutput) {
 		if (q === void 0) continue;
 		const dx = q.x - p.x;
 		const dy = q.y - p.y;
-		if (Math.abs(dx) > .001 || Math.abs(dy) > .001 || (p.turn ?? 0) !== (q.turn ?? 0)) moved += 1;
+		if (Math.abs(dx) > RECORD_EPS || Math.abs(dy) > RECORD_EPS || (p.turn ?? 0) !== (q.turn ?? 0)) moved += 1;
 		distances.push(Math.hypot(dx, dy) / unit);
 	}
 	if (distances.length === 0) return {
@@ -1383,41 +1312,6 @@ const clock = globalThis.performance;
 function now() {
 	return clock ? clock.now() : Date.now();
 }
-/** This function gives the bounding box of a region. */
-function boundsOf(region) {
-	switch (region.kind) {
-		case "rect": return {
-			x: region.x,
-			y: region.y,
-			w: region.w,
-			h: region.h
-		};
-		case "circle": return {
-			x: region.cx - region.r,
-			y: region.cy - region.r,
-			w: 2 * region.r,
-			h: 2 * region.r
-		};
-		case "ellipse": return {
-			x: region.cx - region.rx,
-			y: region.cy - region.ry,
-			w: 2 * region.rx,
-			h: 2 * region.ry
-		};
-		case "polygon": {
-			const xs = region.points.map((p) => p[0]);
-			const ys = region.points.map((p) => p[1]);
-			const x = Math.min(...xs);
-			const y = Math.min(...ys);
-			return {
-				x,
-				y,
-				w: Math.max(...xs) - x,
-				h: Math.max(...ys) - y
-			};
-		}
-	}
-}
 /** This function gives the rectangle of a container. A rectangle shape gives the origin and the sizes of the fixed sides. */
 function containerBounds(input) {
 	const { container } = input;
@@ -1465,7 +1359,7 @@ function buildFrame(input, movable = false) {
 		if (item.locked === true && item.x !== void 0 && item.y !== void 0) {
 			rect.locked = true;
 			rect.position.set(item.x - dx - ox, item.y - dy - oy);
-		} else if (rect.size.x > w + 1e-6 || rect.size.y > h + 1e-6) {
+		} else if (rect.size.x > w + EPS || rect.size.y > h + EPS) {
 			tooLarge.push(item.id);
 			continue;
 		}
@@ -1594,59 +1488,55 @@ function transposeRegion(region) {
 		};
 		case "polygon": {
 			const swap = (ring) => ring.map(([x, y]) => [y, x]);
-			const turned = {
+			return region.holes === void 0 ? {
 				kind: "polygon",
 				points: swap(region.points)
+			} : {
+				kind: "polygon",
+				points: swap(region.points),
+				holes: region.holes.map(swap)
 			};
-			if (region.holes) turned.holes = region.holes.map(swap);
-			return turned;
 		}
 	}
 }
 /** This function gives an item with the axes changed. The ports go, because the adapters of 0.1 do not read them. */
 function transposeItem(item) {
-	const { ports: _ports, ...rest } = item;
-	const turned = {
+	const { ports: _ports, x, y, shape, margin, ...rest } = item;
+	return {
 		...rest,
 		w: item.h,
-		h: item.w
+		h: item.w,
+		...y === void 0 ? {} : { x: y },
+		...x === void 0 ? {} : { y: x },
+		...shape === void 0 ? {} : { shape: transposeRegion(shape) },
+		...margin === void 0 ? {} : { margin: typeof margin === "number" ? margin : {
+			top: margin.left,
+			right: margin.bottom,
+			bottom: margin.right,
+			left: margin.top
+		} }
 	};
-	delete turned.x;
-	delete turned.y;
-	if (item.y !== void 0) turned.x = item.y;
-	if (item.x !== void 0) turned.y = item.x;
-	if (item.shape) turned.shape = transposeRegion(item.shape);
-	if (item.margin !== void 0 && typeof item.margin !== "number") {
-		const m = item.margin;
-		turned.margin = {
-			top: m.left,
-			right: m.bottom,
-			bottom: m.right,
-			left: m.top
-		};
-	}
-	return turned;
 }
 /** This function gives an input with the axes changed. A fixed height becomes a fixed width. */
 function transposeInput(input) {
 	const c = input.container;
-	const container = { fixed: c.fixed === "height" ? "width" : c.fixed === "width" ? "height" : c.fixed };
-	if (c.h !== void 0) container.w = c.h;
-	if (c.w !== void 0) container.h = c.w;
-	if (c.aspect !== void 0) container.aspect = 1 / c.aspect;
-	if (c.aspectWeight !== void 0) container.aspectWeight = c.aspectWeight;
-	if (c.shape !== void 0) container.shape = transposeRegion(c.shape);
-	if (c.inset !== void 0) container.inset = c.inset;
-	const turned = {
-		container,
-		items: input.items.map(transposeItem)
+	return {
+		container: {
+			fixed: c.fixed === "height" ? "width" : c.fixed === "width" ? "height" : c.fixed,
+			...c.h === void 0 ? {} : { w: c.h },
+			...c.w === void 0 ? {} : { h: c.w },
+			...c.aspect === void 0 ? {} : { aspect: 1 / c.aspect },
+			...c.aspectWeight === void 0 ? {} : { aspectWeight: c.aspectWeight },
+			...c.shape === void 0 ? {} : { shape: transposeRegion(c.shape) },
+			...c.inset === void 0 ? {} : { inset: c.inset }
+		},
+		items: input.items.map(transposeItem),
+		...input.obstacles === void 0 ? {} : { obstacles: input.obstacles.map((o) => ({
+			...o,
+			region: transposeRegion(o.region)
+		})) },
+		...input.gap === void 0 ? {} : { gap: input.gap }
 	};
-	if (input.obstacles) turned.obstacles = input.obstacles.map((o) => ({
-		...o,
-		region: transposeRegion(o.region)
-	}));
-	if (input.gap !== void 0) turned.gap = input.gap;
-	return turned;
 }
 /** This function gives an output with the axes changed. */
 function transposeOutput(output) {
@@ -1666,7 +1556,7 @@ function transposeOutput(output) {
 			x: m.y,
 			y: m.x
 		})),
-		trace: output.trace
+		...output.trace === void 0 ? {} : { trace: output.trace }
 	};
 }
 /**
@@ -1676,13 +1566,14 @@ function transposeOutput(output) {
 function viaAxes(input, previous, run) {
 	const start = now();
 	const inner = run(transposeInput(input), previous === void 0 ? void 0 : transposeOutput(previous));
-	const output = transposeOutput(inner);
-	output.trace = [{
-		id: "axes",
-		ms: now() - start,
-		measures: {}
-	}, ...inner.trace];
-	return output;
+	return {
+		...transposeOutput(inner),
+		trace: [{
+			id: "axes",
+			ms: now() - start,
+			measures: {}
+		}, ...inner.trace ?? []]
+	};
 }
 // src/adapters.ts
 /** The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. */
@@ -1723,12 +1614,14 @@ function packFixedWidth(id, input, options) {
 		sortOrder: options.sortOrder
 	});
 	const output = readFrame(input, frame, []);
-	output.trace.push({
-		id,
-		ms: now() - start,
-		measures: { "pack.overflow": output.overflow.length }
-	});
-	return output;
+	return {
+		...output,
+		trace: [{
+			id,
+			ms: now() - start,
+			measures: { "pack.overflow": output.overflow.length }
+		}]
+	};
 }
 /** This function makes the strategy of one function of `pack`. */
 function layoutStrategy(id, family, catalog, cells) {
@@ -1818,24 +1711,26 @@ const logSweep = {
 		const ms = now() - start;
 		const runs = result.tried.length + 1;
 		const output = readFrame(input, frame, []);
-		output.trace.push({
-			id: "log-sweep",
-			ms,
-			measures: {
-				"pack.search.widths": result.tried.length,
-				"pack.search.ms": ms
-			}
-		}, {
-			id,
-			ms: ms / runs,
-			measures: { "pack.overflow": output.overflow.length }
-		});
-		return output;
+		return {
+			...output,
+			trace: [{
+				id: "log-sweep",
+				ms,
+				measures: {
+					"pack.search.widths": result.tried.length,
+					"pack.search.ms": ms
+				}
+			}, {
+				id,
+				ms: ms / runs,
+				measures: { "pack.overflow": output.overflow.length }
+			}]
+		};
 	}
 };
 /** This function tells if the insides of two rectangles overlap by more than `EPS`. */
 function overlaps(a, b) {
-	return Math.min(a.right(), b.right()) - Math.max(a.position.x, b.position.x) > 1e-6 && Math.min(a.bottom(), b.bottom()) - Math.max(a.position.y, b.position.y) > 1e-6;
+	return Math.min(a.right(), b.right()) - Math.max(a.position.x, b.position.x) > EPS && Math.min(a.bottom(), b.bottom()) - Math.max(a.position.y, b.position.y) > EPS;
 }
 /** This function packs an input with a fixed size or a fixed width with a push cascade. */
 function pushFixedWidth(input, options, previous) {
@@ -1877,9 +1772,9 @@ function pushFixedWidth(input, options, previous) {
 		const startAt = starts.get(e);
 		const x = e.rect.position.x + e.dx + frame.ox;
 		const y = e.rect.position.y + e.dy + frame.oy;
-		const b = boundsOf(e.obstacle.region);
-		if (x < bounds.x - 1e-6 || y < bounds.y - 1e-6 || x + b.w > bounds.x + bounds.w + 1e-6 || y + b.h > bounds.y + bounds.h + 1e-6 || lockedItems.some((l) => overlaps(l.rect, e.rect))) e.rect.position.set(startAt.x, startAt.y);
-		else if (Math.abs(e.rect.position.x - startAt.x) > 1e-6 || Math.abs(e.rect.position.y - startAt.y) > 1e-6) moved.push({
+		const b = boundsOf$1(e.obstacle.region);
+		if (x < bounds.x - EPS || y < bounds.y - EPS || x + b.w > bounds.x + bounds.w + EPS || y + b.h > bounds.y + bounds.h + EPS || lockedItems.some((l) => overlaps(l.rect, e.rect))) e.rect.position.set(startAt.x, startAt.y);
+		else if (Math.abs(e.rect.position.x - startAt.x) > EPS || Math.abs(e.rect.position.y - startAt.y) > EPS) moved.push({
 			id: e.obstacle.id,
 			x,
 			y
@@ -1889,7 +1784,7 @@ function pushFixedWidth(input, options, previous) {
 	const kept = [...obstacles, ...lockedItems].map((e) => e.rect);
 	for (const e of positioned) {
 		const r = e.rect;
-		if (r.position.x >= -1e-6 && r.position.y >= -1e-6 && r.right() <= frame.w + 1e-6 && r.bottom() <= frame.h + 1e-6 && !kept.some((k) => overlaps(k, r))) kept.push(r);
+		if (r.position.x >= -EPS && r.position.y >= -EPS && r.right() <= frame.w + EPS && r.bottom() <= frame.h + EPS && !kept.some((k) => overlaps(k, r))) kept.push(r);
 		else pending.push(e);
 	}
 	const skylineStart = now();
@@ -1905,19 +1800,21 @@ function pushFixedWidth(input, options, previous) {
 		packSkyline([...pending.map((e) => e.rect), ...kept], outerOf(frame), { sortOrder: options.sortOrder });
 	}
 	const output = readFrame(input, frame, [], moved);
-	output.trace.push({
-		id: "push",
-		ms: pushMs,
-		measures: { "pack.push.moved": moved.length }
-	}, {
-		id: "skyline",
-		ms: now() - skylineStart,
-		measures: {
-			"pack.push.replaced": pending.length,
-			"pack.overflow": output.overflow.length
-		}
-	});
-	return output;
+	return {
+		...output,
+		trace: [{
+			id: "push",
+			ms: pushMs,
+			measures: { "pack.push.moved": moved.length }
+		}, {
+			id: "skyline",
+			ms: now() - skylineStart,
+			measures: {
+				"pack.push.replaced": pending.length,
+				"pack.overflow": output.overflow.length
+			}
+		}]
+	};
 }
 /**
 * The strategy `push` uses `pushCascade`. Each item starts at its `x` and `y`, or at its place in `context.previous`.
@@ -1967,31 +1864,29 @@ const push = {
 */
 function fromRects(rects, outer) {
 	const fixed = outer.fixedSize ? "size" : outer.fixedWidth ? "width" : "none";
-	const container = { fixed };
-	if (fixed !== "none") container.w = outer.size.x;
-	if (fixed === "size") container.h = outer.size.y;
-	if (outer.position.x !== 0 || outer.position.y !== 0) container.shape = {
-		kind: "rect",
-		x: outer.position.x,
-		y: outer.position.y,
-		w: outer.size.x,
-		h: outer.size.y
-	};
 	return {
-		container,
-		items: rects.map((r, i) => {
-			const item = {
-				id: String(i),
-				w: r.size.x,
-				h: r.size.y
-			};
-			if (r.locked) {
-				item.locked = true;
-				item.x = r.position.x;
-				item.y = r.position.y;
-			}
-			return item;
-		})
+		container: {
+			fixed,
+			...fixed === "none" ? {} : { w: outer.size.x },
+			...fixed === "size" ? { h: outer.size.y } : {},
+			...outer.position.x !== 0 || outer.position.y !== 0 ? { shape: {
+				kind: "rect",
+				x: outer.position.x,
+				y: outer.position.y,
+				w: outer.size.x,
+				h: outer.size.y
+			} } : {}
+		},
+		items: rects.map((r, i) => ({
+			id: String(i),
+			w: r.size.x,
+			h: r.size.y,
+			...r.locked ? {
+				locked: true,
+				x: r.position.x,
+				y: r.position.y
+			} : {}
+		}))
 	};
 }
 /**
@@ -2046,39 +1941,55 @@ function packWith(id, input, options, seed = 0) {
 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 position.
-* - `complete`: each item with no position that is not in the overflow.
+* - `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 rules read a shape of the container, of an obstacle 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.
+* 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.
 */
 function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	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);
-	const breaks = {
-		"no-overlap": 0,
-		"in-container": 0,
-		"locked-kept": 0,
-		complete: 0
-	};
+	let lockedKept = 0;
+	let complete = 0;
 	const boxes = [];
 	for (const item of input.items) {
-		const p = placements.get(item.id);
+		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 (item.locked === true && item.x !== void 0 && item.y !== void 0) breaks["locked-kept"] += 1;
-			if (!overflow.has(item.id)) breaks.complete += 1;
-			continue;
-		}
-		if (item.locked === true && item.x !== void 0 && item.y !== void 0) {
-			if (Math.abs(p.x - item.x) > .001 || Math.abs(p.y - item.y) > .001) breaks["locked-kept"] += 1;
+			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);
@@ -2099,18 +2010,17 @@ function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	}
 	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);
-		const at = moved.get(o.id) ?? b;
-		return {
-			l: at.x,
-			t: at.y,
-			r: at.x + b.w,
-			b: at.y + b.h
-		};
+		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)) breaks["no-overlap"] += 1;
-		for (const o of obstacles) if (overlap(a, o, tol)) breaks["no-overlap"] += 1;
+		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);
@@ -2121,12 +2031,18 @@ function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	const inset = container.inset ?? 0;
 	const fixedW = container.fixed === "size" || container.fixed === "width";
 	const fixedH = container.fixed === "size" || container.fixed === "height";
+	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) breaks["in-container"] += 1;
+		if (outX || outY) outside += 1;
 	}
-	return breaks;
+	return {
+		"no-overlap": overlaps,
+		"in-container": outside,
+		"locked-kept": lockedKept,
+		complete
+	};
 }
 // src/generators.ts
 /** The largest count of boxes that a generator makes. */
@@ -2347,8 +2263,10 @@ function containerOf(size, w, h, shape) {
 			aspectWeight: 0
 		}
 	}[size];
-	if (shape !== void 0) container.shape = shape;
-	return container;
+	return shape === void 0 ? container : {
+		...container,
+		shape
+	};
 }
 /** This function gives the 4 corners of a rectangle, clockwise from the top left. */
 const corners = (x, y, w, h) => [
@@ -3040,6 +2958,6 @@ function corpus(name, specs) {
 		inputs
 	};
 }
-export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, measure, measureChange, medianRatio, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
+export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, checkInput, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, measure, measureChange, medianRatio, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
 
 //# sourceMappingURL=index.js.map