@mark1russell7/packing 0.2.1 → 0.2.3

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 {
@@ -137,6 +137,32 @@ var Rect = class {
 		return rects.reduce((acc, r) => Math.max(acc, r.bottom()), 0);
 	}
 };
+// src/moves.ts
+/** The id of the characteristic move of each strategy. The trace of each strategy has its id, also with the count 0. */
+const MOVES = Object.freeze({
+	/** A rectangle that the gap fill of `packRow` places in a gap of a row: under a shorter neighbor, or at the row break. */
+	rows: "move.gapFill",
+	/** A rectangle that `packShelf` puts on an open shelf with a taller rectangle. The strip above it stays empty. */
+	shelf: "move.stack",
+	/** A rectangle that the skyline puts in a lower window, not in the leftmost window where it fits. */
+	skyline: "move.lowerWindow",
+	/** A rectangle that a push cascade moves. */
+	push: "move.cascade"
+});
+const counts = /* @__PURE__ */ new Map();
+/** This function adds `n` to the count of a move. */
+function countMove(id, n = 1) {
+	if (n > 0) counts.set(id, (counts.get(id) ?? 0) + n);
+}
+/** This function sets the count of a move to 0. Without an id, it sets each count to 0. */
+function clearMoves(id) {
+	if (id === void 0) counts.clear();
+	else counts.delete(id);
+}
+/** This function gives the count of a move since the last `clearMoves`. */
+function moveCount(id) {
+	return counts.get(id) ?? 0;
+}
 // src/order.ts
 /** This constant lists each sort order. The first one is the default. */
 const SORT_ORDERS = [
@@ -832,6 +858,7 @@ function packShelf(rects, outer, options = {}) {
 			x = firstFreeX(obstacles, 0, w, rowTop, rowTop + h);
 		}
 		if (outer.fixedSize && rowTop + h > outer.size.y) continue;
+		if (!rowEmpty && rowTop + h < rowBottom) countMove(MOVES.shelf);
 		rect.position.set(x + outer.position.x, rowTop + outer.position.y);
 		rect.wasPacked = true;
 		rowEmpty = false;
@@ -956,6 +983,14 @@ function packRowsInSpace(rects, outer, order, space) {
 * `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) {
+	const { x, y } = findWindow(skyline, width, rw, limit, rh);
+	return {
+		x,
+		y
+	};
+}
+/** This function is `lowestWindow`, and it also gives the x of the leftmost valid window. */
+function findWindow(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;
@@ -976,9 +1011,14 @@ function lowestWindow(skyline, width, rw, limit, rh = 0) {
 	}
 	return {
 		x: bestX,
-		y: bestY
+		y: bestY,
+		first: width >= rw ? 0 : -1
 	};
 }
+/** This function counts the move of the skyline: a window that is lower than the leftmost valid window. */
+function countWindow(w) {
+	if (Number.isFinite(w.y) && w.first >= 0 && w.x !== w.first) countMove(MOVES.skyline);
+}
 /** This function is `lowestWindow` with a limit for each cell. */
 function lowestLimitedWindow(skyline, limit, width, rw, rh) {
 	const high = new Int32Array(width);
@@ -989,6 +1029,7 @@ function lowestLimitedWindow(skyline, limit, width, rw, rh) {
 	let lt = 0;
 	let bestX = 0;
 	let bestY = Infinity;
+	let first = -1;
 	for (let i = 0; i < width; i++) {
 		while (ht > hh && skyline[high[ht - 1]] <= skyline[i]) ht--;
 		high[ht++] = i;
@@ -998,7 +1039,9 @@ function lowestLimitedWindow(skyline, limit, width, rw, rh) {
 		if (low[lh] <= i - rw) lh++;
 		if (i >= rw - 1) {
 			const max = skyline[high[hh]];
-			if (max < bestY && max + rh <= limit[low[lh]]) {
+			const valid = max + rh <= limit[low[lh]];
+			if (valid && first < 0) first = i - rw + 1;
+			if (max < bestY && valid) {
 				bestY = max;
 				bestX = i - rw + 1;
 			}
@@ -1006,7 +1049,8 @@ function lowestLimitedWindow(skyline, limit, width, rw, rh) {
 	}
 	return {
 		x: bestX,
-		y: bestY
+		y: bestY,
+		first
 	};
 }
 /**
@@ -1050,8 +1094,10 @@ function packSkyline(rects, outer, options = {}) {
 			y = 0;
 			for (let i = 0; i < width; i++) if (skyline[i] > y) y = skyline[i];
 		} else {
-			({x, y} = lowestWindow(skyline, width, rw));
+			const found = findWindow(skyline, width, rw);
+			({x, y} = found);
 			if (outer.fixedSize && y + rh > outer.size.y) continue;
+			countWindow(found);
 		}
 		rect.position.set(x + outer.position.x, y + outer.position.y);
 		rect.wasPacked = true;
@@ -1104,16 +1150,19 @@ function packSkylineInSpace(rects, outer, order, space) {
 			outer.size.y = Math.max(outer.size.y, y + rh);
 			continue;
 		}
-		({x, y} = lowestWindow(skyline, width, rw, limit, rh));
+		let found = findWindow(skyline, width, rw, limit, rh);
+		({x, y} = found);
 		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));
+			found = findWindow(sky, width, rw, lim, rh);
+			({x, y} = found);
 			if (!Number.isFinite(y)) continue;
 		}
+		countWindow(found);
 		rect.position.set(x + ox, y + oy);
 		rect.wasPacked = true;
 		const top = y + rh;
@@ -1126,10 +1175,19 @@ function packSkylineInSpace(rects, outer, order, space) {
 	return outer;
 }
 // src/pack.ts
+/** The depth of the calls of `packInto`. Only the outer gap fill counts its rectangles as moves. */
+let fillDepth = 0;
 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);
+	fillDepth++;
+	try {
+		pack(unpacked, region, { sortOrder: order });
+	} finally {
+		fillDepth--;
+	}
+	const placed = Rect.packed(unpacked);
+	if (fillDepth === 0) countMove(MOVES.rows, placed.length);
+	for (const r of placed) r.translateBy(offset);
 }
 function packRow(rects, outer, order) {
 	const row = [];
@@ -1187,7 +1245,7 @@ function packRows(rects, outer, options = {}) {
 	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));
+	while (!packRow(rects, outer, order)) if (fillDepth === 0) clearMoves(MOVES.rows);
 	return outer;
 }
 /**
@@ -1264,6 +1322,7 @@ function packFree(rects, outer = new Rect(), options = {}) {
 	const maxWidth = Math.max(minWidth, rowWidth);
 	const tried = [];
 	const run = (width) => {
+		clearMoves();
 		Rect.resetPacked(rects);
 		const box = new Rect();
 		box.position.setTo(outer.position);
@@ -1398,6 +1457,323 @@ function pushCascade(placed, rects, options = {}) {
 	}
 	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: 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 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 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 ?? []]);
+	}
+}
+/**
+* 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 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 Math.max(0, area);
+}
+/**
+* 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 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 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 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.
+*
+* - 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 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 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);
+	}
+	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 a lower bound of the overflow of an input: the items that no packer can place, and their area.
+*
+* - 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 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 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 (!(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 {
+		forced,
+		area,
+		free
+	};
+}
 // src/sha256.ts
 /** The round constants of SHA-256. */
 const K = new Uint32Array([
@@ -1597,53 +1973,68 @@ function toPackInput(file) {
 	};
 }
 // src/measures.ts
-const spec = (id, family, unit, direction, min, max, guard) => ({
+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 });
 /**
 * 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 the tolerance of each guard of the packer, and of the minimum effect of each measure.
+*
+* - 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.
 */
 const MEASURE_SPECS = Object.freeze({
-	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity),
-	"pack.fill": spec("pack.fill", "density", "share", "higher", 0, 1),
-	"pack.whitespace": spec("pack.whitespace", "density", "share", "lower", 0, 1),
-	"pack.aspect": spec("pack.aspect", "aspect", "ratio", "lower", 1, Infinity),
-	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity, {
+	"pack.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, {
+	"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),
-	"pack.raggedness": spec("pack.raggedness", "raggedness", "share", "lower", 0, 1),
-	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity, {
+	"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.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1, {
+	"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.overflow.forcedAreaMin": spec("pack.overflow.forcedAreaMin", "overflow", "share", "lower", 0, 1, .005),
+	"pack.overflow.excessArea": spec("pack.overflow.excessArea", "overflow", "share", "lower", 0, 1, .005),
+	"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, {
+	"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, {
+	"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),
-	"pack.search.widths": spec("pack.search.widths", "speed", "count", "lower", 0, Infinity),
-	"pack.search.ms": spec("pack.search.ms", "speed", "milliseconds", "lower", 0, Infinity)
+	"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) {
@@ -1732,6 +2123,9 @@ function traceSum(output, id) {
 * - 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.
+* - `pack.overflow.forcedAreaMin` is a lower bound of the overflow area. `pack.overflow.excessArea` is the overflow area above it.
 *
 * @example
 * ```ts
@@ -1766,6 +2160,17 @@ function measure(input, output, options = {}) {
 	}
 	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);
+	const overflowArea = itemArea > 0 ? unplacedArea / itemArea : 0;
+	const forcedAreaMin = itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0;
 	return {
 		"pack.area": hullArea,
 		"pack.fill": fill,
@@ -1775,12 +2180,27 @@ function measure(input, output, options = {}) {
 		"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.overflow": unplaced.size,
+		"pack.overflow.rate": input.items.length > 0 ? unplaced.size / input.items.length : 0,
+		"pack.overflow.area": overflowArea,
+		"pack.overflow.forced": bound.forced,
+		"pack.overflow.forcedArea": forcedAreaMin,
+		"pack.overflow.excess": Math.max(0, unplaced.size - bound.forced),
+		"pack.overflow.forcedAreaMin": forcedAreaMin,
+		"pack.overflow.excessArea": excessAreaOf(overflowArea, forcedAreaMin),
 		"pack.search.widths": traceSum(output, "pack.search.widths"),
 		"pack.search.ms": traceSum(output, "pack.search.ms")
 	};
 }
 /**
+* This function gives the overflow area above its lower bound. A value from `-AREA_NOISE` to 0 becomes 0. A value below
+* `-AREA_NOISE` stays, because it shows a bug of the bound or of the packer.
+*/
+function excessAreaOf(overflowArea, forcedAreaMin) {
+	const excess = overflowArea - forcedAreaMin;
+	return excess < 0 && excess >= -1e-9 ? 0 : excess;
+}
+/**
 * 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.
 *
@@ -2129,6 +2549,7 @@ function packFixedWidth(id, input, options) {
 	const start = now();
 	const frame = buildFrame(input);
 	const rects = rectsOf(frame);
+	clearMoves();
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
 		sortOrder: options.sortOrder,
@@ -2140,7 +2561,10 @@ function packFixedWidth(id, input, options) {
 		trace: [{
 			id,
 			ms: now() - start,
-			measures: { "pack.overflow": output.overflow.length }
+			measures: {
+				"pack.overflow": output.overflow.length,
+				[MOVES[id]]: moveCount(MOVES[id])
+			}
 		}]
 	};
 }
@@ -2246,7 +2670,10 @@ const logSweep = {
 			}, {
 				id,
 				ms: ms / runs,
-				measures: { "pack.overflow": output.overflow.length }
+				measures: {
+					"pack.overflow": output.overflow.length,
+					[MOVES[id]]: moveCount(MOVES[id])
+				}
 			}]
 		};
 	}
@@ -2282,11 +2709,12 @@ function pushFixedWidth(input, options, previous) {
 	}
 	const inPlay = frame.entries.filter((e) => !pending.includes(e)).map((e) => e.rect);
 	const maxShoves = options.maxShovesPerItem * Math.max(1, inPlay.length);
+	let cascaded = 0;
 	for (const e of positioned) {
-		pushCascade(e.rect, inPlay, {
+		cascaded += pushCascade(e.rect, inPlay, {
 			gap: 0,
 			maxShoves
-		});
+		}).length;
 		e.rect.locked = true;
 	}
 	const { bounds } = frame;
@@ -2328,7 +2756,10 @@ function pushFixedWidth(input, options, previous) {
 		trace: [{
 			id: "push",
 			ms: pushMs,
-			measures: { "pack.push.moved": moved.length }
+			measures: {
+				"pack.push.moved": moved.length,
+				[MOVES.push]: cascaded
+			}
 		}, {
 			id: "skyline",
 			ms: now() - skylineStart,
@@ -2488,8 +2919,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);
@@ -2554,11 +2989,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,