@mark1russell7/packing 0.2.0 → 0.2.2

package/build/index.js

@@ -1,4 +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";
+import { DEFAULT_TOLERANCE, EPS, RECORD_EPS, boundsOf, boundsOf as boundsOf$1, checkInput, marginSides, rectInRegion, regionHitsRect, translate, turnBox, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
 // src/vector.ts
 /** A mutable two-dimensional vector. */
 var Vector = class Vector {
@@ -156,1427 +156,2286 @@ 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;
-		}
-		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);
+	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 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);
+	return {
+		w: Number.isFinite(frame.bounds.w) ? frame.bounds.w : right,
+		h: Number.isFinite(frame.bounds.h) ? frame.bounds.h : bottom
+	};
 }
-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);
+/** 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)
+			};
 		}
 	}
-	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 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
+		} }
+	};
+}
+/** 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 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.
+* 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 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);
+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 (a > s) out.push([s, a]);
+		if (e > b) out.push([b, e]);
 	}
-	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 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];
+		}
+		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 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 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 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;
+/** 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]] : [];
 		}
-		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);
+		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;
 		}
 	}
-	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;
-		}
+}
+/** 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);
 	}
-	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;
+	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 spans;
+}
+/** 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;
 		}
 	}
-	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 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 {
-		outer,
-		area,
-		fill: area > 0 ? itemArea / area : 0,
-		aspect: h > 0 ? w / h : 0,
-		aspectError: aspectError(w, h, target),
-		objective: chosen?.objective ?? 0,
-		tried
+		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
+			};
+		})
 	};
 }
-// 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) {
+/** This function makes a blocker of a region in the frame. */
+function blockerOf(region, g) {
+	const box = boundsOf(region);
 	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)
+		region,
+		g,
+		c0: box.y,
+		c1: box.y + box.h
 	};
 }
 /**
-* 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 and its frame. The adapters use it with the frame that they pack.
+* `freeSpace` makes the frame itself.
 */
-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
+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;
+		}
+		const r = e.rect;
+		holes.push({
+			a0: r.position.x,
+			a1: r.right(),
+			c0: r.position.y,
+			c1: r.bottom()
+		});
+	}
+	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
 	};
+	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 {
-		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
+		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 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 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 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];
+	return x;
 }
-// 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 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.
-* It is `turnBox` of the contract.
+* 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) {
-	return turnBox(item);
-}
-// 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;
+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);
+	}
+	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;
 		}
-		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;
+		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 hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+	return outer;
 }
-// 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 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;
 }
-/** 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;
+// 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);
+		}
+	}
+	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);
+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;
 }
-/** 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 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);
+	}
+	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 outer;
 }
-/** 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/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 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.
+* 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 toPackInput(file) {
+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;
+		}
+	}
+	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 {
-		container: file.container ?? { fixed: "none" },
-		items: file.boxes,
-		...file.obstacles === void 0 ? {} : { obstacles: file.obstacles },
-		...file.gap === void 0 ? {} : { gap: file.gap }
+		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)
 	};
 }
-// 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 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.
 */
-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
+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
 	};
