@mark1russell7/packing 0.2.1 → 0.2.2

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_TOLERANCE, Direction, Direction as Direction$1, EPS, Item, Item as Item$1, LayoutContainer, LayoutContainer as LayoutContainer$1, LayoutEdge, LayoutEdge as LayoutEdge$1, LayoutGenerator, LayoutInput, LayoutInput as LayoutInput$1, Margin, MeasureSpec as MeasureSpec$1, Obstacle, PackHard, PackHard as PackHard$1, PackInput, PackOutput, Placement, Port, RECORD_EPS, Region, Side, Sides, Sides as Sides$1, StageTrace, Tolerance, checkInput, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
+import { ContainerTest, ContainerTest as ContainerTest$1, DEFAULT_TOLERANCE, Direction, Direction as Direction$1, EPS, Item, Item as Item$1, LayoutContainer, LayoutContainer as LayoutContainer$1, LayoutEdge, LayoutEdge as LayoutEdge$1, LayoutGenerator, LayoutInput, LayoutInput as LayoutInput$1, Margin, MeasureSpec as MeasureSpec$1, Obstacle, PackHard, PackHard as PackHard$1, PackInput, PackOutput, Placement, Port, RECORD_EPS, Region, Side, Sides, Sides as Sides$1, StageTrace, Tolerance, checkInput, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
 /** A mutable two-dimensional vector. */
 export declare class Vector {
   #private;
@@ -351,7 +351,7 @@ export declare function packingMetrics(rects: readonly Rect[], options?: Metrics
 /** The family of a measure. Each family has a section in `docs/MEASURES.md`. */
 type MeasureFamily = "density" | "aspect" | "order" | "raggedness" | "overflow" | "stability" | "determinism" | "speed";
 /** The id of a measure of the packer. The ids are those of `docs/FORMAT.md`, and `highways` uses the same ids. */
-type MeasureId = "pack.area" | "pack.fill" | "pack.whitespace" | "pack.aspect" | "pack.aspectError" | "pack.order.inversions" | "pack.order.breaks" | "pack.raggedness" | "pack.overflow" | "pack.stability.moved" | "pack.stability.mean" | "pack.stability.q95" | "pack.deterministic" | "pack.search.widths" | "pack.search.ms";
+type MeasureId = "pack.area" | "pack.fill" | "pack.whitespace" | "pack.aspect" | "pack.aspectError" | "pack.order.inversions" | "pack.order.breaks" | "pack.raggedness" | "pack.overflow" | "pack.overflow.rate" | "pack.overflow.area" | "pack.overflow.forced" | "pack.overflow.forcedArea" | "pack.overflow.excess" | "pack.stability.moved" | "pack.stability.mean" | "pack.stability.q95" | "pack.deterministic" | "pack.search.widths" | "pack.search.ms";
 /**
  * The facts of one measure: its family, its unit, its direction and its range.
  * It is `MeasureSpec` of the contract for a packer measure id, with a family.
@@ -384,6 +384,11 @@ interface LayoutMeasures {
   "pack.order.breaks": number;
   "pack.raggedness": number;
   "pack.overflow": number;
+  "pack.overflow.rate": number;
+  "pack.overflow.area": number;
+  "pack.overflow.forced": number;
+  "pack.overflow.forcedArea": number;
+  "pack.overflow.excess": number;
   "pack.search.widths": number;
   "pack.search.ms": number;
 }
@@ -403,7 +408,12 @@ interface MeasureOptions {
 }
 /**
  * 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.
  */
 export declare const MEASURE_SPECS: Readonly<Record<MeasureId, MeasureSpec>>;
 /**
@@ -413,6 +423,8 @@ export declare const MEASURE_SPECS: Readonly<Record<MeasureId, MeasureSpec>>;
  * - 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
@@ -644,8 +656,12 @@ export declare function packWith(id: string, input: PackInput, options?: unknown
  * 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`.
  */
-export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): PackHard$1;
+export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">, options?: ContainerTest$1): PackHard$1;
 /** The parameters of a generator: a name and a string or a number for each parameter. */
 type GeneratorParams = Record<string, string | number>;
 /**
@@ -818,5 +834,5 @@ interface Corpus {
  * `RangeError` for an unknown generator, a different version or 2 inputs with the same id.
  */
 export declare function corpus(name: string, specs: readonly CorpusSpec[]): Corpus;
-export { type Cell, type ChangeMeasures, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
+export { type Cell, type ChangeMeasures, type ContainerTest, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","ContainerTest","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}

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 {
@@ -1398,6 +1398,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 +1914,66 @@ 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.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 +2062,8 @@ 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.
 *
 * @example
 * ```ts
@@ -1766,6 +2098,15 @@ 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);
 	return {
 		"pack.area": hullArea,
 		"pack.fill": fill,
@@ -1775,7 +2116,12 @@ 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": 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")
 	};
@@ -2488,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);
@@ -2554,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,