@mark1russell7/packing 0.1.7 → 0.2.1

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 {
@@ -155,1559 +156,1940 @@ function compareRects(order) {
 		case "input": return () => 0;
 	}
 }
-// src/shelf.ts
+// src/contract.ts
+/** 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 = marginSides(item.margin);
+	return {
+		top: m.top,
+		right: m.right,
+		bottom: m.bottom,
+		left: m.left
+	};
+}
 /**
-* This function gives the first x from `start` where a rectangle of width `w` crosses no obstacle in the band from
-* `top` to `bottom`.
+* 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 firstFreeX(obstacles, start, w, top, bottom) {
-	let x = start;
-	let moved = true;
-	while (moved) {
-		moved = false;
-		for (const o of obstacles) if (o.top < bottom && top < o.bottom && o.left < x + w && x < o.right) {
-			x = o.right;
-			moved = true;
-		}
-	}
-	return x;
+function turnItem(item) {
+	return turnBox(item);
 }
-/** This function gives the lowest bottom edge of the obstacles in the band from `top` to `bottom`, under `top`. */
-function nextTop(obstacles, top, bottom) {
-	let next = Infinity;
-	for (const o of obstacles) if (o.top < bottom && top < o.bottom && o.bottom > top) next = Math.min(next, o.bottom);
-	return next;
+// src/frame.ts
+const clock = globalThis.performance;
+/** This function gives the time in milliseconds. */
+function now() {
+	return clock ? clock.now() : Date.now();
+}
+/** 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;
+	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
+	const fixedW = container.fixed === "size" || container.fixed === "width";
+	const fixedH = container.fixed === "size" || container.fixed === "height";
+	const w = shape?.w ?? container.w;
+	const h = shape?.h ?? container.h;
+	if (fixedW && w === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a width.`);
+	if (fixedH && h === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a height.`);
+	return {
+		x: shape?.x ?? 0,
+		y: shape?.y ?? 0,
+		w: fixedW ? w : Infinity,
+		h: fixedH ? h : Infinity
+	};
+}
+/** This function gives the items in the order of their rank. The index in the array is the rank of an item without one. */
+function byRank(items) {
+	return items.map((item, index) => ({
+		item,
+		rank: item.rank ?? index
+	})).toSorted((a, b) => a.rank - b.rank).map((e) => e.item);
 }
 /**
-* This function packs rectangles into shelves: rows that it fills left to right in the sort order, and does not fill
-* again. It goes around each `locked` rectangle. It sets the position of each rectangle and gives the outer rectangle.
-*
-* - With the sort order `input`, the rows read in the order of the array: left to right, and top to bottom.
-* - With `height-desc` (the default), it is the classic Next-Fit Decreasing Height packing.
-* - A rectangle goes to the first x in the row where it crosses no locked rectangle. If no such x is in the width,
-*   a new row starts under the current row.
-* - A rectangle wider than the outer rectangle goes on its own row, at the left edge, and overflows.
-* - It does not change the width. Without `fixedSize`, the height grows to the content. With `fixedSize`, a
-*   rectangle that does not fit is not packed: its `wasPacked` stays `false`.
+* This function makes the frame of an input. A locked item with a position and an obstacle without `move` are locked
+* rectangles. An obstacle with `move` is a free rectangle only when `movable` is `true`.
 */
-function packShelf(rects, outer, options = {}) {
-	const width = outer.size.x;
-	const obstacles = [];
-	let contentBottom = 0;
-	for (const rect of rects) {
-		if (!rect.locked) continue;
-		rect.wasPacked = true;
-		const left = rect.position.x - outer.position.x;
-		const top = rect.position.y - outer.position.y;
-		obstacles.push({
-			left,
-			top,
-			right: left + rect.size.x,
-			bottom: top + rect.size.y
+function buildFrame(input, movable = false) {
+	const bounds = containerBounds(input);
+	const inset = input.container.inset ?? 0;
+	const half = (input.gap ?? 0) / 2;
+	const ox = bounds.x + inset - half;
+	const oy = bounds.y + inset - half;
+	const w = bounds.w - 2 * inset + 2 * half;
+	const h = bounds.h - 2 * inset + 2 * half;
+	const entries = [];
+	const tooLarge = [];
+	for (const item of byRank(input.items)) {
+		const m = marginOf(item);
+		const rect = new Rect();
+		rect.size.set(item.w + m.left + m.right + 2 * half, item.h + m.top + m.bottom + 2 * half);
+		const dx = m.left + half;
+		const dy = m.top + half;
+		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 + EPS || rect.size.y > h + EPS) {
+			tooLarge.push(item.id);
+			continue;
+		}
+		entries.push({
+			rect,
+			item,
+			dx,
+			dy
 		});
-		contentBottom = Math.max(contentBottom, top + rect.size.y);
 	}
-	let rowTop = 0;
-	let rowBottom = 0;
-	let cursor = 0;
-	let rowEmpty = true;
-	for (const rect of rects.toSorted(compareRects(options.sortOrder ?? "height-desc"))) {
-		if (rect.wasPacked) continue;
-		const w = rect.size.x;
-		const h = rect.size.y;
-		if (!(w > 0 && h > 0)) continue;
-		const overflows = w > width;
-		if (overflows && outer.fixedSize) continue;
-		if (overflows && !rowEmpty) {
-			rowTop = rowBottom;
-			cursor = 0;
-			rowEmpty = true;
-		}
-		let x = firstFreeX(obstacles, cursor, w, rowTop, rowTop + h);
-		while (!overflows && x + w > width) {
-			rowTop = rowEmpty ? nextTop(obstacles, rowTop, rowTop + h) : rowBottom;
-			rowBottom = rowTop;
-			cursor = 0;
-			rowEmpty = true;
-			x = firstFreeX(obstacles, cursor, w, rowTop, rowTop + h);
-		}
-		while (overflows && x !== 0) {
-			rowTop = nextTop(obstacles, rowTop, rowTop + h);
-			rowBottom = rowTop;
-			x = firstFreeX(obstacles, 0, w, rowTop, rowTop + h);
-		}
-		if (outer.fixedSize && rowTop + h > outer.size.y) continue;
-		rect.position.set(x + outer.position.x, rowTop + outer.position.y);
-		rect.wasPacked = true;
-		rowEmpty = false;
-		cursor = x + w;
-		rowBottom = Math.max(rowBottom, rowTop + h);
-		contentBottom = Math.max(contentBottom, rowTop + h);
-		if (overflows) {
-			rowTop = rowBottom;
-			cursor = 0;
-			rowEmpty = true;
-		}
+	for (const obstacle of input.obstacles ?? []) {
+		const b = boundsOf(obstacle.region);
+		const rect = new Rect();
+		rect.size.set(b.w + 2 * half, b.h + 2 * half);
+		rect.position.set(b.x - half - ox, b.y - half - oy);
+		rect.locked = !(movable && obstacle.move !== void 0);
+		entries.push({
+			rect,
+			obstacle,
+			dx: half,
+			dy: half
+		});
 	}
-	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
+	return {
+		ox,
+		oy,
+		w,
+		h,
+		bounds,
+		inset,
+		entries,
+		tooLarge
+	};
+}
+/** This function gives the outer rectangle of 0.1 for a frame. A free height starts at 0 and grows. */
+function outerOf(frame) {
+	const outer = new Rect();
+	const fixedSize = Number.isFinite(frame.h);
+	outer.size.set(frame.w, fixedSize ? frame.h : 0);
+	outer.fixedWidth = true;
+	outer.fixedSize = fixedSize;
 	return outer;
 }
-// src/skyline.ts
+/** This function gives the rectangles of a frame, in the order of the entries. */
+function rectsOf(frame) {
+	return frame.entries.map((e) => e.rect);
+}
 /**
-* This function finds the lowest window of width `rw` on a skyline. For each `x` in `[0, width - rw]`, the height
-* of the window is the largest value of `skyline[x, x + rw)`. The first `x` with the smallest height wins. A
-* monotonic deque makes the search O(width) for one rectangle.
+* This function reads the output from the rectangles of a frame after a packing of 0.1. A locked item keeps its
+* position exactly. Each other item that the packer did not place goes to the overflow.
 */
-function lowestWindow(skyline, width, rw) {
-	const deque = new Int32Array(width);
-	let head = 0;
-	let tail = 0;
-	let bestX = 0;
-	let bestY = Infinity;
-	for (let i = 0; i < width; i++) {
-		while (tail > head && skyline[deque[tail - 1]] <= skyline[i]) tail--;
-		deque[tail++] = i;
-		if (deque[head] <= i - rw) head++;
-		if (i >= rw - 1) {
-			const max = skyline[deque[head]];
-			if (max < bestY) {
-				bestY = max;
-				bestX = i - rw + 1;
-			}
-		}
+function readFrame(input, frame, trace, moved = []) {
+	const placements = [];
+	const overflow = [...frame.tooLarge];
+	for (const e of frame.entries) {
+		const item = e.item;
+		if (item === void 0) continue;
+		if (item.locked === true && item.x !== void 0 && item.y !== void 0) placements.push({
+			id: item.id,
+			x: item.x,
+			y: item.y
+		});
+		else if (e.rect.wasPacked) placements.push({
+			id: item.id,
+			x: e.rect.position.x + e.dx + frame.ox,
+			y: e.rect.position.y + e.dy + frame.oy
+		});
+		else overflow.push(item.id);
 	}
 	return {
-		x: bestX,
-		y: bestY
+		placements,
+		overflow,
+		size: sizeOf(input, frame, placements, moved),
+		moved,
+		trace
 	};
 }
 /**
-* This function packs rectangles into an outer rectangle with a skyline. It puts each rectangle in the lowest place
-* where it fits, and it does not change the width of the outer rectangle.
-*
-* - A `locked` rectangle keeps its position. The skyline starts at its bottom edge across its width, thus the other
-*   rectangles go under it. The space above it stays empty, because a skyline has no holes.
-* - The skyline has a cell for each whole unit of the width. A rectangle that needs more cells than the outer
-*   rectangle has goes under all other rectangles, at the left edge.
-* - Without `fixedSize`, the height of the outer rectangle grows to the content. With `fixedSize`, a rectangle that
-*   does not fit is not packed: its `wasPacked` stays `false`.
-* - The default sort order is `height-desc`. The order of the array of the caller stays.
+* 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 packSkyline(rects, outer, options = {}) {
-	const width = Math.floor(outer.size.x);
-	if (width <= 0) return outer;
-	const skyline = new Float64Array(width);
-	for (const rect of rects) {
-		if (!rect.locked) continue;
-		rect.wasPacked = true;
-		const x0 = Math.max(0, Math.floor(rect.position.x - outer.position.x));
-		const x1 = Math.min(width, Math.ceil(rect.position.x - outer.position.x + rect.size.x));
-		const bottom = rect.position.y - outer.position.y + rect.size.y;
-		for (let i = x0; i < x1; i++) skyline[i] = Math.max(skyline[i], bottom);
-		if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, bottom);
+function sizeOf(input, frame, placements, moved) {
+	const items = new Map(input.items.map((i) => [i.id, i]));
+	let right = 0;
+	let bottom = 0;
+	for (const p of placements) {
+		const item = items.get(p.id);
+		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);
 	}
-	for (const rect of rects.toSorted(compareRects(options.sortOrder ?? "height-desc"))) {
-		if (rect.wasPacked) continue;
-		const rw = Math.ceil(rect.size.x);
-		const rh = rect.size.y;
-		if (rw <= 0 || rh <= 0) continue;
-		let x;
-		let y;
-		if (rw > width) {
-			if (outer.fixedSize) continue;
-			x = 0;
-			y = 0;
-			for (let i = 0; i < width; i++) if (skyline[i] > y) y = skyline[i];
-		} else {
-			({x, y} = lowestWindow(skyline, width, rw));
-			if (outer.fixedSize && y + rh > outer.size.y) continue;
+	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);
+	}
+	return {
+		w: Number.isFinite(frame.bounds.w) ? frame.bounds.w : right,
+		h: Number.isFinite(frame.bounds.h) ? frame.bounds.h : bottom
+	};
+}
+/** This function gives a region with the axes changed: x for y, and w for h. */
+function transposeRegion(region) {
+	switch (region.kind) {
+		case "rect": return {
+			kind: "rect",
+			x: region.y,
+			y: region.x,
+			w: region.h,
+			h: region.w
+		};
+		case "circle": return {
+			kind: "circle",
+			cx: region.cy,
+			cy: region.cx,
+			r: region.r
+		};
+		case "ellipse": return {
+			kind: "ellipse",
+			cx: region.cy,
+			cy: region.cx,
+			rx: region.ry,
+			ry: region.rx
+		};
+		case "polygon": {
+			const swap = (ring) => ring.map(([x, y]) => [y, x]);
+			return region.holes === void 0 ? {
+				kind: "polygon",
+				points: swap(region.points)
+			} : {
+				kind: "polygon",
+				points: swap(region.points),
+				holes: region.holes.map(swap)
+			};
 		}
-		rect.position.set(x + outer.position.x, y + outer.position.y);
-		rect.wasPacked = true;
-		const top = y + rh;
-		for (let i = x; i < Math.min(width, x + rw); i++) skyline[i] = top;
-		if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, top);
 	}
-	return outer;
 }
-// src/pack.ts
-function packInto(rects, region, offset, order) {
-	const unpacked = Rect.unpacked(rects);
-	pack(unpacked, region, { sortOrder: order });
-	for (const r of Rect.packed(unpacked)) r.translateBy(offset);
+/** 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, x, y, shape, margin, ...rest } = item;
+	return {
+		...rest,
+		w: item.h,
+		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
+		} }
+	};
 }
-function packRow(rects, outer, order) {
-	const row = [];
-	const byHeight = rects.toSorted(compareRects(order));
-	const fillGaps = order !== "input";
-	const rowRect = new Rect();
-	rowRect.size.set(outer.size.x, 0);
-	for (const rect of byHeight) {
-		if (rect.wasPacked) continue;
-		if (rect.size.x > rowRect.size.x) {
-			if (outer.fixedSize && rect.size.x > outer.size.x) continue;
-			const outerLeft = new Rect();
-			outerLeft.position.setTo(rowRect.position);
-			outerLeft.size.set(outer.size.x - rowRect.position.x, rowRect.size.y);
-			outerLeft.fixedSize = true;
-			if (fillGaps) packInto(rects, outerLeft, outer.position, order);
-			rowRect.position.set(0, rowRect.bottom());
-			rowRect.size.set(outer.size.x, 0);
-			row.length = 0;
+/** This function gives an input with the axes changed. A fixed height becomes a fixed width. */
+function transposeInput(input) {
+	const c = input.container;
+	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 }
+	};
+}
+/** This function gives an output with the axes changed. */
+function transposeOutput(output) {
+	return {
+		placements: output.placements.map((p) => ({
+			...p,
+			x: p.y,
+			y: p.x
+		})),
+		overflow: [...output.overflow],
+		size: {
+			w: output.size.h,
+			h: output.size.w
+		},
+		moved: output.moved.map((m) => ({
+			id: m.id,
+			x: m.y,
+			y: m.x
+		})),
+		...output.trace === void 0 ? {} : { trace: output.trace }
+	};
+}
+/**
+* This function packs an input with a fixed height through the turn of the axes. It changes x for y in the input.
+* Then it packs with a fixed width, and changes the axes of the output back.
+*/
+function viaAxes(input, previous, run) {
+	const start = now();
+	const inner = run(transposeInput(input), previous === void 0 ? void 0 : transposeOutput(previous));
+	return {
+		...transposeOutput(inner),
+		trace: [{
+			id: "axes",
+			ms: now() - start,
+			measures: {}
+		}, ...inner.trace ?? []]
+	};
+}
+// src/space.ts
+/** This function removes the closed interval from `a` to `b` from a list of spans. A span of no length goes. */
+function subtract(spans, a, b) {
+	const out = [];
+	for (const [s, e] of spans) {
+		if (b <= s || a >= e) {
+			out.push([s, e]);
+			continue;
 		}
-		if (rowRect.position.y + rect.size.y > outer.size.y) {
-			if (outer.fixedSize) continue;
-			outer.size.y += rect.size.y;
-			if (!outer.fixedWidth && !outer.size.x) outer.size.x = rect.size.x;
-			Rect.resetPacked(rects);
-			return false;
+		if (a > s) out.push([s, a]);
+		if (e > b) out.push([b, e]);
+	}
+	return out;
+}
+/** This function gives the x of a segment at `y`. The ends give their exact x. */
+function xAt(ax, ay, bx, by, y) {
+	if (y === ay) return ax;
+	if (y === by) return bx;
+	return ax + (y - ay) * (bx - ax) / (by - ay);
+}
+/** This function gives the x-range of the part of a segment in the open strip from `y0` to `y1`, or `undefined`. */
+function edgeRange(ax, ay, bx, by, y0, y1) {
+	const lo = Math.min(ay, by);
+	const hi = Math.max(ay, by);
+	if (hi <= y0 || lo >= y1) return void 0;
+	if (ay === by) return [Math.min(ax, bx), Math.max(ax, bx)];
+	const p = xAt(ax, ay, bx, by, Math.max(y0, lo));
+	const q = xAt(ax, ay, bx, by, Math.min(y1, hi));
+	return [Math.min(p, q), Math.max(p, q)];
+}
+/** This function gives the x-range of a region in the open strip from `y0` to `y1`, or `undefined` when they have no common point. */
+function regionRange(region, y0, y1) {
+	switch (region.kind) {
+		case "rect": return region.y < y1 && y0 < region.y + region.h ? [region.x, region.x + region.w] : void 0;
+		case "circle":
+		case "ellipse": {
+			const rx = region.kind === "circle" ? region.r : region.rx;
+			const ry = region.kind === "circle" ? region.r : region.ry;
+			if (y1 <= region.cy - ry || y0 >= region.cy + ry) return void 0;
+			const dy = y0 <= region.cy && region.cy <= y1 ? 0 : Math.min(Math.abs(y0 - region.cy), Math.abs(y1 - region.cy));
+			const c = rx * Math.sqrt(Math.max(0, 1 - (dy / ry) ** 2));
+			return [region.cx - c, region.cx + c];
 		}
-		row.push(rect);
-		rect.position.setTo(rowRect.position.add(outer.position));
-		rowRect.shrinkLeft(rect.size.x);
-		rect.wasPacked = true;
-		if (rect.size.y > rowRect.size.y) rowRect.size.y = rect.size.y;
-		if (fillGaps && row.length > 1) {
-			const rectInRow = row[row.length - 1];
-			const outerLeft = new Rect();
-			outerLeft.position.set(rectInRow.position.x - outer.position.x, rectInRow.bottom() - outer.position.y);
-			outerLeft.size.set(rectInRow.size.x, rowRect.size.y - rectInRow.size.y);
-			outerLeft.fixedWidth = true;
-			outerLeft.fixedSize = true;
-			packInto(rects, outerLeft, outer.position, order);
+		case "polygon": {
+			let lo = Infinity;
+			let hi = -Infinity;
+			const ring = region.points;
+			for (let i = 0; i < ring.length; i++) {
+				const a = ring[i];
+				const b = ring[(i + 1) % ring.length];
+				const r = edgeRange(a[0], a[1], b[0], b[1], y0, y1);
+				if (r === void 0) continue;
+				lo = Math.min(lo, r[0]);
+				hi = Math.max(hi, r[1]);
+			}
+			return lo <= hi ? [lo, hi] : void 0;
 		}
 	}
-	return true;
 }
-/**
-* This function packs rectangles into an outer rectangle of a given width with a guillotine row packing. It does
-* not change the width. Without `fixedSize`, the height grows until all rectangles fit. A `locked` rectangle keeps
-* its position, but the rows do not go around it. `pack` sets the width first and then uses this function.
-*/
-function packRows(rects, outer, options = {}) {
-	const order = options.sortOrder ?? "height-desc";
-	for (const r of rects) if (r.locked) r.wasPacked = true;
-	while (!packRow(rects, outer, order));
-	return outer;
+/** This function gives the spans of the outline of a layer for the strip from `y0` to `y1`, before the holes and the blockers. */
+function outline(layer, y0, y1) {
+	const { d } = layer;
+	switch (layer.kind) {
+		case "plain": return [[0, layer.w]];
+		case "box": return y0 < 0 || y1 > layer.h ? [] : [[0, layer.w]];
+		case "round": {
+			const r = layer.region;
+			if (r.kind !== "circle" && r.kind !== "ellipse") return [];
+			const rx = r.kind === "circle" ? r.r : r.rx;
+			const ry = r.kind === "circle" ? r.r : r.ry;
+			const top = y0 - d;
+			const bottom = y1 + d;
+			if (top < r.cy - ry || bottom > r.cy + ry) return [];
+			const dy = Math.max(Math.abs(top - r.cy), Math.abs(bottom - r.cy));
+			const c = rx * Math.sqrt(Math.max(0, 1 - (dy / ry) ** 2)) - EPS;
+			const a = r.cx - c + d;
+			const b = r.cx + c - d;
+			return b > a ? [[a, b]] : [];
+		}
+		case "rings": {
+			const top = y0 - d;
+			const bottom = y1 + d;
+			if (!(bottom > top)) return [];
+			const blocked = [];
+			for (const ring of layer.rings) for (let i = 0; i < ring.length; i++) {
+				const a = ring[i];
+				const b = ring[(i + 1) % ring.length];
+				const r = edgeRange(a[0], a[1], b[0], b[1], top, bottom);
+				if (r !== void 0) blocked.push(r);
+			}
+			if (blocked.length === 0) return [];
+			blocked.sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+			const merged = [];
+			for (const r of blocked) {
+				const last = merged.at(-1);
+				if (last !== void 0 && r[0] <= last[1]) last[1] = Math.max(last[1], r[1]);
+				else merged.push([r[0], r[1]]);
+			}
+			const spans = [];
+			for (let i = 0; i + 1 < merged.length; i++) {
+				const a = merged[i][1];
+				const b = merged[i + 1][0];
+				if (!(b > a)) continue;
+				if (!regionHitsRect(layer.region, {
+					x: a,
+					y: top,
+					w: b - a,
+					h: bottom - top
+				})) continue;
+				if (b - d > a + d) spans.push([a + d, b - d]);
+			}
+			return spans;
+		}
+	}
 }
-/**
-* This function packs rectangles into an outer rectangle with a guillotine row packing. It sets the position
-* of each rectangle and the size of the outer rectangle, and it gives the outer rectangle.
-*
-* - Without fixed sizes, the outer rectangle starts with a width of 1.5 times the square root of the total area.
-*   This width is not less than the width of the widest rectangle. The height grows until all rectangles fit.
-* - With `fixedWidth`, the width stays. A rectangle wider than that width goes on its own row and overflows.
-* - With `fixedSize`, a rectangle that does not fit is not packed: its `wasPacked` stays `false`.
-* - `options.strategy` selects `packRows` (the default), `packSkyline` or `packShelf` after the width is set.
-*/
-function pack(rects, outer = new Rect(), options = {}) {
-	let totalArea = 0;
-	let widest = 0;
-	let minX = rects.length > 0 ? Infinity : 0;
-	let minY = rects.length > 0 ? Infinity : 0;
-	for (const r of rects) {
-		totalArea += r.area();
-		widest = Math.max(widest, r.size.x);
-		minX = Math.min(minX, r.size.x);
-		minY = Math.min(minY, r.size.y);
+/** This function gives the free spans of a layer for the strip from `y0` to `y1`. */
+function spansOf(layer, y0, y1) {
+	let spans = outline(layer, y0, y1);
+	for (const hole of layer.holes) {
+		if (spans.length === 0) return spans;
+		if (Math.min(y1, hole.c1) - Math.max(y0, hole.c0) > 0) spans = subtract(spans, hole.a0, hole.a1);
 	}
-	const idealWidth = outer.fixedWidth ? outer.size.x : Math.max(widest, Math.min(1.5 * Math.sqrt(totalArea), outer.size.x || Infinity));
-	const ideal = Vector.of(idealWidth).clamp(new Vector(minX, minY), Vector.Infinity);
-	if (!outer.fixedSize) outer.size.setTo(outer.fixedWidth ? new Vector(outer.size.x, ideal.y) : ideal);
-	if (options.strategy === "skyline") packSkyline(rects, outer, options);
-	else if (options.strategy === "shelf") packShelf(rects, outer, options);
-	else packRows(rects, outer, options);
-	if (!outer.fixedSize) {
-		const contentRight = Rect.maxRight(rects);
-		if (!outer.size.x) outer.size.x = contentRight;
-		else if (!outer.fixedWidth) outer.size.x = Math.min(contentRight, outer.size.x);
-		outer.size.y = Rect.maxBottom(rects);
+	for (const b of layer.blockers) {
+		if (spans.length === 0) return spans;
+		if (b.c1 + b.g <= y0 || b.c0 - b.g >= y1) continue;
+		const r = regionRange(b.region, y0 - b.g, y1 + b.g);
+		if (r !== void 0) spans = subtract(spans, r[0] - b.g - EPS, r[1] + b.g + EPS);
 	}
-	return outer;
+	return spans;
 }
-// src/free.ts
-/** This function gives the distance between an aspect and a target aspect on a log scale. */
-function aspectError(width, height, target = 1) {
-	if (!(width > 0 && height > 0 && target > 0)) return Infinity;
-	return Math.abs(Math.log(width / height) - Math.log(target));
+/** This function gives the first x from `x` where a box of width `w` fits in one of the spans, or `Infinity`. */
+function firstFit(spans, x, w) {
+	for (const s of spans) {
+		const at = Math.max(x, s.start);
+		if (at + w <= s.end) return at;
+	}
+	return Infinity;
+}
+/** This function gives the next top edge of a layer after `y0` for a strip of the height `y1 - y0`, as `FreeSpace.nextY` tells. */
+function nextOf(layer, y0, y1, w) {
+	const height = y1 - y0;
+	const { d } = layer;
+	let next = Infinity;
+	const take = (y) => {
+		if (y > y0 + EPS && y < next) next = y;
+	};
+	for (const hole of layer.holes) if (hole.c0 < y1 && y0 < hole.c1) take(hole.c1);
+	for (const b of layer.blockers) if (b.c0 - b.g < y1 && y0 < b.c1 + b.g) take(b.c1 + b.g);
+	switch (layer.kind) {
+		case "plain": break;
+		case "box":
+			if (y1 > layer.h) return Infinity;
+			break;
+		case "rings":
+			for (const ring of layer.rings) for (const [, vy] of ring) {
+				take(vy + d);
+				take(vy - height - d);
+			}
+			break;
+		case "round": {
+			const r = layer.region;
+			if (r.kind !== "circle" && r.kind !== "ellipse") break;
+			const rx = r.kind === "circle" ? r.r : r.rx;
+			const ry = r.kind === "circle" ? r.r : r.ry;
+			const need = w / 2 + d + EPS;
+			if (need >= rx) return Infinity;
+			const reach = ry * Math.sqrt(1 - (need / rx) ** 2);
+			if (y1 + d > r.cy + reach) return Infinity;
+			take(r.cy - reach + d);
+			break;
+		}
+	}
+	return next;
+}
+/** This function gives the layer with the axes changed: the spans go along y, and the query goes along x. */
+function transposeLayer(layer) {
+	return {
+		kind: layer.kind,
+		w: layer.h,
+		h: layer.w,
+		d: layer.d,
+		...layer.region === void 0 ? {} : { region: transposeRegion(layer.region) },
+		rings: layer.rings.map((ring) => ring.map(([x, y]) => [y, x])),
+		holes: layer.holes.map((h) => ({
+			a0: h.c0,
+			a1: h.c1,
+			c0: h.a0,
+			c1: h.a1
+		})),
+		blockers: layer.blockers.map((b) => {
+			const region = transposeRegion(b.region);
+			const box = boundsOf(region);
+			return {
+				region,
+				g: b.g,
+				c0: box.y,
+				c1: box.y + box.h
+			};
+		})
+	};
+}
+/** This function makes a blocker of a region in the frame. */
+function blockerOf(region, g) {
+	const box = boundsOf(region);
+	return {
+		region,
+		g,
+		c0: box.y,
+		c1: box.y + box.h
+	};
 }
 /**
-* This function packs rectangles with a free width. It tries many widths with the strategy of `options`, and keeps
-* the width with the lowest objective: the area of the bounding box times `1 + aspectWeight * aspectError`.
-*
-* - The first pass tries `samples` widths on a log scale, from the widest rectangle to the width of one row.
-* - The second pass tries the widths between the two neighbours of the best width of the first pass.
-* - The search is deterministic: the same input gives the same widths and the same result.
-* - A `locked` rectangle keeps its position. The width is not less than its right edge.
-* - Each strategy of `pack` works with this function, because it only changes the width.
+* This function gives the free space of an input and its frame. The adapters use it with the frame that they pack.
+* `freeSpace` makes the frame itself.
 */
-function packFree(rects, outer = new Rect(), options = {}) {
-	const target = options.aspect ?? 1;
-	const weight = options.aspectWeight ?? 1;
-	const samples = Math.max(2, Math.floor(options.samples ?? 48));
-	const ox = outer.position.x;
-	const oy = outer.position.y;
-	let itemArea = 0;
-	let minWidth = 0;
-	let rowWidth = 0;
-	for (const r of rects) {
-		if (r.locked) {
-			minWidth = Math.max(minWidth, r.right() - ox);
+function spaceOf(input, frame) {
+	const { container } = input;
+	const half = (input.gap ?? 0) / 2;
+	const d = frame.inset - half;
+	const shape = container.shape === void 0 ? void 0 : translate(container.shape, -frame.ox, -frame.oy);
+	const fixedSize = Number.isFinite(frame.w) && Number.isFinite(frame.h);
+	const holes = [];
+	const blockers = [];
+	let rectObstacles = true;
+	for (const e of frame.entries) {
+		if (!e.rect.locked) continue;
+		if (e.obstacle !== void 0 && e.obstacle.region.kind !== "rect") {
+			rectObstacles = false;
+			blockers.push(blockerOf(translate(e.obstacle.region, -frame.ox, -frame.oy), half));
 			continue;
 		}
-		if (!(r.size.x > 0 && r.size.y > 0)) continue;
-		itemArea += r.area();
-		minWidth = Math.max(minWidth, r.size.x);
-		rowWidth += r.size.x;
-	}
-	for (const r of rects) if (r.locked) itemArea += r.area();
-	const maxWidth = Math.max(minWidth, rowWidth);
-	const tried = [];
-	const run = (width) => {
-		Rect.resetPacked(rects);
-		const box = new Rect();
-		box.position.setTo(outer.position);
-		box.size.set(width, 0);
-		box.fixedWidth = true;
-		pack(rects, box, options);
-		const placed = Rect.packed(rects);
-		const contentWidth = Math.max(0, Rect.maxRight(placed) - ox);
-		const contentHeight = Math.max(0, Rect.maxBottom(placed) - oy);
-		const area = contentWidth * contentHeight;
-		const t = {
-			width,
-			contentWidth,
-			contentHeight,
-			objective: area > 0 ? area * (1 + weight * aspectError(contentWidth, contentHeight, target)) : 0
-		};
-		tried.push(t);
-		return t;
-	};
-	const widths = [];
-	if (maxWidth > 0) {
-		const ratio = maxWidth / minWidth;
-		for (let i = 0; i < samples; i++) {
-			const w = minWidth * ratio ** (i / (samples - 1));
-			const rounded = i === samples - 1 ? maxWidth : Math.max(minWidth, Math.round(w));
-			if (widths.at(-1) !== rounded) widths.push(rounded);
-		}
-	}
-	let best = void 0;
-	let bestIndex = 0;
-	for (const [i, w] of widths.entries()) {
-		const t = run(w);
-		if (best === void 0 || t.objective < best.objective) {
-			best = t;
-			bestIndex = i;
-		}
-	}
-	if (widths.length > 2) {
-		const low = widths[Math.max(0, bestIndex - 1)];
-		const high = widths[Math.min(widths.length - 1, bestIndex + 1)];
-		const steps = Math.min(Math.floor(samples / 2), Math.max(0, Math.round(high - low) - 1));
-		for (let i = 1; i <= steps; i++) {
-			const w = Math.round(low + (high - low) * i / (steps + 1));
-			if (widths.includes(w)) continue;
-			const t = run(w);
-			if (best === void 0 || t.objective < best.objective) best = t;
-		}
+		const r = e.rect;
+		holes.push({
+			a0: r.position.x,
+			a1: r.right(),
+			c0: r.position.y,
+			c1: r.bottom()
+		});
 	}
-	const chosen = best === void 0 ? void 0 : run(best.width);
-	tried.pop();
-	const w = chosen?.contentWidth ?? 0;
-	const h = chosen?.contentHeight ?? 0;
-	if (!outer.fixedSize) outer.size.set(w, h);
-	const area = w * h;
-	return {
-		outer,
-		area,
-		fill: area > 0 ? itemArea / area : 0,
-		aspect: h > 0 ? w / h : 0,
-		aspectError: aspectError(w, h, target),
-		objective: chosen?.objective ?? 0,
-		tried
+	const plain = (shape === void 0 || shape.kind === "rect") && rectObstacles;
+	let layer = {
+		kind: plain ? "plain" : "box",
+		w: frame.w,
+		h: frame.h,
+		d,
+		rings: [],
+		holes,
+		blockers
 	};
-}
-// src/push.ts
-/** This function gives the overlap of two rectangles on each axis. A value of 0 or less is no overlap. */
-function overlapOf(a, b) {
+	if (shape !== void 0 && shape.kind !== "rect") {
+		if (fixedSize && shape.kind === "polygon") layer = {
+			...layer,
+			kind: "rings",
+			region: shape,
+			rings: [shape.points, ...shape.holes ?? []]
+		};
+		else if (fixedSize) layer = {
+			...layer,
+			kind: "round",
+			region: shape
+		};
+		else if (shape.kind === "polygon") for (const ring of shape.holes ?? []) blockers.push(blockerOf({
+			kind: "polygon",
+			points: ring
+		}, d));
+	}
+	const across = transposeLayer(layer);
+	const band = (y0, y1) => spansOf(layer, y0, y1).map(([start, end]) => ({
+		start,
+		end
+	}));
 	return {
-		x: Math.min(a.right(), b.right()) - Math.max(a.position.x, b.position.x),
-		y: Math.min(a.bottom(), b.bottom()) - Math.max(a.position.y, b.position.y)
+		w: frame.w,
+		h: frame.h,
+		plain,
+		band,
+		column(x0, x1, from = 0) {
+			for (const [start, end] of spansOf(across, x0, x1)) {
+				const top = Math.max(start, from);
+				if (end > top) return {
+					start: top,
+					end
+				};
+			}
+		},
+		fits(rect) {
+			return firstFit(band(rect.y, rect.y + rect.h), rect.x, rect.w) === rect.x;
+		},
+		fitX(x, w, y0, y1) {
+			return firstFit(band(y0, y1), x, w);
+		},
+		nextY(y0, y1, w) {
+			return nextOf(layer, y0, y1, w);
+		}
 	};
 }
 /**
-* This function gives the direction of a first shove. The axis has the smaller overlap. The sign points away from the
-* center of the pusher. When that shove crosses 0, the sign is positive.
+* This function gives the free space of an input, in the coordinates of the frame of the adapters. The origin of the
+* frame is the corner of the container, moved in by the inset and out by half the gap. `FreeSpace` tells the methods.
 */
-function firstDirection(pusher, r, gap) {
-	const overlap = overlapOf(pusher, r);
-	if (overlap.x < overlap.y) return {
-		axis: "x",
-		sign: r.position.x + r.size.x / 2 < pusher.position.x + pusher.size.x / 2 && pusher.position.x - r.size.x - gap >= 0 ? -1 : 1
-	};
-	return {
-		axis: "y",
-		sign: r.position.y + r.size.y / 2 < pusher.position.y + pusher.size.y / 2 && pusher.position.y - r.size.y - gap >= 0 ? -1 : 1
-	};
-}
-/** This function puts a rectangle past the pusher, along a direction. The rectangle does not go past 0. */
-function shove(pusher, r, direction, gap) {
-	if (direction.axis === "x") {
-		const x = direction.sign > 0 ? pusher.right() + gap : pusher.position.x - r.size.x - gap;
-		r.position.set(Math.max(0, x), r.position.y);
-		return;
-	}
-	const y = direction.sign > 0 ? pusher.bottom() + gap : pusher.position.y - r.size.y - gap;
-	r.position.set(r.position.x, Math.max(0, y));
+function freeSpace(input) {
+	return spaceOf(input, buildFrame(input));
 }
+// src/shelf.ts
 /**
-* This function moves each rectangle that a placed rectangle overlaps, and the rectangles that those overlap in turn.
-* A shove takes the axis of the smaller overlap, away from the pusher. A shoved rectangle keeps the direction of its first
-* shove when it shoves the next one, so the cascade goes outward. The placed rectangle and each locked rectangle stay.
-* The function moves the rectangles in place and gives the rectangles that moved.
-*
-* @example
-* ```ts
-* const moved = pushCascade(dropped, cards, { gap: 8 });
-* ```
+* This function gives the first x from `start` where a rectangle of width `w` crosses no obstacle in the band from
+* `top` to `bottom`.
 */
-function pushCascade(placed, rects, options = {}) {
-	const gap = options.gap ?? 8;
-	const maxShoves = options.maxShoves ?? rects.length * 8;
-	const moved = /* @__PURE__ */ new Set();
-	const queue = [{ pusher: placed }];
-	let shoves = 0;
-	while (shoves < maxShoves) {
-		const step = queue.shift();
-		if (!step) break;
-		const { pusher, direction } = step;
-		for (const r of rects) {
-			if (r === pusher || r === placed || r.locked) continue;
-			const overlap = overlapOf(pusher, r);
-			if (overlap.x <= 0 || overlap.y <= 0) continue;
-			const next = direction ?? firstDirection(pusher, r, gap);
-			shove(pusher, r, next, gap);
-			moved.add(r);
-			queue.push({
-				pusher: r,
-				direction: next
-			});
-			if (++shoves >= maxShoves) break;
+function firstFreeX(obstacles, start, w, top, bottom) {
+	let x = start;
+	let moved = true;
+	while (moved) {
+		moved = false;
+		for (const o of obstacles) if (o.top < bottom && top < o.bottom && o.left < x + w && x < o.right) {
+			x = o.right;
+			moved = true;
 		}
 	}
-	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
-	};
-	return {
-		top: m.top,
-		right: m.right,
-		bottom: m.bottom,
-		left: m.left
-	};
+	return x;
 }
-/** 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 the lowest bottom edge of the obstacles in the band from `top` to `bottom`, under `top`. */
+function nextTop(obstacles, top, bottom) {
+	let next = Infinity;
+	for (const o of obstacles) if (o.top < bottom && top < o.bottom && o.bottom > top) next = Math.min(next, o.bottom);
+	return next;
 }
 /**
-* 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.
+* This function packs rectangles into shelves: rows that it fills left to right in the sort order, and does not fill
+* again. It goes around each `locked` rectangle. It sets the position of each rectangle and gives the outer rectangle.
+*
+* - With the sort order `input`, the rows read in the order of the array: left to right, and top to bottom.
+* - With `height-desc` (the default), it is the classic Next-Fit Decreasing Height packing.
+* - A rectangle goes to the first x in the row where it crosses no locked rectangle. If no such x is in the width,
+*   a new row starts under the current row.
+* - A rectangle wider than the outer rectangle goes on its own row, at the left edge, and overflows.
+* - It does not change the width. Without `fixedSize`, the height grows to the content. With `fixedSize`, a
+*   rectangle that does not fit is not packed: its `wasPacked` stays `false`.
+* - With a space that is not plain, `packRowsInSpace` packs the rows into the outline of the space and around its holes.
 */
-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
-		};
+function packShelf(rects, outer, options = {}) {
+	if (options.space !== void 0 && !options.space.plain) return packRowsInSpace(rects, outer, options.sortOrder ?? "height-desc", options.space);
+	const width = outer.size.x;
+	const obstacles = [];
+	let contentBottom = 0;
+	for (const rect of rects) {
+		if (!rect.locked) continue;
+		rect.wasPacked = true;
+		const left = rect.position.x - outer.position.x;
+		const top = rect.position.y - outer.position.y;
+		obstacles.push({
+			left,
+			top,
+			right: left + rect.size.x,
+			bottom: top + rect.size.y
+		});
+		contentBottom = Math.max(contentBottom, top + rect.size.y);
 	}
-	return turned;
-}
-// src/sha256.ts
-/** The round constants of SHA-256. */
-const K = new Uint32Array([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-/** The first hash value of SHA-256. */
-const H0 = [
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-];
-/** This function turns a 32-bit word to the right by `n` bits. */
-const rotr = (x, n) => x >>> n | x << 32 - n;
+	let rowTop = 0;
+	let rowBottom = 0;
+	let cursor = 0;
+	let rowEmpty = true;
+	for (const rect of rects.toSorted(compareRects(options.sortOrder ?? "height-desc"))) {
+		if (rect.wasPacked) continue;
+		const w = rect.size.x;
+		const h = rect.size.y;
+		if (!(w > 0 && h > 0)) continue;
+		const overflows = w > width;
+		if (overflows && outer.fixedSize) continue;
+		if (overflows && !rowEmpty) {
+			rowTop = rowBottom;
+			cursor = 0;
+			rowEmpty = true;
+		}
+		let x = firstFreeX(obstacles, cursor, w, rowTop, rowTop + h);
+		while (!overflows && x + w > width) {
+			rowTop = rowEmpty ? nextTop(obstacles, rowTop, rowTop + h) : rowBottom;
+			rowBottom = rowTop;
+			cursor = 0;
+			rowEmpty = true;
+			x = firstFreeX(obstacles, cursor, w, rowTop, rowTop + h);
+		}
+		while (overflows && x !== 0) {
+			rowTop = nextTop(obstacles, rowTop, rowTop + h);
+			rowBottom = rowTop;
+			x = firstFreeX(obstacles, 0, w, rowTop, rowTop + h);
+		}
+		if (outer.fixedSize && rowTop + h > outer.size.y) continue;
+		rect.position.set(x + outer.position.x, rowTop + outer.position.y);
+		rect.wasPacked = true;
+		rowEmpty = false;
+		cursor = x + w;
+		rowBottom = Math.max(rowBottom, rowTop + h);
+		contentBottom = Math.max(contentBottom, rowTop + h);
+		if (overflows) {
+			rowTop = rowBottom;
+			cursor = 0;
+			rowEmpty = true;
+		}
+	}
+	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
+	return outer;
+}
 /**
-* This function gives the UTF-8 bytes of a string. A lone surrogate becomes U+FFFD, as with `TextEncoder`. The
-* package has no `TextEncoder` type, because its code operates on each runtime with no global types.
+* This function gives the first x from `start` where a rectangle of width `w` fits. There, it crosses no locked rectangle,
+* and it is in a free span of its band. It takes `firstFreeX` and `firstFit` in turn until they agree. It gives `Infinity` when no x fits.
 */
-function utf8(text) {
-	const out = [];
-	for (let i = 0; i < text.length; i++) {
-		let c = text.charCodeAt(i);
-		if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
-			const next = text.charCodeAt(i + 1);
-			if (next >= 56320 && next <= 57343) {
-				c = 65536 + (c - 55296 << 10) + (next - 56320);
-				i++;
+function placeInBand(obstacles, spans, start, w, top, bottom) {
+	let x = start;
+	for (;;) {
+		const free = firstFreeX(obstacles, x, w, top, bottom);
+		const fit = firstFit(spans, free, w);
+		if (fit === free || !Number.isFinite(fit)) return fit;
+		x = fit;
+	}
+}
+/**
+* This function packs rectangles into rows inside a free space. `packShelf` and `packRows` use it when the space is not
+* plain. It sets the position of each rectangle and gives the outer rectangle.
+*
+* - A rectangle goes to the first x from the row cursor where it fits in the space and crosses no locked rectangle.
+* - When it does not fit, a new row starts under the current row. An empty row steps down to `nextY` of the space.
+* - When the steps of an empty row find no place, the row goes back to its last top edge. Later rectangles can use it.
+* - A rectangle wider than the outer rectangle overflows. Without `fixedSize`, it goes on its own row at the left edge.
+*/
+function packRowsInSpace(rects, outer, order, space) {
+	const width = outer.size.x;
+	const ox = outer.position.x;
+	const oy = outer.position.y;
+	const limit = outer.fixedSize ? outer.size.y : Infinity;
+	const obstacles = [];
+	let contentBottom = 0;
+	for (const rect of rects) {
+		if (!rect.locked) continue;
+		rect.wasPacked = true;
+		const left = rect.position.x - ox;
+		const top = rect.position.y - oy;
+		obstacles.push({
+			left,
+			top,
+			right: left + rect.size.x,
+			bottom: top + rect.size.y
+		});
+		contentBottom = Math.max(contentBottom, top + rect.size.y);
+	}
+	const place = (start, w, top, h) => {
+		const spans = space.band(top + oy, top + h + oy).map((s) => ({
+			start: s.start - ox,
+			end: s.end - ox
+		}));
+		return placeInBand(obstacles, spans, start, w, top, top + h);
+	};
+	let rowTop = 0;
+	let rowBottom = 0;
+	let cursor = 0;
+	let rowEmpty = true;
+	for (const rect of rects.toSorted(compareRects(order))) {
+		if (rect.wasPacked) continue;
+		const w = rect.size.x;
+		const h = rect.size.y;
+		if (!(w > 0 && h > 0)) continue;
+		if (w > width) {
+			if (outer.fixedSize) continue;
+			const top = rowEmpty ? rowTop : rowBottom;
+			rect.position.set(ox, top + oy);
+			rect.wasPacked = true;
+			rowTop = top + h;
+			rowBottom = rowTop;
+			cursor = 0;
+			rowEmpty = true;
+			contentBottom = Math.max(contentBottom, top + h);
+			continue;
+		}
+		let x = place(cursor, w, rowTop, h);
+		if (!(x + w <= width) && !rowEmpty) {
+			rowTop = rowBottom;
+			cursor = 0;
+			rowEmpty = true;
+			x = place(0, w, rowTop, h);
+		}
+		let top = rowTop;
+		while (!(x + w <= width) && top + h <= limit) {
+			const next = Math.min(space.nextY(top + oy, top + h + oy, w) - oy, nextTop(obstacles, top, top + h));
+			if (!Number.isFinite(next)) break;
+			top = next;
+			x = place(0, w, top, h);
+		}
+		if (!(x + w <= width) || top + h > limit) continue;
+		if (top !== rowTop) {
+			rowTop = top;
+			rowBottom = top;
+		}
+		rect.position.set(x + ox, rowTop + oy);
+		rect.wasPacked = true;
+		rowEmpty = false;
+		cursor = x + w;
+		rowBottom = Math.max(rowBottom, rowTop + h);
+		contentBottom = Math.max(contentBottom, rowTop + h);
+	}
+	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
+	return outer;
+}
+// src/skyline.ts
+/**
+* This function finds the lowest window of width `rw` on a skyline. For each `x` in `[0, width - rw]`, the height
+* of the window is the largest value of `skyline[x, x + rw)`. The first `x` with the smallest height wins. A
+* monotonic deque makes the search O(width) for one rectangle.
+*
+* With `limit`, a window is valid only when its height plus `rh` is not more than the smallest value of
+* `limit[x, x + rw)`. A second deque keeps that smallest value. No valid window gives the height `Infinity`.
+*/
+function lowestWindow(skyline, width, rw, limit, rh = 0) {
+	if (limit !== void 0) return lowestLimitedWindow(skyline, limit, width, rw, rh);
+	const deque = new Int32Array(width);
+	let head = 0;
+	let tail = 0;
+	let bestX = 0;
+	let bestY = Infinity;
+	for (let i = 0; i < width; i++) {
+		while (tail > head && skyline[deque[tail - 1]] <= skyline[i]) tail--;
+		deque[tail++] = i;
+		if (deque[head] <= i - rw) head++;
+		if (i >= rw - 1) {
+			const max = skyline[deque[head]];
+			if (max < bestY) {
+				bestY = max;
+				bestX = i - rw + 1;
 			}
 		}
-		if (c >= 55296 && c <= 57343) c = 65533;
-		if (c < 128) out.push(c);
-		else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
-		else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
-		else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
 	}
-	return Uint8Array.from(out);
+	return {
+		x: bestX,
+		y: bestY
+	};
 }
-/** This function gives the SHA-256 of the UTF-8 bytes of a string, as 64 lowercase hex characters. */
-function sha256Hex(text) {
-	const bytes = utf8(text);
-	const length = bytes.length;
-	const padded = new Uint8Array(((length + 9 + 63) / 64 | 0) * 64);
-	padded.set(bytes);
-	padded[length] = 128;
-	const view = new DataView(padded.buffer);
-	const bits = length * 8;
-	view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
-	view.setUint32(padded.length - 4, bits >>> 0);
-	const hash = [...H0];
-	const w = /* @__PURE__ */ new Uint32Array(64);
-	for (let block = 0; block < padded.length; block += 64) {
-		for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
-		for (let t = 16; t < 64; t++) {
-			const a = w[t - 15];
-			const b = w[t - 2];
-			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
-			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
-			w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+/** This function is `lowestWindow` with a limit for each cell. */
+function lowestLimitedWindow(skyline, limit, width, rw, rh) {
+	const high = new Int32Array(width);
+	const low = new Int32Array(width);
+	let hh = 0;
+	let ht = 0;
+	let lh = 0;
+	let lt = 0;
+	let bestX = 0;
+	let bestY = Infinity;
+	for (let i = 0; i < width; i++) {
+		while (ht > hh && skyline[high[ht - 1]] <= skyline[i]) ht--;
+		high[ht++] = i;
+		if (high[hh] <= i - rw) hh++;
+		while (lt > lh && limit[low[lt - 1]] >= limit[i]) lt--;
+		low[lt++] = i;
+		if (low[lh] <= i - rw) lh++;
+		if (i >= rw - 1) {
+			const max = skyline[high[hh]];
+			if (max < bestY && max + rh <= limit[low[lh]]) {
+				bestY = max;
+				bestX = i - rw + 1;
+			}
 		}
-		let [a, b, c, d, e, f, g, h] = hash;
-		for (let t = 0; t < 64; t++) {
-			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-			const ch = e & f ^ ~e & g;
-			const t1 = h + s1 + ch + K[t] + w[t] | 0;
-			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
-			h = g;
-			g = f;
-			f = e;
-			e = d + t1 | 0;
-			d = c;
-			c = b;
-			b = a;
-			a = t1 + t2 | 0;
+	}
+	return {
+		x: bestX,
+		y: bestY
+	};
+}
+/**
+* This function packs rectangles into an outer rectangle with a skyline. It puts each rectangle in the lowest place
+* where it fits, and it does not change the width of the outer rectangle.
+*
+* - A `locked` rectangle keeps its position. The skyline starts at its bottom edge across its width, thus the other
+*   rectangles go under it. The space above it stays empty, because a skyline has no holes.
+* - The skyline has a cell for each whole unit of the width. A rectangle that needs more cells than the outer
+*   rectangle has goes under all other rectangles, at the left edge.
+* - Without `fixedSize`, the height of the outer rectangle grows to the content. With `fixedSize`, a rectangle that
+*   does not fit is not packed: its `wasPacked` stays `false`.
+* - The default sort order is `height-desc`. The order of the array of the caller stays.
+* - With a space that is not plain, each cell gets its start and its limit from `column` of the space. The space holds
+*   the obstacles and the locked items, thus the locked rectangles only keep their positions.
+*/
+function packSkyline(rects, outer, options = {}) {
+	if (options.space !== void 0 && !options.space.plain) return packSkylineInSpace(rects, outer, options.sortOrder ?? "height-desc", options.space);
+	const width = Math.floor(outer.size.x);
+	if (width <= 0) return outer;
+	const skyline = new Float64Array(width);
+	for (const rect of rects) {
+		if (!rect.locked) continue;
+		rect.wasPacked = true;
+		const x0 = Math.max(0, Math.floor(rect.position.x - outer.position.x));
+		const x1 = Math.min(width, Math.ceil(rect.position.x - outer.position.x + rect.size.x));
+		const bottom = rect.position.y - outer.position.y + rect.size.y;
+		for (let i = x0; i < x1; i++) skyline[i] = Math.max(skyline[i], bottom);
+		if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, bottom);
+	}
+	for (const rect of rects.toSorted(compareRects(options.sortOrder ?? "height-desc"))) {
+		if (rect.wasPacked) continue;
+		const rw = Math.ceil(rect.size.x);
+		const rh = rect.size.y;
+		if (rw <= 0 || rh <= 0) continue;
+		let x;
+		let y;
+		if (rw > width) {
+			if (outer.fixedSize) continue;
+			x = 0;
+			y = 0;
+			for (let i = 0; i < width; i++) if (skyline[i] > y) y = skyline[i];
+		} else {
+			({x, y} = lowestWindow(skyline, width, rw));
+			if (outer.fixedSize && y + rh > outer.size.y) continue;
+		}
+		rect.position.set(x + outer.position.x, y + outer.position.y);
+		rect.wasPacked = true;
+		const top = y + rh;
+		for (let i = x; i < Math.min(width, x + rw); i++) skyline[i] = top;
+		if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, top);
+	}
+	return outer;
+}
+/**
+* This function packs rectangles with a skyline in a free space. Each cell has a free range: the skyline is its start,
+* and `limit` is its end. A cell with less room than the lowest rectangle left goes to its next free range.
+*/
+function packSkylineInSpace(rects, outer, order, space) {
+	const width = Math.floor(outer.size.x);
+	if (width <= 0) return outer;
+	const ox = outer.position.x;
+	const oy = outer.position.y;
+	const end = outer.fixedSize ? outer.size.y : Infinity;
+	for (const rect of rects) if (rect.locked) rect.wasPacked = true;
+	const rangeOf = (i, from) => {
+		const r = space.column(ox + i, ox + i + 1, from + oy);
+		if (r === void 0) return [Infinity, -Infinity];
+		return [r.start - oy, Math.min(r.end - oy, end)];
+	};
+	const skyline = new Float64Array(width);
+	const limit = new Float64Array(width);
+	for (let i = 0; i < width; i++) [skyline[i], limit[i]] = rangeOf(i, 0);
+	const sorted = rects.toSorted(compareRects(order)).filter((r) => !r.wasPacked && Math.ceil(r.size.x) > 0 && r.size.y > 0);
+	const lowest = new Float64Array(sorted.length + 1).fill(Infinity);
+	for (let k = sorted.length - 1; k >= 0; k--) lowest[k] = Math.min(lowest[k + 1], sorted[k].size.y);
+	const advance = (k) => {
+		const need = lowest[k];
+		if (!Number.isFinite(need)) return;
+		for (let i = 0; i < width; i++) while (Number.isFinite(limit[i]) && limit[i] - skyline[i] < need && limit[i] < end) [skyline[i], limit[i]] = rangeOf(i, limit[i]);
+	};
+	for (const [k, rect] of sorted.entries()) {
+		advance(k);
+		const rw = Math.ceil(rect.size.x);
+		const rh = rect.size.y;
+		let x;
+		let y;
+		if (rw > width) {
+			if (outer.fixedSize) continue;
+			x = 0;
+			y = 0;
+			for (let i = 0; i < width; i++) if (Number.isFinite(skyline[i]) && skyline[i] > y) y = skyline[i];
+			rect.position.set(x + ox, y + oy);
+			rect.wasPacked = true;
+			outer.size.y = Math.max(outer.size.y, y + rh);
+			continue;
+		}
+		({x, y} = lowestWindow(skyline, width, rw, limit, rh));
+		let sky = skyline;
+		let lim = limit;
+		if (!Number.isFinite(y)) {
+			sky = skyline.slice();
+			lim = limit.slice();
+			for (let i = 0; i < width; i++) while (Number.isFinite(lim[i]) && lim[i] - sky[i] < rh && lim[i] < end) [sky[i], lim[i]] = rangeOf(i, lim[i]);
+			({x, y} = lowestWindow(sky, width, rw, lim, rh));
+			if (!Number.isFinite(y)) continue;
+		}
+		rect.position.set(x + ox, y + oy);
+		rect.wasPacked = true;
+		const top = y + rh;
+		for (let i = x; i < x + rw; i++) {
+			skyline[i] = top;
+			limit[i] = lim[i];
+		}
+		if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, top);
+	}
+	return outer;
+}
+// src/pack.ts
+function packInto(rects, region, offset, order) {
+	const unpacked = Rect.unpacked(rects);
+	pack(unpacked, region, { sortOrder: order });
+	for (const r of Rect.packed(unpacked)) r.translateBy(offset);
+}
+function packRow(rects, outer, order) {
+	const row = [];
+	const byHeight = rects.toSorted(compareRects(order));
+	const fillGaps = order !== "input";
+	const rowRect = new Rect();
+	rowRect.size.set(outer.size.x, 0);
+	for (const rect of byHeight) {
+		if (rect.wasPacked) continue;
+		if (rect.size.x > rowRect.size.x) {
+			if (outer.fixedSize && rect.size.x > outer.size.x) continue;
+			const outerLeft = new Rect();
+			outerLeft.position.setTo(rowRect.position);
+			outerLeft.size.set(outer.size.x - rowRect.position.x, rowRect.size.y);
+			outerLeft.fixedSize = true;
+			if (fillGaps) packInto(rects, outerLeft, outer.position, order);
+			rowRect.position.set(0, rowRect.bottom());
+			rowRect.size.set(outer.size.x, 0);
+			row.length = 0;
+		}
+		if (rowRect.position.y + rect.size.y > outer.size.y) {
+			if (outer.fixedSize) continue;
+			outer.size.y += rect.size.y;
+			if (!outer.fixedWidth && !outer.size.x) outer.size.x = rect.size.x;
+			Rect.resetPacked(rects);
+			return false;
+		}
+		row.push(rect);
+		rect.position.setTo(rowRect.position.add(outer.position));
+		rowRect.shrinkLeft(rect.size.x);
+		rect.wasPacked = true;
+		if (rect.size.y > rowRect.size.y) rowRect.size.y = rect.size.y;
+		if (fillGaps && row.length > 1) {
+			const rectInRow = row[row.length - 1];
+			const outerLeft = new Rect();
+			outerLeft.position.set(rectInRow.position.x - outer.position.x, rectInRow.bottom() - outer.position.y);
+			outerLeft.size.set(rectInRow.size.x, rowRect.size.y - rectInRow.size.y);
+			outerLeft.fixedWidth = true;
+			outerLeft.fixedSize = true;
+			packInto(rects, outerLeft, outer.position, order);
 		}
-		hash[0] = hash[0] + a | 0;
-		hash[1] = hash[1] + b | 0;
-		hash[2] = hash[2] + c | 0;
-		hash[3] = hash[3] + d | 0;
-		hash[4] = hash[4] + e | 0;
-		hash[5] = hash[5] + f | 0;
-		hash[6] = hash[6] + g | 0;
-		hash[7] = hash[7] + h | 0;
 	}
-	return hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
-}
-// src/layout-input.ts
-/** This function gives the `fnv1a32` hash of the UTF-8 bytes of a string, as `docs/FORMAT.md` gives it. */
-function fnv1a32(text) {
-	let h = 2166136261;
-	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
-	return h;
-}
-/** This function rounds the numbers of a file to 3 decimals. A half goes up, and the value `-0` becomes 0. */
-function round3(x) {
-	const v = Math.round(x * 1e3) / 1e3;
-	return Object.is(v, -0) ? 0 : v;
+	return true;
 }
 /**
-* This function gives the canonical form of a value: sorted keys, no whitespace and the numbers of `JSON.stringify`
-* after `round3`. A key with the value `undefined` is not in the form.
+* This function packs rectangles into an outer rectangle of a given width with a guillotine row packing. It does
+* not change the width. Without `fixedSize`, the height grows until all rectangles fit. A `locked` rectangle keeps
+* its position, but the rows do not go around it. `pack` sets the width first and then uses this function.
+*
+* With `options.space`, the rows go around the locked rectangles and the holes of the space, inside its outline. A space
+* that is plain, with no locked rectangle, gives the rows of 0.1.
 */
-function canonicalJson(value) {
-	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
-	return JSON.stringify(typeof value === "number" ? round3(value) : 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;
-	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`. */
-function countCell(count) {
-	if (count <= 3) return "1";
-	if (count <= 31) return "10";
-	if (count <= 316) return "100";
-	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. */
-function toPackInput(file) {
-	const input = {
-		container: file.container,
-		items: file.boxes
-	};
-	if (file.obstacles !== void 0) input.obstacles = file.obstacles;
-	if (file.gap !== void 0) input.gap = file.gap;
-	return input;
+function packRows(rects, outer, options = {}) {
+	const order = options.sortOrder ?? "height-desc";
+	const space = options.space;
+	if (space !== void 0 && (!space.plain || rects.some((r) => r.locked))) return packRowsInSpace(rects, outer, order, space);
+	for (const r of rects) if (r.locked) r.wasPacked = true;
+	while (!packRow(rects, outer, order));
+	return outer;
 }
-// src/measures.ts
-const spec = (id, family, unit, direction, min, max, guard) => ({
-	id,
-	family,
-	unit,
-	direction,
-	min,
-	max,
-	...guard
-});
 /**
-* 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.
+* This function packs rectangles into an outer rectangle with a guillotine row packing. It sets the position
+* of each rectangle and the size of the outer rectangle, and it gives the outer rectangle.
+*
+* - Without fixed sizes, the outer rectangle starts with a width of 1.5 times the square root of the total area.
+*   This width is not less than the width of the widest rectangle. The height grows until all rectangles fit.
+* - With `fixedWidth`, the width stays. A rectangle wider than that width goes on its own row and overflows.
+* - With `fixedSize`, a rectangle that does not fit is not packed: its `wasPacked` stays `false`.
+* - `options.strategy` selects `packRows` (the default), `packSkyline` or `packShelf` after the width is set.
 */
-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, {
-		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, {
-		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)
-});
-/** This function gives the smallest rectangle around the boxes. No box gives a rectangle of size 0 at 0, 0. */
-function hullOf(boxes) {
-	if (boxes.length === 0) return {
-		x: 0,
-		y: 0,
-		w: 0,
-		h: 0
-	};
-	let left = Infinity;
-	let top = Infinity;
-	let right = -Infinity;
-	let bottom = -Infinity;
-	for (const b of boxes) {
-		left = Math.min(left, b.x);
-		top = Math.min(top, b.y);
-		right = Math.max(right, b.x + b.w);
-		bottom = Math.max(bottom, b.y + b.h);
+function pack(rects, outer = new Rect(), options = {}) {
+	let totalArea = 0;
+	let widest = 0;
+	let minX = rects.length > 0 ? Infinity : 0;
+	let minY = rects.length > 0 ? Infinity : 0;
+	for (const r of rects) {
+		totalArea += r.area();
+		widest = Math.max(widest, r.size.x);
+		minX = Math.min(minX, r.size.x);
+		minY = Math.min(minY, r.size.y);
 	}
-	return {
-		x: left,
-		y: top,
-		w: right - left,
-		h: bottom - top
-	};
-}
-/**
-* This function puts the boxes in rows. It sorts the boxes by their top, and keeps the order of the list for equal tops.
-* A box joins the last row when its top is within `tolerance` of the top of the first box of that row.
-*/
-function rowsOf$1(boxes, tolerance) {
-	const rows = [];
-	for (const b of boxes.toSorted((p, q) => p.y - q.y)) {
-		const row = rows.at(-1);
-		if (row && Math.abs(b.y - row.top) <= tolerance) {
-			row.right = Math.max(row.right, b.x + b.w);
-			row.count += 1;
-		} else rows.push({
-			top: b.y,
-			right: b.x + b.w,
-			count: 1
-		});
+	const idealWidth = outer.fixedWidth ? outer.size.x : Math.max(widest, Math.min(1.5 * Math.sqrt(totalArea), outer.size.x || Infinity));
+	const ideal = Vector.of(idealWidth).clamp(new Vector(minX, minY), Vector.Infinity);
+	if (!outer.fixedSize) outer.size.setTo(outer.fixedWidth ? new Vector(outer.size.x, ideal.y) : ideal);
+	if (options.strategy === "skyline") packSkyline(rects, outer, options);
+	else if (options.strategy === "shelf") packShelf(rects, outer, options);
+	else packRows(rects, outer, options);
+	if (!outer.fixedSize) {
+		const contentRight = Rect.maxRight(rects);
+		if (!outer.size.x) outer.size.x = contentRight;
+		else if (!outer.fixedWidth) outer.size.x = Math.min(contentRight, outer.size.x);
+		outer.size.y = Rect.maxBottom(rects);
 	}
-	return rows;
+	return outer;
+}
+// src/free.ts
+/** This function gives the distance between an aspect and a target aspect on a log scale. */
+function aspectError(width, height, target = 1) {
+	if (!(width > 0 && height > 0 && target > 0)) return Infinity;
+	return Math.abs(Math.log(width / height) - Math.log(target));
 }
 /**
-* This function gives the placed boxes of an output, in the order of the items of the input. A box has the size of its
-* item after the turn. The list has no item without a placement, and no item with a width or a height of 0.
+* This function packs rectangles with a free width. It tries many widths with the strategy of `options`, and keeps
+* the width with the lowest objective: the area of the bounding box times `1 + aspectWeight * aspectError`.
+*
+* - The first pass tries `samples` widths on a log scale, from the widest rectangle to the width of one row.
+* - The second pass tries the widths between the two neighbours of the best width of the first pass.
+* - The search is deterministic: the same input gives the same widths and the same result.
+* - A `locked` rectangle keeps its position. The width is not less than its right edge.
+* - Each strategy of `pack` works with this function, because it only changes the width.
 */
-function boxesOf$1(input, output) {
-	const placements = /* @__PURE__ */ new Map();
-	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
-	const boxes = [];
-	for (const [index, item] of input.items.entries()) {
-		const p = placements.get(item.id);
-		if (p === void 0 || !(item.w > 0 && item.h > 0)) continue;
-		const turned = p.turn === 90;
-		boxes.push({
-			x: p.x,
-			y: p.y,
-			w: turned ? item.h : item.w,
-			h: turned ? item.w : item.h,
-			rank: item.rank ?? index
-		});
+function packFree(rects, outer = new Rect(), options = {}) {
+	const target = options.aspect ?? 1;
+	const weight = options.aspectWeight ?? 1;
+	const samples = Math.max(2, Math.floor(options.samples ?? 48));
+	const ox = outer.position.x;
+	const oy = outer.position.y;
+	let itemArea = 0;
+	let minWidth = 0;
+	let rowWidth = 0;
+	for (const r of rects) {
+		if (r.locked) {
+			minWidth = Math.max(minWidth, r.right() - ox);
+			continue;
+		}
+		if (!(r.size.x > 0 && r.size.y > 0)) continue;
+		itemArea += r.area();
+		minWidth = Math.max(minWidth, r.size.x);
+		rowWidth += r.size.x;
+	}
+	for (const r of rects) if (r.locked) itemArea += r.area();
+	const maxWidth = Math.max(minWidth, rowWidth);
+	const tried = [];
+	const run = (width) => {
+		Rect.resetPacked(rects);
+		const box = new Rect();
+		box.position.setTo(outer.position);
+		box.size.set(width, 0);
+		box.fixedWidth = true;
+		pack(rects, box, options);
+		const placed = Rect.packed(rects);
+		const contentWidth = Math.max(0, Rect.maxRight(placed) - ox);
+		const contentHeight = Math.max(0, Rect.maxBottom(placed) - oy);
+		const area = contentWidth * contentHeight;
+		const t = {
+			width,
+			contentWidth,
+			contentHeight,
+			objective: area > 0 ? area * (1 + weight * aspectError(contentWidth, contentHeight, target)) : 0
+		};
+		tried.push(t);
+		return t;
+	};
+	const widths = [];
+	if (maxWidth > 0) {
+		const ratio = maxWidth / minWidth;
+		for (let i = 0; i < samples; i++) {
+			const w = minWidth * ratio ** (i / (samples - 1));
+			const rounded = i === samples - 1 ? maxWidth : Math.max(minWidth, Math.round(w));
+			if (widths.at(-1) !== rounded) widths.push(rounded);
+		}
+	}
+	let best = void 0;
+	let bestIndex = 0;
+	for (const [i, w] of widths.entries()) {
+		const t = run(w);
+		if (best === void 0 || t.objective < best.objective) {
+			best = t;
+			bestIndex = i;
+		}
+	}
+	if (widths.length > 2) {
+		const low = widths[Math.max(0, bestIndex - 1)];
+		const high = widths[Math.min(widths.length - 1, bestIndex + 1)];
+		const steps = Math.min(Math.floor(samples / 2), Math.max(0, Math.round(high - low) - 1));
+		for (let i = 1; i <= steps; i++) {
+			const w = Math.round(low + (high - low) * i / (steps + 1));
+			if (widths.includes(w)) continue;
+			const t = run(w);
+			if (best === void 0 || t.objective < best.objective) best = t;
+		}
 	}
-	return boxes;
+	const chosen = best === void 0 ? void 0 : run(best.width);
+	tried.pop();
+	const w = chosen?.contentWidth ?? 0;
+	const h = chosen?.contentHeight ?? 0;
+	if (!outer.fixedSize) outer.size.set(w, h);
+	const area = w * h;
+	return {
+		outer,
+		area,
+		fill: area > 0 ? itemArea / area : 0,
+		aspect: h > 0 ? w / h : 0,
+		aspectError: aspectError(w, h, target),
+		objective: chosen?.objective ?? 0,
+		tried
+	};
+}
+// src/push.ts
+/** This function gives the overlap of two rectangles on each axis. A value of 0 or less is no overlap. */
+function overlapOf(a, b) {
+	return {
+		x: Math.min(a.right(), b.right()) - Math.max(a.position.x, b.position.x),
+		y: Math.min(a.bottom(), b.bottom()) - Math.max(a.position.y, b.position.y)
+	};
 }
 /**
-* This function tells if box `a` comes before box `b` in the reading order. Two boxes whose heights overlap by more than
-* `RECORD_EPS` are on one line, and the left box comes first. Otherwise the upper box comes first.
+* This function gives the direction of a first shove. The axis has the smaller overlap. The sign points away from the
+* center of the pusher. When that shove crosses 0, the sign is positive.
 */
-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;
-	return a.y < b.y;
+function firstDirection(pusher, r, gap) {
+	const overlap = overlapOf(pusher, r);
+	if (overlap.x < overlap.y) return {
+		axis: "x",
+		sign: r.position.x + r.size.x / 2 < pusher.position.x + pusher.size.x / 2 && pusher.position.x - r.size.x - gap >= 0 ? -1 : 1
+	};
+	return {
+		axis: "y",
+		sign: r.position.y + r.size.y / 2 < pusher.position.y + pusher.size.y / 2 && pusher.position.y - r.size.y - gap >= 0 ? -1 : 1
+	};
 }
-/** 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;
-	return sum;
+/** This function puts a rectangle past the pusher, along a direction. The rectangle does not go past 0. */
+function shove(pusher, r, direction, gap) {
+	if (direction.axis === "x") {
+		const x = direction.sign > 0 ? pusher.right() + gap : pusher.position.x - r.size.x - gap;
+		r.position.set(Math.max(0, x), r.position.y);
+		return;
+	}
+	const y = direction.sign > 0 ? pusher.bottom() + gap : pusher.position.y - r.size.y - gap;
+	r.position.set(r.position.x, Math.max(0, y));
 }
 /**
-* This function gives the measures of one layout, by the ids of `docs/MEASURES.md`. The values are not rounded. A
-* record rounds them with `roundMeasures`.
-*
-* - The boxes are the placed items with a width and a height above 0. The hull is the smallest rectangle around them.
-* - An empty layout gives the area 0, the aspect 1 and the aspect error 0. Its fill is 0 and its whitespace is 1.
-* - The time `pack.search.ms` comes from the trace. It is not part of the determinism rule.
+* This function moves each rectangle that a placed rectangle overlaps, and the rectangles that those overlap in turn.
+* A shove takes the axis of the smaller overlap, away from the pusher. A shoved rectangle keeps the direction of its first
+* shove when it shoves the next one, so the cascade goes outward. The placed rectangle and each locked rectangle stay.
+* The function moves the rectangles in place and gives the rectangles that moved.
 *
 * @example
 * ```ts
-* const m = measure(input, packWith("shelf", input));
-* m["pack.fill"]; // the area of the boxes divided by the area of the hull
+* const moved = pushCascade(dropped, cards, { gap: 8 });
 * ```
 */
-function measure(input, output, options = {}) {
-	const boxes = boxesOf$1(input, output);
-	const hull = hullOf(boxes);
-	const hullArea = hull.w * hull.h;
-	const boxArea = boxes.reduce((sum, b) => sum + b.w * b.h, 0);
-	const fill = hullArea > 0 ? boxArea / hullArea : 0;
-	const empty = boxes.length === 0;
-	const target = input.container.aspect ?? 1;
-	let pairs = 0;
-	let inversions = 0;
-	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
-		const a = boxes[i];
-		const b = boxes[j];
-		if (a.rank === b.rank) continue;
-		pairs += 1;
-		const first = a.rank < b.rank ? a : b;
-		if (readsBefore(first === a ? b : a, first)) inversions += 1;
-	}
-	const byRank = boxes.toSorted((a, b) => a.rank - b.rank);
-	let breaks = 0;
-	for (let k = 1; k < byRank.length; k++) {
-		const prev = byRank[k - 1];
-		const next = byRank[k];
-		if (prev.rank !== next.rank && readsBefore(next, prev)) breaks += 1;
-	}
-	const rights = rowsOf$1(boxes, options.rowTolerance ?? quantileOrZero(boxes.map((b) => b.h), .5) / 2).map((r) => r.right);
-	const spread = rights.length > 0 ? Math.max(...rights) - Math.min(...rights) : 0;
-	return {
-		"pack.area": hullArea,
-		"pack.fill": fill,
-		"pack.whitespace": 1 - fill,
-		"pack.aspect": empty ? 1 : Math.max(hull.w / hull.h, hull.h / hull.w),
-		"pack.aspectError": empty ? 0 : aspectError(hull.w, hull.h, target),
-		"pack.order.inversions": pairs > 0 ? inversions / pairs : 0,
-		"pack.order.breaks": breaks,
-		"pack.raggedness": hull.w > 0 ? spread / hull.w : 0,
-		"pack.overflow": new Set(output.overflow).size,
-		"pack.search.widths": traceSum(output, "pack.search.widths"),
-		"pack.search.ms": traceSum(output, "pack.search.ms")
-	};
-}
-/**
-* This function gives the stability measures of a change pair: the run on the base input and the run on the changed
-* input. The items match by id. The values are not rounded.
-*
-* - An item stays when both inputs have it and both outputs place it. The added and the removed items do not count.
-* - A staying item moved when its `x` or its `y` changed by more than `RECORD_EPS`, or when its turn changed.
-* - The distance of an item is the length of the move of its top-left corner. The unit is the width `W`.
-* - `W` is the larger width of the 2 output sizes. A `W` of 0 becomes 1, so the unit is then the unit of the input.
-* - No staying item gives 0 for each measure.
-*/
-function measureChange(baseInput, baseOutput, changeInput, changeOutput) {
-	const placed = (input, output) => {
-		const ids = new Set(input.items.map((i) => i.id));
-		const map = /* @__PURE__ */ new Map();
-		for (const p of output.placements) if (ids.has(p.id) && !map.has(p.id)) map.set(p.id, p);
-		return map;
-	};
-	const before = placed(baseInput, baseOutput);
-	const after = placed(changeInput, changeOutput);
-	const width = Math.max(baseOutput.size.w, changeOutput.size.w);
-	const unit = width > 0 ? width : 1;
-	const distances = [];
-	let moved = 0;
-	for (const [id, p] of before) {
-		const q = after.get(id);
-		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;
-		distances.push(Math.hypot(dx, dy) / unit);
+function pushCascade(placed, rects, options = {}) {
+	const gap = options.gap ?? 8;
+	const maxShoves = options.maxShoves ?? rects.length * 8;
+	const moved = /* @__PURE__ */ new Set();
+	const queue = [{ pusher: placed }];
+	let shoves = 0;
+	while (shoves < maxShoves) {
+		const step = queue.shift();
+		if (!step) break;
+		const { pusher, direction } = step;
+		for (const r of rects) {
+			if (r === pusher || r === placed || r.locked) continue;
+			const overlap = overlapOf(pusher, r);
+			if (overlap.x <= 0 || overlap.y <= 0) continue;
+			const next = direction ?? firstDirection(pusher, r, gap);
+			shove(pusher, r, next, gap);
+			moved.add(r);
+			queue.push({
+				pusher: r,
+				direction: next
+			});
+			if (++shoves >= maxShoves) break;
+		}
 	}
-	if (distances.length === 0) return {
-		"pack.stability.moved": 0,
-		"pack.stability.mean": 0,
-		"pack.stability.q95": 0
-	};
-	return {
-		"pack.stability.moved": moved / distances.length,
-		"pack.stability.mean": distances.reduce((sum, d) => sum + d, 0) / distances.length,
-		"pack.stability.q95": quantile(distances, .95)
-	};
+	return [...moved];
 }
+// src/sha256.ts
+/** The round constants of SHA-256. */
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** The first hash value of SHA-256. */
+const H0 = [
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+];
+/** This function turns a 32-bit word to the right by `n` bits. */
+const rotr = (x, n) => x >>> n | x << 32 - n;
 /**
-* This function gives the measure `pack.deterministic` of two runs with the same input, options and seed. It gives
-* `true` when the runs have the same placements, overflow, size and moved obstacles.
-*
-* - The placements match by id, so their order in the list does not count. The numbers must be equal.
-* - The trace is not part of the rule, because its times change each time.
+* This function gives the UTF-8 bytes of a string. A lone surrogate becomes U+FFFD, as with `TextEncoder`. The
+* package has no `TextEncoder` type, because its code operates on each runtime with no global types.
 */
-function isDeterministic(first, second) {
-	const key = (list) => new Map(list.map((e) => [e.id, e]));
-	const samePlacements = (a, b) => {
-		if (a.length !== b.length) return false;
-		const other = key(b);
-		return a.every((p) => {
-			const q = other.get(p.id);
-			return q !== void 0 && q.x === p.x && q.y === p.y && (q.turn ?? 0) === (p.turn ?? 0);
-		});
-	};
-	const sameMoved = (a, b) => {
-		if (a.length !== b.length) return false;
-		const other = key(b);
-		return a.every((m) => {
-			const n = other.get(m.id);
-			return n !== void 0 && n.x === m.x && n.y === m.y;
-		});
-	};
-	const overflowA = new Set(first.overflow);
-	const overflowB = new Set(second.overflow);
-	return first.size.w === second.size.w && first.size.h === second.size.h && overflowA.size === overflowB.size && [...overflowA].every((id) => overflowB.has(id)) && samePlacements(first.placements, second.placements) && sameMoved(first.moved, second.moved);
+function utf8(text) {
+	const out = [];
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
+			const next = text.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) {
+				c = 65536 + (c - 55296 << 10) + (next - 56320);
+				i++;
+			}
+		}
+		if (c >= 55296 && c <= 57343) c = 65533;
+		if (c < 128) out.push(c);
+		else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return Uint8Array.from(out);
 }
-/**
-* This function rounds each number of a record of measures with `round3`, as `docs/FORMAT.md` tells. A half goes up,
-* and `-0` becomes 0. The function keeps the other values, and it does not change its argument.
-*/
-function roundMeasures(measures) {
-	const out = {};
-	for (const [id, value] of Object.entries(measures)) out[id] = typeof value === "number" ? round3(value) : value;
-	return out;
+/** This function gives the SHA-256 of the UTF-8 bytes of a string, as 64 lowercase hex characters. */
+function sha256Hex(text) {
+	const bytes = utf8(text);
+	const length = bytes.length;
+	const padded = new Uint8Array(((length + 9 + 63) / 64 | 0) * 64);
+	padded.set(bytes);
+	padded[length] = 128;
+	const view = new DataView(padded.buffer);
+	const bits = length * 8;
+	view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+	view.setUint32(padded.length - 4, bits >>> 0);
+	const hash = [...H0];
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < padded.length; block += 64) {
+		for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
+		for (let t = 16; t < 64; t++) {
+			const a = w[t - 15];
+			const b = w[t - 2];
+			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
+			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = hash;
+		for (let t = 0; t < 64; t++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + s1 + ch + K[t] + w[t] | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		hash[0] = hash[0] + a | 0;
+		hash[1] = hash[1] + b | 0;
+		hash[2] = hash[2] + c | 0;
+		hash[3] = hash[3] + d | 0;
+		hash[4] = hash[4] + e | 0;
+		hash[5] = hash[5] + f | 0;
+		hash[6] = hash[6] + g | 0;
+		hash[7] = hash[7] + h | 0;
+	}
+	return hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
 }
-/**
-* This function gives the paired ratio of a measure on one input: the value of the candidate against the value of the
-* current default. A ratio above 1 is worse, in the direction of the measure.
-*
-* - For `lower`, the ratio is `candidate / current`. For `higher`, it is `current / candidate`.
-* - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
-* - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
-*/
-function pairedRatio(candidate, current, direction) {
-	if (!(candidate >= 0 && current >= 0)) throw new RangeError("A paired ratio needs two values of 0 or more.");
-	const top = direction === "lower" ? candidate : current;
-	const bottom = direction === "lower" ? current : candidate;
-	if (bottom === 0) return top === 0 ? 1 : Infinity;
-	return top / bottom;
+// src/layout-input.ts
+/** This function gives the `fnv1a32` hash of the UTF-8 bytes of a string, as `docs/FORMAT.md` gives it. */
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
+	return h;
+}
+/** This function rounds the numbers of a file to 3 decimals. A half goes up, and the value `-0` becomes 0. */
+function round3(x) {
+	const v = Math.round(x * 1e3) / 1e3;
+	return Object.is(v, -0) ? 0 : v;
 }
 /**
-* This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
-* position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
+* This function gives the canonical form of a value: sorted keys, no whitespace and the numbers of `JSON.stringify`
+* after `round3`. A key with the value `undefined` is not in the form.
 */
-function quantile(values, q) {
-	if (values.length === 0) throw new RangeError("A quantile needs one value or more.");
-	if (!(q >= 0 && q <= 1)) throw new RangeError("A quantile needs a q from 0 to 1.");
-	const sorted = values.toSorted((a, b) => a - b);
-	const at = (sorted.length - 1) * q;
-	const low = Math.floor(at);
-	const part = at - low;
-	const a = sorted[low];
-	if (part === 0) return a;
-	const b = sorted[low + 1];
-	if (a === b) return a;
-	return a + part * (b - a);
-}
-/** This function gives the quantile `q` of a list, and 0 for an empty list. */
-function quantileOrZero(values, q) {
-	return values.length === 0 ? 0 : quantile(values, q);
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+	return JSON.stringify(typeof value === "number" ? round3(value) : value);
 }
-/** This function gives the median of the paired ratios of a corpus: the quantile 0.5. It is not a ratio of two medians. */
-function medianRatio(ratios) {
-	return quantile(ratios, .5);
+/** 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 { hash: _hash, ...rest } = file;
+	return sha256Hex(canonicalJson(rest)).slice(0, 16);
 }
-/** This function gives the share of the paired ratios above a limit. An empty list throws a `RangeError`. */
-function tailShare(ratios, limit) {
-	if (ratios.length === 0) throw new RangeError("A tail share needs one ratio or more.");
-	return ratios.filter((r) => r > limit).length / ratios.length;
+/** 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`. */
+function countCell(count) {
+	if (count <= 3) return "1";
+	if (count <= 31) return "10";
+	if (count <= 316) return "100";
+	if (count <= 3162) return "1k";
+	return "10k";
 }
-// src/metrics.ts
 /**
-* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
-* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
-*
-* @example
-* ```ts
-* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
-* ```
+* 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 packingMetrics(rects, options = {}) {
-	const tolerance = options.rowTolerance ?? 40;
-	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0).map((r) => ({
-		x: r.position.x,
-		y: r.position.y,
-		w: r.size.x,
-		h: r.size.y
-	}));
-	if (boxes.length === 0) return {
-		count: 0,
-		hull: {
-			width: 0,
-			height: 0
-		},
-		hullAspect: 0,
-		rows: [],
-		raggedness: 0,
-		utilization: 0,
-		widestOverMedian: 0
+function toPackInput(file) {
+	return {
+		container: file.container ?? { fixed: "none" },
+		items: file.boxes,
+		...file.obstacles === void 0 ? {} : { obstacles: file.obstacles },
+		...file.gap === void 0 ? {} : { gap: file.gap }
 	};
-	const box = hullOf(boxes);
-	const hull = {
-		width: box.w,
-		height: box.h
+}
+// src/measures.ts
+const spec = (id, family, unit, direction, min, max, guard) => ({
+	id,
+	family,
+	unit,
+	direction,
+	min,
+	max,
+	...guard
+});
+/**
+* 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, {
+		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, {
+		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)
+});
+/** This function gives the smallest rectangle around the boxes. No box gives a rectangle of size 0 at 0, 0. */
+function hullOf(boxes) {
+	if (boxes.length === 0) return {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
 	};
-	const rows = rowsOf$1(boxes, tolerance);
-	const rights = rows.map((row) => row.right);
-	const widths = boxes.map((r) => r.w).toSorted((a, b) => a - b);
-	const median = widths[Math.floor(widths.length / 2)] ?? 0;
-	const widest = widths.at(-1) ?? 0;
-	const area = boxes.reduce((sum, r) => sum + r.w * r.h, 0);
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.w);
+		bottom = Math.max(bottom, b.y + b.h);
+	}
 	return {
-		count: boxes.length,
-		hull,
-		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
-		rows: rows.map((row) => row.count),
-		raggedness: Math.max(...rights) - Math.min(...rights),
-		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
-		widestOverMedian: median > 0 ? widest / median : 0
+		x: left,
+		y: top,
+		w: right - left,
+		h: bottom - top
 	};
 }
-// src/strategy.ts
 /**
-* The error of a strategy for an input outside its cells. The benchmark records this result. It is not a failure of the
-* strategy.
+* This function puts the boxes in rows. It sorts the boxes by their top, and keeps the order of the list for equal tops.
+* A box joins the last row when its top is within `tolerance` of the top of the first box of that row.
 */
-var UnsupportedCell = class extends Error {
-	/** The dimension of the taxonomy. */
-	dimension;
-	/** The value of the input that the strategy does not support. */
-	value;
-	constructor(dimension, value) {
-		super(`The strategy does not support the value "${value}" of the dimension "${dimension}".`);
-		this.name = "UnsupportedCell";
-		this.dimension = dimension;
-		this.value = value;
+function rowsOf$1(boxes, tolerance) {
+	const rows = [];
+	for (const b of boxes.toSorted((p, q) => p.y - q.y)) {
+		const row = rows.at(-1);
+		if (row && Math.abs(b.y - row.top) <= tolerance) {
+			row.right = Math.max(row.right, b.x + b.w);
+			row.count += 1;
+		} else rows.push({
+			top: b.y,
+			right: b.x + b.w,
+			count: 1
+		});
 	}
-};
-/** This function gives a generator of random numbers in `[0, 1)`: `mulberry32` of `docs/FORMAT.md`. */
-function mulberry32(seed) {
-	let s = seed >>> 0;
-	return () => {
-		s = s + 1831565813 | 0;
-		let t = Math.imul(s ^ s >>> 15, 1 | s);
-		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-		return ((t ^ t >>> 14) >>> 0) / 4294967296;
-	};
-}
-/** This function makes the context of one packing from a seed. */
-function createContext(seed = 0, more = {}) {
-	return {
-		...more,
-		seed,
-		rng: mulberry32(seed)
-	};
+	return rows;
 }
-/** This function tells if a polygon ring is convex. A ring with fewer than 3 points is convex. */
-function isConvex(points) {
-	let sign = 0;
-	const n = points.length;
-	for (let i = 0; i < n; i++) {
-		const [ax, ay] = points[i];
-		const [bx, by] = points[(i + 1) % n];
-		const [cx, cy] = points[(i + 2) % n];
-		const cross = (bx - ax) * (cy - by) - (by - ay) * (cx - bx);
-		if (cross === 0) continue;
-		if (sign === 0) sign = Math.sign(cross);
-		else if (Math.sign(cross) !== sign) return false;
+/**
+* This function gives the placed boxes of an output, in the order of the items of the input. A box has the size of its
+* item after the turn. The list has no item without a placement, and no item with a width or a height of 0.
+*/
+function boxesOf$1(input, output) {
+	const placements = /* @__PURE__ */ new Map();
+	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
+	const boxes = [];
+	for (const [index, item] of input.items.entries()) {
+		const p = placements.get(item.id);
+		if (p === void 0 || !(item.w > 0 && item.h > 0)) continue;
+		const turned = p.turn === 90;
+		boxes.push({
+			x: p.x,
+			y: p.y,
+			w: turned ? item.h : item.w,
+			h: turned ? item.w : item.h,
+			rank: item.rank ?? index
+		});
 	}
-	return true;
+	return boxes;
 }
-/** This function gives the value of `containerShape` of one region. */
-function shapeOf$1(region) {
-	switch (region.kind) {
-		case "rect":
-		case "circle":
-		case "ellipse": return region.kind;
-		case "polygon":
-			if (region.holes && region.holes.length > 0) return "holes";
-			return isConvex(region.points) ? "convex" : "polygon";
-	}
+/**
+* This function tells if box `a` comes before box `b` in the reading order. Two boxes whose heights overlap by more than
+* `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) > RECORD_EPS) return a.x + RECORD_EPS < b.x;
+	return a.y < b.y;
 }
-/** This function gives the value of `itemShape` of one item shape. An ellipse is convex. */
-function itemShapeOf(region) {
-	if (region === void 0) return "rect";
-	switch (region.kind) {
-		case "rect":
-		case "circle": return region.kind;
-		case "ellipse": return "convex";
-		case "polygon": return !region.holes?.length && isConvex(region.points) ? "convex" : "polygon";
-	}
+/** 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;
+	return sum;
 }
 /**
-* This function gives the cell of an input: the values of the packer dimensions that the input tells.
+* This function gives the measures of one layout, by the ids of `docs/MEASURES.md`. The values are not rounded. A
+* record rounds them with `roundMeasures`.
 *
-* - `containerSize` comes from `fixed`. The value `none` gives `freeArea` when `aspectWeight` is 0, and `freeAspect` if not.
-* - `containerShape` comes from the shape. A rectangle container with an obstacle of another region gives `holes`.
-* - `obstacleMove` is the hardest value of the obstacles and the locked items: `costly`, then `free`, then `fixed`.
-* - `order` is `soft` when an item has a rank, and `free` if not. The input does not tell a hard order.
-* - `groups` is `nested` when an item has a parent, `flat` when an item has a group, and `none` if not.
+* - The boxes are the placed items with a width and a height above 0. The hull is the smallest rectangle around them.
+* - An empty layout gives the area 0, the aspect 1 and the aspect error 0. Its fill is 0 and its whitespace is 1.
+* - The time `pack.search.ms` comes from the trace. It is not part of the determinism rule.
+*
+* @example
+* ```ts
+* const m = measure(input, packWith("shelf", input));
+* m["pack.fill"]; // the area of the boxes divided by the area of the hull
+* ```
 */
-function cellOf(input) {
-	const { container, items } = input;
-	const obstacles = input.obstacles ?? [];
-	const containerSize = {
-		size: "fixed",
-		width: "freeHeight",
-		height: "freeWidth",
-		none: container.aspectWeight === 0 ? "freeArea" : "freeAspect"
-	}[container.fixed];
-	let containerShape = container.shape ? shapeOf$1(container.shape) : "rect";
-	if (containerShape === "rect" && obstacles.some((o) => o.region.kind !== "rect")) containerShape = "holes";
-	let obstacleMove = items.some((i) => i.locked === true) ? "fixed" : void 0;
-	for (const o of obstacles) {
-		const move = o.move === void 0 ? "fixed" : o.move.cost > 0 ? "costly" : "free";
-		if (move === "costly" || obstacleMove === void 0 || move === "free" && obstacleMove === "fixed") obstacleMove = move;
-	}
-	const shapes = new Set(items.map((i) => itemShapeOf(i.shape)));
-	const itemShape = shapes.size > 1 ? "mixed" : [...shapes][0] ?? "rect";
-	const cell = {
-		containerSize,
-		containerShape,
-		itemShape,
-		rotation: items.some((i) => i.turnable === true) ? "quarter" : "none",
-		order: items.some((i) => i.rank !== void 0) ? "soft" : "free",
-		groups: items.some((i) => i.parent !== void 0) ? "nested" : items.some((i) => i.group !== void 0) ? "flat" : "none"
-	};
-	if (obstacleMove !== void 0) cell.obstacleMove = obstacleMove;
-	return cell;
-}
-/** This function gives the first dimension of a cell that `supports` does not hold, or `undefined` when it holds each one. */
-function unsupportedOf(supports, cell) {
-	for (const dimension of Object.keys(supports)) {
-		const value = cell[dimension];
-		if (value === void 0) continue;
-		if (!supports[dimension].includes(value)) return {
-			dimension,
-			value
-		};
-	}
-}
-/** This function tells if `supports` holds each value of a cell. A dimension that the cell does not have is held. */
-function supportsCell(supports, cell) {
-	return unsupportedOf(supports, cell) === void 0;
-}
-/** This function throws `UnsupportedCell` for the first value of the cell of an input that `supports` does not hold. */
-function assertSupported(supports, input) {
-	const miss = unsupportedOf(supports, cellOf(input));
-	if (miss) throw new UnsupportedCell(miss.dimension, miss.value);
-}
-// src/frame.ts
-const clock = globalThis.performance;
-/** This function gives the time in milliseconds. */
-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
-			};
-		}
+function measure(input, output, options = {}) {
+	const boxes = boxesOf$1(input, output);
+	const hull = hullOf(boxes);
+	const hullArea = hull.w * hull.h;
+	const boxArea = boxes.reduce((sum, b) => sum + b.w * b.h, 0);
+	const fill = hullArea > 0 ? boxArea / hullArea : 0;
+	const empty = boxes.length === 0;
+	const target = input.container.aspect ?? 1;
+	let pairs = 0;
+	let inversions = 0;
+	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
+		const a = boxes[i];
+		const b = boxes[j];
+		if (a.rank === b.rank) continue;
+		pairs += 1;
+		const first = a.rank < b.rank ? a : b;
+		if (readsBefore(first === a ? b : a, first)) inversions += 1;
 	}
-}
-/** 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;
-	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
-	const fixedW = container.fixed === "size" || container.fixed === "width";
-	const fixedH = container.fixed === "size" || container.fixed === "height";
-	const w = shape?.w ?? container.w;
-	const h = shape?.h ?? container.h;
-	if (fixedW && w === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a width.`);
-	if (fixedH && h === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a height.`);
+	const byRank = boxes.toSorted((a, b) => a.rank - b.rank);
+	let breaks = 0;
+	for (let k = 1; k < byRank.length; k++) {
+		const prev = byRank[k - 1];
+		const next = byRank[k];
+		if (prev.rank !== next.rank && readsBefore(next, prev)) breaks += 1;
+	}
+	const rights = rowsOf$1(boxes, options.rowTolerance ?? quantileOrZero(boxes.map((b) => b.h), .5) / 2).map((r) => r.right);
+	const spread = rights.length > 0 ? Math.max(...rights) - Math.min(...rights) : 0;
 	return {
-		x: shape?.x ?? 0,
-		y: shape?.y ?? 0,
-		w: fixedW ? w : Infinity,
-		h: fixedH ? h : Infinity
+		"pack.area": hullArea,
+		"pack.fill": fill,
+		"pack.whitespace": 1 - fill,
+		"pack.aspect": empty ? 1 : Math.max(hull.w / hull.h, hull.h / hull.w),
+		"pack.aspectError": empty ? 0 : aspectError(hull.w, hull.h, target),
+		"pack.order.inversions": pairs > 0 ? inversions / pairs : 0,
+		"pack.order.breaks": breaks,
+		"pack.raggedness": hull.w > 0 ? spread / hull.w : 0,
+		"pack.overflow": new Set(output.overflow).size,
+		"pack.search.widths": traceSum(output, "pack.search.widths"),
+		"pack.search.ms": traceSum(output, "pack.search.ms")
 	};
 }
-/** This function gives the items in the order of their rank. The index in the array is the rank of an item without one. */
-function byRank(items) {
-	return items.map((item, index) => ({
-		item,
-		rank: item.rank ?? index
-	})).toSorted((a, b) => a.rank - b.rank).map((e) => e.item);
+/**
+* This function gives the stability measures of a change pair: the run on the base input and the run on the changed
+* input. The items match by id. The values are not rounded.
+*
+* - An item stays when both inputs have it and both outputs place it. The added and the removed items do not count.
+* - A staying item moved when its `x` or its `y` changed by more than `RECORD_EPS`, or when its turn changed.
+* - The distance of an item is the length of the move of its top-left corner. The unit is the width `W`.
+* - `W` is the larger width of the 2 output sizes. A `W` of 0 becomes 1, so the unit is then the unit of the input.
+* - No staying item gives 0 for each measure.
+*/
+function measureChange(baseInput, baseOutput, changeInput, changeOutput) {
+	const placed = (input, output) => {
+		const ids = new Set(input.items.map((i) => i.id));
+		const map = /* @__PURE__ */ new Map();
+		for (const p of output.placements) if (ids.has(p.id) && !map.has(p.id)) map.set(p.id, p);
+		return map;
+	};
+	const before = placed(baseInput, baseOutput);
+	const after = placed(changeInput, changeOutput);
+	const width = Math.max(baseOutput.size.w, changeOutput.size.w);
+	const unit = width > 0 ? width : 1;
+	const distances = [];
+	let moved = 0;
+	for (const [id, p] of before) {
+		const q = after.get(id);
+		if (q === void 0) continue;
+		const dx = q.x - p.x;
+		const dy = q.y - p.y;
+		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 {
+		"pack.stability.moved": 0,
+		"pack.stability.mean": 0,
+		"pack.stability.q95": 0
+	};
+	return {
+		"pack.stability.moved": moved / distances.length,
+		"pack.stability.mean": distances.reduce((sum, d) => sum + d, 0) / distances.length,
+		"pack.stability.q95": quantile(distances, .95)
+	};
 }
 /**
-* This function makes the frame of an input. A locked item with a position and an obstacle without `move` are locked
-* rectangles. An obstacle with `move` is a free rectangle only when `movable` is `true`.
+* This function gives the measure `pack.deterministic` of two runs with the same input, options and seed. It gives
+* `true` when the runs have the same placements, overflow, size and moved obstacles.
+*
+* - The placements match by id, so their order in the list does not count. The numbers must be equal.
+* - The trace is not part of the rule, because its times change each time.
 */
-function buildFrame(input, movable = false) {
-	const bounds = containerBounds(input);
-	const inset = input.container.inset ?? 0;
-	const half = (input.gap ?? 0) / 2;
-	const ox = bounds.x + inset - half;
-	const oy = bounds.y + inset - half;
-	const w = bounds.w - 2 * inset + 2 * half;
-	const h = bounds.h - 2 * inset + 2 * half;
-	const entries = [];
-	const tooLarge = [];
-	for (const item of byRank(input.items)) {
-		const m = marginOf(item);
-		const rect = new Rect();
-		rect.size.set(item.w + m.left + m.right + 2 * half, item.h + m.top + m.bottom + 2 * half);
-		const dx = m.left + half;
-		const dy = m.top + half;
-		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) {
-			tooLarge.push(item.id);
-			continue;
-		}
-		entries.push({
-			rect,
-			item,
-			dx,
-			dy
+function isDeterministic(first, second) {
+	const key = (list) => new Map(list.map((e) => [e.id, e]));
+	const samePlacements = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((p) => {
+			const q = other.get(p.id);
+			return q !== void 0 && q.x === p.x && q.y === p.y && (q.turn ?? 0) === (p.turn ?? 0);
 		});
-	}
-	for (const obstacle of input.obstacles ?? []) {
-		const b = boundsOf(obstacle.region);
-		const rect = new Rect();
-		rect.size.set(b.w + 2 * half, b.h + 2 * half);
-		rect.position.set(b.x - half - ox, b.y - half - oy);
-		rect.locked = !(movable && obstacle.move !== void 0);
-		entries.push({
-			rect,
-			obstacle,
-			dx: half,
-			dy: half
+	};
+	const sameMoved = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((m) => {
+			const n = other.get(m.id);
+			return n !== void 0 && n.x === m.x && n.y === m.y;
 		});
-	}
-	return {
-		ox,
-		oy,
-		w,
-		h,
-		bounds,
-		inset,
-		entries,
-		tooLarge
 	};
+	const overflowA = new Set(first.overflow);
+	const overflowB = new Set(second.overflow);
+	return first.size.w === second.size.w && first.size.h === second.size.h && overflowA.size === overflowB.size && [...overflowA].every((id) => overflowB.has(id)) && samePlacements(first.placements, second.placements) && sameMoved(first.moved, second.moved);
 }
-/** This function gives the outer rectangle of 0.1 for a frame. A free height starts at 0 and grows. */
-function outerOf(frame) {
-	const outer = new Rect();
-	const fixedSize = Number.isFinite(frame.h);
-	outer.size.set(frame.w, fixedSize ? frame.h : 0);
-	outer.fixedWidth = true;
-	outer.fixedSize = fixedSize;
-	return outer;
+/**
+* This function rounds each number of a record of measures with `round3`, as `docs/FORMAT.md` tells. A half goes up,
+* and `-0` becomes 0. The function keeps the other values, and it does not change its argument.
+*/
+function roundMeasures(measures) {
+	const out = {};
+	for (const [id, value] of Object.entries(measures)) out[id] = typeof value === "number" ? round3(value) : value;
+	return out;
 }
-/** This function gives the rectangles of a frame, in the order of the entries. */
-function rectsOf(frame) {
-	return frame.entries.map((e) => e.rect);
+/**
+* This function gives the paired ratio of a measure on one input: the value of the candidate against the value of the
+* current default. A ratio above 1 is worse, in the direction of the measure.
+*
+* - For `lower`, the ratio is `candidate / current`. For `higher`, it is `current / candidate`.
+* - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
+* - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
+*/
+function pairedRatio(candidate, current, direction) {
+	if (!(candidate >= 0 && current >= 0)) throw new RangeError("A paired ratio needs two values of 0 or more.");
+	const top = direction === "lower" ? candidate : current;
+	const bottom = direction === "lower" ? current : candidate;
+	if (bottom === 0) return top === 0 ? 1 : Infinity;
+	return top / bottom;
 }
 /**
-* This function reads the output from the rectangles of a frame after a packing of 0.1. A locked item keeps its
-* position exactly. Each other item that the packer did not place goes to the overflow.
+* This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
+* position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
 */
-function readFrame(input, frame, trace, moved = []) {
-	const placements = [];
-	const overflow = [...frame.tooLarge];
-	for (const e of frame.entries) {
-		const item = e.item;
-		if (item === void 0) continue;
-		if (item.locked === true && item.x !== void 0 && item.y !== void 0) placements.push({
-			id: item.id,
-			x: item.x,
-			y: item.y
-		});
-		else if (e.rect.wasPacked) placements.push({
-			id: item.id,
-			x: e.rect.position.x + e.dx + frame.ox,
-			y: e.rect.position.y + e.dy + frame.oy
-		});
-		else overflow.push(item.id);
-	}
+function quantile(values, q) {
+	if (values.length === 0) throw new RangeError("A quantile needs one value or more.");
+	if (!(q >= 0 && q <= 1)) throw new RangeError("A quantile needs a q from 0 to 1.");
+	const sorted = values.toSorted((a, b) => a - b);
+	const at = (sorted.length - 1) * q;
+	const low = Math.floor(at);
+	const part = at - low;
+	const a = sorted[low];
+	if (part === 0) return a;
+	const b = sorted[low + 1];
+	if (a === b) return a;
+	return a + part * (b - a);
+}
+/** This function gives the quantile `q` of a list, and 0 for an empty list. */
+function quantileOrZero(values, q) {
+	return values.length === 0 ? 0 : quantile(values, q);
+}
+/** This function gives the median of the paired ratios of a corpus: the quantile 0.5. It is not a ratio of two medians. */
+function medianRatio(ratios) {
+	return quantile(ratios, .5);
+}
+/** This function gives the share of the paired ratios above a limit. An empty list throws a `RangeError`. */
+function tailShare(ratios, limit) {
+	if (ratios.length === 0) throw new RangeError("A tail share needs one ratio or more.");
+	return ratios.filter((r) => r > limit).length / ratios.length;
+}
+// src/metrics.ts
+/**
+* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
+* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
+*
+* @example
+* ```ts
+* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
+* ```
+*/
+function packingMetrics(rects, options = {}) {
+	const tolerance = options.rowTolerance ?? 40;
+	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0).map((r) => ({
+		x: r.position.x,
+		y: r.position.y,
+		w: r.size.x,
+		h: r.size.y
+	}));
+	if (boxes.length === 0) return {
+		count: 0,
+		hull: {
+			width: 0,
+			height: 0
+		},
+		hullAspect: 0,
+		rows: [],
+		raggedness: 0,
+		utilization: 0,
+		widestOverMedian: 0
+	};
+	const box = hullOf(boxes);
+	const hull = {
+		width: box.w,
+		height: box.h
+	};
+	const rows = rowsOf$1(boxes, tolerance);
+	const rights = rows.map((row) => row.right);
+	const widths = boxes.map((r) => r.w).toSorted((a, b) => a - b);
+	const median = widths[Math.floor(widths.length / 2)] ?? 0;
+	const widest = widths.at(-1) ?? 0;
+	const area = boxes.reduce((sum, r) => sum + r.w * r.h, 0);
 	return {
-		placements,
-		overflow,
-		size: sizeOf(input, frame, placements, moved),
-		moved,
-		trace
+		count: boxes.length,
+		hull,
+		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
+		rows: rows.map((row) => row.count),
+		raggedness: Math.max(...rights) - Math.min(...rights),
+		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
+		widestOverMedian: median > 0 ? widest / median : 0
 	};
 }
+// src/strategy.ts
 /**
-* 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.
+* The error of a strategy for an input outside its cells. The benchmark records this result. It is not a failure of the
+* strategy.
 */
-function sizeOf(input, frame, placements, moved) {
-	const items = new Map(input.items.map((i) => [i.id, i]));
-	let right = 0;
-	let bottom = 0;
-	for (const p of placements) {
-		const item = items.get(p.id);
-		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);
-	}
-	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);
+var UnsupportedCell = class extends Error {
+	/** The dimension of the taxonomy. */
+	dimension;
+	/** The value of the input that the strategy does not support. */
+	value;
+	constructor(dimension, value) {
+		super(`The strategy does not support the value "${value}" of the dimension "${dimension}".`);
+		this.name = "UnsupportedCell";
+		this.dimension = dimension;
+		this.value = value;
 	}
+};
+/** This function gives a generator of random numbers in `[0, 1)`: `mulberry32` of `docs/FORMAT.md`. */
+function mulberry32(seed) {
+	let s = seed >>> 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = Math.imul(s ^ s >>> 15, 1 | s);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** This function makes the context of one packing from a seed. */
+function createContext(seed = 0, more = {}) {
 	return {
-		w: Number.isFinite(frame.bounds.w) ? frame.bounds.w : right,
-		h: Number.isFinite(frame.bounds.h) ? frame.bounds.h : bottom
+		...more,
+		seed,
+		rng: mulberry32(seed)
 	};
 }
-/** This function gives a region with the axes changed: x for y, and w for h. */
-function transposeRegion(region) {
+/** This function tells if a polygon ring is convex. A ring with fewer than 3 points is convex. */
+function isConvex(points) {
+	let sign = 0;
+	const n = points.length;
+	for (let i = 0; i < n; i++) {
+		const [ax, ay] = points[i];
+		const [bx, by] = points[(i + 1) % n];
+		const [cx, cy] = points[(i + 2) % n];
+		const cross = (bx - ax) * (cy - by) - (by - ay) * (cx - bx);
+		if (cross === 0) continue;
+		if (sign === 0) sign = Math.sign(cross);
+		else if (Math.sign(cross) !== sign) return false;
+	}
+	return true;
+}
+/** This function gives the value of `containerShape` of one region. */
+function shapeOf$1(region) {
 	switch (region.kind) {
-		case "rect": return {
-			kind: "rect",
-			x: region.y,
-			y: region.x,
-			w: region.h,
-			h: region.w
-		};
-		case "circle": return {
-			kind: "circle",
-			cx: region.cy,
-			cy: region.cx,
-			r: region.r
-		};
-		case "ellipse": return {
-			kind: "ellipse",
-			cx: region.cy,
-			cy: region.cx,
-			rx: region.ry,
-			ry: region.rx
-		};
-		case "polygon": {
-			const swap = (ring) => ring.map(([x, y]) => [y, x]);
-			const turned = {
-				kind: "polygon",
-				points: swap(region.points)
-			};
-			if (region.holes) turned.holes = region.holes.map(swap);
-			return turned;
-		}
+		case "rect":
+		case "circle":
+		case "ellipse": return region.kind;
+		case "polygon":
+			if (region.holes && region.holes.length > 0) return "holes";
+			return isConvex(region.points) ? "convex" : "polygon";
 	}
 }
-/** 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 = {
-		...rest,
-		w: item.h,
-		h: item.w
+/** This function gives the value of `itemShape` of one item shape. An ellipse is convex. */
+function itemShapeOf(region) {
+	if (region === void 0) return "rect";
+	switch (region.kind) {
+		case "rect":
+		case "circle": return region.kind;
+		case "ellipse": return "convex";
+		case "polygon": return !region.holes?.length && isConvex(region.points) ? "convex" : "polygon";
+	}
+}
+/**
+* This function gives the cell of an input: the values of the packer dimensions that the input tells.
+*
+* - `containerSize` comes from `fixed`. The value `none` gives `freeArea` when `aspectWeight` is 0, and `freeAspect` if not.
+* - `containerShape` comes from the shape. A rectangle container with an obstacle of another region gives `holes`.
+* - `obstacleMove` is the hardest value of the obstacles and the locked items: `costly`, then `free`, then `fixed`.
+* - `order` is `soft` when an item has a rank, and `free` if not. The input does not tell a hard order.
+* - `groups` is `nested` when an item has a parent, `flat` when an item has a group, and `none` if not.
+*/
+function cellOf(input) {
+	const { container, items } = input;
+	const obstacles = input.obstacles ?? [];
+	const containerSize = {
+		size: "fixed",
+		width: "freeHeight",
+		height: "freeWidth",
+		none: container.aspectWeight === 0 ? "freeArea" : "freeAspect"
+	}[container.fixed];
+	let containerShape = container.shape ? shapeOf$1(container.shape) : "rect";
+	if (containerShape === "rect" && obstacles.some((o) => o.region.kind !== "rect")) containerShape = "holes";
+	let obstacleMove = items.some((i) => i.locked === true) ? "fixed" : void 0;
+	for (const o of obstacles) {
+		const move = o.move === void 0 ? "fixed" : o.move.cost > 0 ? "costly" : "free";
+		if (move === "costly" || obstacleMove === void 0 || move === "free" && obstacleMove === "fixed") obstacleMove = move;
+	}
+	const shapes = new Set(items.map((i) => itemShapeOf(i.shape)));
+	const itemShape = shapes.size > 1 ? "mixed" : [...shapes][0] ?? "rect";
+	const cell = {
+		containerSize,
+		containerShape,
+		itemShape,
+		rotation: items.some((i) => i.turnable === true) ? "quarter" : "none",
+		order: items.some((i) => i.rank !== void 0) ? "soft" : "free",
+		groups: items.some((i) => i.parent !== void 0) ? "nested" : items.some((i) => i.group !== void 0) ? "flat" : "none"
 	};
-	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
+	if (obstacleMove !== void 0) cell.obstacleMove = obstacleMove;
+	return cell;
+}
+/** This function gives the first dimension of a cell that `supports` does not hold, or `undefined` when it holds each one. */
+function unsupportedOf(supports, cell) {
+	for (const dimension of Object.keys(supports)) {
+		const value = cell[dimension];
+		if (value === void 0) continue;
+		if (!supports[dimension].includes(value)) return {
+			dimension,
+			value
 		};
 	}
-	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)
-	};
-	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 tells if `supports` holds each value of a cell. A dimension that the cell does not have is held. */
+function supportsCell(supports, cell) {
+	return unsupportedOf(supports, cell) === void 0;
 }
-/** This function gives an output with the axes changed. */
-function transposeOutput(output) {
-	return {
-		placements: output.placements.map((p) => ({
-			...p,
-			x: p.y,
-			y: p.x
-		})),
-		overflow: [...output.overflow],
-		size: {
-			w: output.size.h,
-			h: output.size.w
-		},
-		moved: output.moved.map((m) => ({
-			id: m.id,
-			x: m.y,
-			y: m.x
-		})),
-		trace: output.trace
-	};
+/** This function throws `UnsupportedCell` for the first value of the cell of an input that `supports` does not hold. */
+function assertSupported(supports, input) {
+	const miss = unsupportedOf(supports, cellOf(input));
+	if (miss) throw new UnsupportedCell(miss.dimension, miss.value);
 }
+// src/adapters.ts
 /**
-* This function packs an input with a fixed height through the turn of the axes. It changes x for y in the input.
-* Then it packs with a fixed width, and changes the axes of the output back.
+* The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. The container layer of `src/space.ts`
+* gives them each container shape.
 */
-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;
-}
-// src/adapters.ts
-/** The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. */
 const LAYOUT_CELLS = {
 	containerSize: [
 		"fixed",
@@ -1716,7 +2098,14 @@ const LAYOUT_CELLS = {
 		"freeAspect",
 		"freeArea"
 	],
-	containerShape: ["rect"],
+	containerShape: [
+		"rect",
+		"convex",
+		"polygon",
+		"circle",
+		"ellipse",
+		"holes"
+	],
 	itemShape: ["rect"],
 	rotation: ["none"],
 	groups: ["none"],
@@ -1742,15 +2131,18 @@ function packFixedWidth(id, input, options) {
 	const rects = rectsOf(frame);
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
-		sortOrder: options.sortOrder
+		sortOrder: options.sortOrder,
+		space: spaceOf(input, frame)
 	});
 	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) {
@@ -1783,11 +2175,12 @@ function layoutStrategy(id, family, catalog, cells) {
 	return self;
 }
 /**
-* The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. It supports no obstacle and
-* no locked item, because `packRows` does not go around them. Turnable items, groups and shapes throw `UnsupportedCell`.
+* The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. With obstacles, locked items or a
+* container shape, the rows go around the holes of the free space and lose the gap fill. Turnable items, groups and item
+* shapes throw `UnsupportedCell`.
 */
 const rows = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
-	obstacleMove: [],
+	obstacleMove: ["fixed"],
 	order: [
 		"free",
 		"soft",
@@ -1796,7 +2189,7 @@ const rows = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
 });
 /**
 * The strategy `skyline` uses `packSkyline`: each item goes to the lowest place where it fits. It packs around the
-* locked items and the fixed obstacles. Turnable items, groups and shapes throw `UnsupportedCell`.
+* locked items and the fixed obstacles, in each container shape. Turnable items, groups and item shapes throw `UnsupportedCell`.
 */
 const skyline = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
 	obstacleMove: ["fixed"],
@@ -1804,7 +2197,7 @@ const skyline = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
 });
 /**
 * The strategy `shelf` uses `packShelf`: rows filled left to right, around the locked items and the fixed obstacles.
-* With the sort order `input`, the rows keep the rank order. Turnable items, groups and shapes throw `UnsupportedCell`.
+* With the sort order `input`, the rows keep the rank order. Turnable items, groups and item shapes throw `UnsupportedCell`.
 */
 const shelf = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
 	obstacleMove: ["fixed"],
@@ -1833,6 +2226,7 @@ const logSweep = {
 		const result = packFree(rectsOf(frame), new Rect(), {
 			strategy: id,
 			sortOrder: o.sortOrder,
+			space: spaceOf(input, frame),
 			samples: o.samples,
 			aspect: input.container.aspect ?? 1,
 			aspectWeight: input.container.aspectWeight ?? 1
@@ -1840,24 +2234,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) {
@@ -1899,9 +2295,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
@@ -1911,7 +2307,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();
@@ -1927,19 +2323,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`.
@@ -1989,31 +2387,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
+			} : {}
+		}))
 	};
 }
 /**
@@ -2068,6 +2464,15 @@ 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.
 *
@@ -2078,38 +2483,36 @@ function overlap(a, b, tolerance) {
 * - `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 not locked for these rules.
+* `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 lockedAt = item.locked === true && item.x !== void 0 && item.y !== void 0 ? {
+		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)) breaks.complete += 1;
+				if (!overflow.has(item.id)) complete += 1;
 				continue;
 			}
-			breaks["locked-kept"] += 1;
+			lockedKept += 1;
 			p = lockedAt;
 		} else if (lockedAt !== void 0) {
-			if (Math.abs(p.x - lockedAt.x) > .001 || Math.abs(p.y - lockedAt.y) > .001) breaks["locked-kept"] += 1;
+			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);
@@ -2130,18 +2533,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);
@@ -2152,12 +2554,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. */
@@ -2378,8 +2786,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) => [
@@ -3071,6 +3481,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, freeSpace, 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