-	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 {
+		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));
+}
+/**
+* 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 });
+* ```
+*/
+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;
+		}
+	}
+	return [...moved];
+}
+// src/overflow.ts
+/** This function gives the area of a ring by the shoelace formula. The direction of the ring does not count. */
+function ringArea(ring) {
+	let sum = 0;
+	for (let i = 0; i < ring.length; i++) {
+		const a = ring[i];
+		const b = ring[(i + 1) % ring.length];
+		sum += a[0] * b[1] - b[0] * a[1];
 	}
+	return Math.abs(sum) / 2;
+}
+/**
+* This function gives the area of a region that an item cannot use. A polygon loses the area of its holes. Thus a hole
+* that is out of the polygon makes the area too small, and the free area stays an upper bound.
+*/
+function blockedArea(region) {
+	switch (region.kind) {
+		case "rect": return Math.max(0, region.w) * Math.max(0, region.h);
+		case "circle": return Math.PI * region.r ** 2;
+		case "ellipse": return Math.PI * region.rx * region.ry;
+		case "polygon": {
+			let area = ringArea(region.points);
+			for (const hole of region.holes ?? []) area -= ringArea(hole);
+			return Math.max(0, area);
+		}
+	}
+}
+/** This function tells if the insides of two rectangles have a common point. Two rectangles with a common edge do not. */
+function boxesOverlap(a, b) {
+	return Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x) > 0 && Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > 0;
+}
+/** This function tells if rectangle `a` is in rectangle `b`. */
+function boxIn(a, b) {
+	return a.x >= b.x && a.y >= b.y && a.x + a.w <= b.x + b.w && a.y + a.h <= b.y + b.h;
+}
+/** This function gives the rectangle made smaller by `d` on each side. */
+function shrink(b, d) {
 	return {
-		x: left,
-		y: top,
-		w: right - left,
-		h: bottom - top
+		x: b.x + d,
+		y: b.y + d,
+		w: Math.max(0, b.w - 2 * d),
+		h: Math.max(0, b.h - 2 * d)
+	};
+}
+/** This function tells if a point is in a ring, by the even-odd rule. */
+function pointInRing(x, y, ring) {
+	let inside = false;
+	for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+		const [xi, yi] = ring[i];
+		const [xj, yj] = ring[j];
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+/** This function tells if a segment has a part of a length above 0 in the open rectangle. The Liang-Barsky clip gives it. */
+function segmentHitsBox(ax, ay, bx, by, r) {
+	let t0 = 0;
+	let t1 = 1;
+	const dx = bx - ax;
+	const dy = by - ay;
+	const clip = (p, q) => {
+		if (p === 0) return q > 0;
+		const t = q / p;
+		if (p < 0) {
+			if (t > t1) return false;
+			if (t > t0) t0 = t;
+		} else {
+			if (t < t0) return false;
+			if (t < t1) t1 = t;
+		}
+		return true;
 	};
+	return clip(-dx, ax - r.x) && clip(dx, r.x + r.w - ax) && clip(-dy, ay - r.y) && clip(dy, r.y + r.h - ay) && t1 > t0;
 }
 /**
-* 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.
+* This function tells if a rectangle is in a polygon with holes. No edge of a ring crosses the inside of the rectangle.
+* No vertex is in it, and its center is in the polygon by the even-odd rule.
 */
-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
+function boxInPolygon(b, rings) {
+	for (const ring of rings) for (let i = 0; i < ring.length; i++) {
+		const p = ring[i];
+		const q = ring[(i + 1) % ring.length];
+		if (p[0] > b.x && p[0] < b.x + b.w && p[1] > b.y && p[1] < b.y + b.h) return false;
+		if (segmentHitsBox(p[0], p[1], q[0], q[1], b)) return false;
+	}
+	const cx = b.x + b.w / 2;
+	const cy = b.y + b.h / 2;
+	let inside = false;
+	for (const ring of rings) if (pointInRing(cx, cy, ring)) inside = !inside;
+	return inside;
+}
+/** This function tells if a rectangle is in a region of a container. A rectangle with no size is in no region. */
+function boxInShape(b, shape) {
+	if (!(b.w > 0 && b.h > 0)) return false;
+	const s = shrink(b, 1e-9 * Math.max(1, b.w, b.h));
+	switch (shape.kind) {
+		case "rect": return boxIn(b, {
+			x: shape.x,
+			y: shape.y,
+			w: shape.w,
+			h: shape.h
 		});
+		case "circle":
+		case "ellipse": {
+			const rx = shape.kind === "circle" ? shape.r : shape.rx;
+			const ry = shape.kind === "circle" ? shape.r : shape.ry;
+			const inside = (x, y) => ((x - shape.cx) / rx) ** 2 + ((y - shape.cy) / ry) ** 2 <= 1;
+			return inside(s.x, s.y) && inside(s.x + s.w, s.y) && inside(s.x, s.y + s.h) && inside(s.x + s.w, s.y + s.h);
+		}
+		case "polygon": return boxInPolygon(s, [shape.points, ...shape.holes ?? []]);
 	}
-	return rows;
 }
 /**
-* 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 gives the area of a container shape. A hole counts only when its bounding box is in the outer ring.
+* Also, that box has no common point with the box of a hole before it. Thus the area is not too small.
 */
-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 shapeArea(shape) {
+	if (shape.kind !== "polygon") return blockedArea(shape);
+	let area = ringArea(shape.points);
+	const kept = [];
+	for (const hole of shape.holes ?? []) {
+		const box = boundsOf({
+			kind: "polygon",
+			points: hole
 		});
+		if (!boxInPolygon(shrink(box, 1e-9 * Math.max(1, box.w, box.h)), [shape.points])) continue;
+		if (kept.some((k) => boxesOverlap(k, box))) continue;
+		kept.push(box);
+		area -= ringArea(hole);
 	}
-	return boxes;
+	return Math.max(0, area);
 }
 /**
-* 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 area of the union of rectangles, each cut to the rectangle `clip`. A sweep over the x edges
+* adds the merged y intervals of each slab.
 */
-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;
+function unionArea(boxes, clip) {
+	const cut = [];
+	for (const b of boxes) {
+		const x0 = Math.max(b.x, clip.x);
+		const y0 = Math.max(b.y, clip.y);
+		const x1 = Math.min(b.x + b.w, clip.x + clip.w);
+		const y1 = Math.min(b.y + b.h, clip.y + clip.h);
+		if (x1 > x0 && y1 > y0) cut.push({
+			x: x0,
+			y: y0,
+			w: x1 - x0,
+			h: y1 - y0
+		});
+	}
+	const xs = [...new Set(cut.flatMap((b) => [b.x, b.x + b.w]))].toSorted((a, b) => a - b);
+	let area = 0;
+	for (let i = 0; i + 1 < xs.length; i++) {
+		const left = xs[i];
+		const right = xs[i + 1];
+		const spans = cut.filter((b) => b.x <= left && b.x + b.w >= right).map((b) => [b.y, b.y + b.h]).toSorted((p, q) => p[0] - q[0]);
+		let covered = 0;
+		let top = -Infinity;
+		let bottom = -Infinity;
+		for (const [s, e] of spans) if (s > bottom) {
+			covered += bottom - top > 0 ? bottom - top : 0;
+			top = s;
+			bottom = e;
+		} else bottom = Math.max(bottom, e);
+		covered += bottom - top > 0 ? bottom - top : 0;
+		area += covered * (right - left);
+	}
+	return area;
+}
+/** This function gives the rectangle of the container: the bounding box of its shape, or 0, 0, `w`, `h`. */
+function containerBox(input) {
+	const { container } = input;
+	if (container.shape !== void 0) return boundsOf(container.shape);
+	return {
+		x: 0,
+		y: 0,
+		w: container.w ?? Infinity,
+		h: container.h ?? Infinity
+	};
 }
-/** 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 tells if an item is locked at a position. Such an item is not a candidate of the overflow. */
+const lockedAt = (item) => item.locked === true && item.x !== void 0 && item.y !== void 0;
+/** This function gives the rectangle of an item at its position: the bounding box of its shape, or its size. */
+function itemBox(item) {
+	const s = item.shape === void 0 ? {
+		x: 0,
+		y: 0,
+		w: item.w,
+		h: item.h
+	} : boundsOf(item.shape);
+	return {
+		x: (item.x ?? 0) + s.x,
+		y: (item.y ?? 0) + s.y,
+		w: s.w,
+		h: s.h
+	};
+}
+/** This function gives the smallest area of an item: its rectangle, or the area of its shape when that is smaller. */
+function itemArea(item) {
+	const rect = Math.max(0, item.w) * Math.max(0, item.h);
+	return item.shape === void 0 ? rect : Math.min(rect, blockedArea(item.shape));
 }
 /**
-* 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 gives an upper bound of the free area of a container with a fixed size. The bound ignores the gap and
+* the margins, thus it is not too small.
 *
-* @example
-* ```ts
-* const m = measure(input, packWith("shelf", input));
-* m["pack.fill"]; // the area of the boxes divided by the area of the hull
-* ```
+* - The container area is the inner rectangle (the container less the inset). A shape gives the smaller of that and its exact area.
+* - A rectangle container loses the exact union of the fixed rectangle obstacles and the locked items in the inner rectangle.
+* - A shape loses only the regions that are fully in it and in the inner rectangle, with no common point between their boxes.
+* - An obstacle with `move` can go out of the way. Thus the bound does not subtract it.
 */
-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;
+function freeAreaBound(input) {
+	const inner = shrink(containerBox(input), input.container.inset ?? 0);
+	if (!(inner.w > 0 && inner.h > 0)) return 0;
+	const blocked = [];
+	for (const o of input.obstacles ?? []) if (o.move === void 0) blocked.push({
+		region: o.region,
+		box: boundsOf(o.region)
+	});
+	for (const item of input.items) {
+		if (!lockedAt(item)) continue;
+		const box = itemBox(item);
+		blocked.push({
+			region: {
+				kind: "rect",
+				...box
+			},
+			box
+		});
 	}
-	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 shape = input.container.shape;
+	const innerArea = inner.w * inner.h;
+	const inInner = (b) => b.w > 0 && b.h > 0 && boxIn(b, inner);
+	if (shape === void 0 || shape.kind === "rect") {
+		const rects = blocked.filter((b) => b.region.kind === "rect");
+		let free = innerArea - unionArea(rects.map((b) => b.box), inner);
+		const kept = [];
+		for (const b of blocked) {
+			if (b.region.kind === "rect" || !inInner(b.box)) continue;
+			if (rects.some((r) => boxesOverlap(r.box, b.box)) || kept.some((k) => boxesOverlap(k, b.box))) continue;
+			kept.push(b.box);
+			free -= blockedArea(b.region);
+		}
+		return Math.max(0, free);
 	}
-	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")
-	};
+	let free = Math.min(innerArea, shapeArea(shape));
+	const kept = [];
+	for (const b of blocked) {
+		if (!inInner(b.box) || !boxInShape(b.box, shape) || kept.some((k) => boxesOverlap(k, b.box))) continue;
+		kept.push(b.box);
+		free -= blockedArea(b.region);
+	}
+	return Math.max(0, free);
 }
 /**
-* 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.
+* This function gives a lower bound of the overflow of an input: the items that no packer can place, and their area.
 *
-* - 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.
+* - The candidates are the items that are not locked at a position.
+* - A fixed side forces each candidate that is longer than the side less the inset, in each turn that the item permits.
+* - A fixed size also forces the fewest other candidates that make the rest fit the free area of `freeAreaBound`. These are the largest ones.
+* - The area of the bound is the area of the long items, plus the part of the area of the rest above the free area.
+* - The margins and the gap do not count. A slack of the overlap tolerance along the edge of each candidate keeps the bound valid.
+* - A container with no fixed side gives 0.
 */
-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;
+function overflowBound(input) {
+	const { container } = input;
+	const fixedW = container.fixed === "size" || container.fixed === "width";
+	const fixedH = container.fixed === "size" || container.fixed === "height";
+	if (!fixedW && !fixedH) return {
+		forced: 0,
+		area: 0,
+		free: Infinity
 	};
-	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);
+	const tol = DEFAULT_TOLERANCE.overlap;
+	const bounds = containerBox(input);
+	const inset = container.inset ?? 0;
+	const maxW = fixedW ? bounds.w - 2 * inset + 2 * tol : Infinity;
+	const maxH = fixedH ? bounds.h - 2 * inset + 2 * tol : Infinity;
+	let forced = 0;
+	let area = 0;
+	let slack = 0;
+	const rest = [];
+	for (const item of input.items) {
+		if (lockedAt(item)) continue;
+		const box = itemBox(item);
+		const w = Math.min(item.w, box.w);
+		const h = Math.min(item.h, box.h);
+		const fits = w <= maxW && h <= maxH || item.turnable === true && h <= maxW && w <= maxH;
+		const a = itemArea(item);
+		if (!fits) {
+			forced += 1;
+			area += a;
+			continue;
+		}
+		rest.push(a);
+		slack += 2 * tol * (Math.max(0, w) + Math.max(0, h));
 	}
-	if (distances.length === 0) return {
-		"pack.stability.moved": 0,
-		"pack.stability.mean": 0,
-		"pack.stability.q95": 0
+	if (!(fixedW && fixedH)) return {
+		forced,
+		area,
+		free: Infinity
 	};
+	const free = freeAreaBound(input);
+	const room = free + slack + 2 * tol * (Math.max(0, bounds.w) + Math.max(0, bounds.h));
+	let sum = rest.reduce((s, a) => s + a, 0);
+	area += Math.max(0, sum - room);
+	for (const a of rest.toSorted((p, q) => q - p)) {
+		if (sum <= room || !(a > 0)) break;
+		sum -= a;
+		forced += 1;
+	}
 	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)
+		forced,
+		area,
+		free
 	};
 }
+// 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);
+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 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 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 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 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 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 packing input of a file. The boxes become the items, and the edges go.
+* A file without a container gets `{ fixed: "none" }`, so the packer picks the size. It is `toPackInput` of the contract.
+*/
+function toPackInput(file) {
+	return {
+		container: file.container ?? { fixed: "none" },
+		items: file.boxes,
+		...file.obstacles === void 0 ? {} : { obstacles: file.obstacles },
+		...file.gap === void 0 ? {} : { gap: file.gap }
+	};
 }
-// src/metrics.ts
+// src/measures.ts
+const spec = (id, family, unit, direction, min, max, minEffect, guard) => ({
+	id,
+	family,
+	unit,
+	direction,
+	min,
+	max,
+	...minEffect === void 0 ? {} : { minEffect },
+	...guard
+});
+/** The minimum effect of an area or a ratio of lengths: 1% of the larger value. */
+const REL = Object.freeze({ rel: .01 });
 /**
-* 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.
+* 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, and of the minimum effect of each measure.
 *
-* @example
-* ```ts
-* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
-* ```
+* - A count and a share of counts have the minimum effect 0. Thus each change of a count is an effect.
+* - A share of an area from 0 to 1 has 0.005. A guard has its tolerance.
+* - An area and a ratio of lengths have `{ rel: 0.01 }`: 1% of the larger value.
+* - The time has no minimum effect, because the times of CI change each time.
 */
-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 MEASURE_SPECS = Object.freeze({
+	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity, REL),
+	"pack.fill": spec("pack.fill", "density", "share", "higher", 0, 1, .005),
+	"pack.whitespace": spec("pack.whitespace", "density", "share", "lower", 0, 1, .005),
+	"pack.aspect": spec("pack.aspect", "aspect", "ratio", "lower", 1, Infinity, REL),
+	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity, .01, {
+		floor: 0,
+		tol: .01
+	}),
+	"pack.order.inversions": spec("pack.order.inversions", "order", "share", "lower", 0, 1, 0, {
+		floor: 0,
+		tol: 0
+	}),
+	"pack.order.breaks": spec("pack.order.breaks", "order", "count", "lower", 0, Infinity, 0),
+	"pack.raggedness": spec("pack.raggedness", "raggedness", "share", "lower", 0, 1, .005),
+	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity, 0, {
+		floor: 0,
+		tol: 0
+	}),
+	"pack.overflow.rate": spec("pack.overflow.rate", "overflow", "share", "lower", 0, 1, 0),
+	"pack.overflow.area": spec("pack.overflow.area", "overflow", "share", "lower", 0, 1, .005),
+	"pack.overflow.forced": spec("pack.overflow.forced", "overflow", "count", "lower", 0, Infinity, 0),
+	"pack.overflow.forcedArea": spec("pack.overflow.forcedArea", "overflow", "share", "lower", 0, 1, .005),
+	"pack.overflow.excess": spec("pack.overflow.excess", "overflow", "count", "lower", 0, Infinity, 0),
+	"pack.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1, .02, {
+		floor: 0,
+		tol: .02
+	}),
+	"pack.stability.mean": spec("pack.stability.mean", "stability", "container widths", "lower", 0, Infinity, .005, {
+		floor: 0,
+		tol: .005
+	}),
+	"pack.stability.q95": spec("pack.stability.q95", "stability", "container widths", "lower", 0, Infinity, .01, {
+		floor: 0,
+		tol: .01
+	}),
+	"pack.deterministic": spec("pack.deterministic", "determinism", "boolean", "higher", 0, 1, 0),
+	"pack.search.widths": spec("pack.search.widths", "speed", "count", "lower", 0, Infinity, 0),
+	"pack.search.ms": spec("pack.search.ms", "speed", "milliseconds", "lower", 0, Infinity, void 0)
+});
+/** 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.
+* - The overflow measures count each id once. `pack.overflow.forced` is the lower bound of `overflowBound`.
+* - `pack.overflow.excess` is the overflow less the forced overflow. A container with no fixed side gives 0 for both.
+*
+* @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;
+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 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"
+	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;
+	const unplaced = new Set(output.overflow);
+	let itemArea = 0;
+	let unplacedArea = 0;
+	for (const item of input.items) {
+		const a = Math.max(0, item.w) * Math.max(0, item.h);
+		itemArea += a;
+		if (unplaced.has(item.id)) unplacedArea += a;
+	}
+	const bound = overflowBound(input);
+	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": unplaced.size,
+		"pack.overflow.rate": input.items.length > 0 ? unplaced.size / input.items.length : 0,
+		"pack.overflow.area": itemArea > 0 ? unplacedArea / itemArea : 0,
+		"pack.overflow.forced": bound.forced,
+		"pack.overflow.forcedArea": itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0,
+		"pack.overflow.excess": Math.max(0, unplaced.size - bound.forced),
+		"pack.search.widths": traceSum(output, "pack.search.widths"),
+		"pack.search.ms": traceSum(output, "pack.search.ms")
 	};
-	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 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);
 	}
-}
-/** 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 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.`);
+	if (distances.length === 0) return {
+		"pack.stability.moved": 0,
+		"pack.stability.mean": 0,
+		"pack.stability.q95": 0
+	};
 	return {
-		x: shape?.x ?? 0,
-		y: shape?.y ?? 0,
-		w: fixedW ? w : Infinity,
-		h: fixedH ? h : Infinity
+		"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 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 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 + EPS || rect.size.y > h + EPS) {
-			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;
 	}
-	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 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 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)
-			};
-		}
-	}
-}
-/** 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;
+/** This function makes the context of one packing from a seed. */
+function createContext(seed = 0, more = {}) {
 	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
-		} }
+		...more,
+		seed,
+		rng: mulberry32(seed)
 	};
 }
-/** 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 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 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 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 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 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.
+* 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 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 ?? []]
+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/adapters.ts
-/** The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. */
+/**
+* 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.
+*/
 const LAYOUT_CELLS = {
 	containerSize: [
 		"fixed",
@@ -1585,7 +2444,14 @@ const LAYOUT_CELLS = {
 		"freeAspect",
 		"freeArea"
 	],
-	containerShape: ["rect"],
+	containerShape: [
+		"rect",
+		"convex",
+		"polygon",
+		"circle",
+		"ellipse",
+		"holes"
+	],
 	itemShape: ["rect"],
 	rotation: ["none"],
 	groups: ["none"],
@@ -1611,7 +2477,8 @@ 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, []);
 	return {
@@ -1654,11 +2521,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",
@@ -1667,7 +2535,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"],
@@ -1675,7 +2543,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"],
@@ -1704,6 +2572,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
@@ -1965,8 +2834,12 @@ function inner(box, tolerance) {
 * The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
 * The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
 * shape is relative to the position of the item. The result has no tolerance in it.
+*
+* With `options.exactContainer`, a shaped container with the size `fixed` also uses its true outline for `in-container`.
+* A box then counts when `rectInRegion` of the contract tells that it is not in the shape, as in `packHard`.
+* For that test, the box grows by the inset and becomes smaller by `tolerance.overlap` on each side. The default is `false`.
 */
-function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
+function checkHard(input, output, tolerance = DEFAULT_TOLERANCE, options = {}) {
 	const tol = tolerance.overlap;
 	const placements = /* @__PURE__ */ new Map();
 	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
@@ -2031,11 +2904,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";
+	const exact = options.exactContainer === true && container.fixed === "size" ? container.shape : void 0;
 	let outside = 0;
 	for (const box of boxes) {
 		const outX = fixedW && (box.l < x + inset - tol || box.r > x + w - inset + tol);
 		const outY = fixedH && (box.t < y + inset - tol || box.b > y + h - inset + tol);
 		if (outX || outY) outside += 1;
+		else if (exact !== void 0 && !rectInRegion(exact, inner({
+			l: box.l - inset,
+			t: box.t - inset,
+			r: box.r + inset,
+			b: box.b + inset
+		}, tol))) outside += 1;
 	}
 	return {
 		"no-overlap": overlaps,
@@ -2958,6 +3838,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, checkInput, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, measure, measureChange, medianRatio, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
+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