@mark1russell7/packing 0.2.2 → 0.2.4

package/build/index.js

@@ -137,6 +137,39 @@ 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 and of each shelf fit. 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. With a
+	* `fit`, the move is a rectangle in the strip above a shorter rectangle of a shelf.
+	*/
+	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",
+	/** A rectangle that a shelf fit puts on a shelf that is not the open shelf. The open shelf is the last shelf that the packing opened. */
+	firstFit: "move.firstFit",
+	/** A rectangle that the fit `best` puts on a shelf that is not the first shelf where it fits. */
+	bestFit: "move.bestFit"
+});
+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 = [
@@ -749,6 +782,12 @@ function freeSpace(input) {
 	return spaceOf(input, buildFrame(input));
 }
 // src/shelf.ts
+/** This constant lists each shelf fit. */
+const SHELF_FITS = [
+	"next",
+	"first",
+	"best"
+];
 /**
 * This function gives the first x from `start` where a rectangle of width `w` crosses no obstacle in the band from
 * `top` to `bottom`.
@@ -783,8 +822,10 @@ function nextTop(obstacles, top, bottom) {
 * - 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.
+* - With `fit`, `packShelvesInSpace` packs the rectangles, in each container shape. A `fit` that is not in `SHELF_FITS` throws a `RangeError`.
 */
 function packShelf(rects, outer, options = {}) {
+	if (options.fit !== void 0) return packShelvesInSpace(rects, outer, options.sortOrder ?? "height-desc", options.fit, options.space);
 	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 = [];
@@ -832,6 +873,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;
@@ -946,6 +988,181 @@ function packRowsInSpace(rects, outer, order, space) {
 	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
 	return outer;
 }
+/**
+* This function packs rectangles into shelves with a fit: `next`, `first` or `best`. `packShelf` uses it when its
+* options have a `fit`. It sets the position of each rectangle and gives the outer rectangle.
+*
+* - A shelf opens at the bottom edge of the last shelf, at the first x where the rectangle fits in the free space.
+*   When no x fits, the shelf steps down to `nextY` of the space, as an empty row of `packRowsInSpace` does.
+* - The first rectangle of a shelf sets its height. A rectangle goes on the floor of a shelf at its cursor, or into
+*   the strip above a shorter rectangle of the shelf. The strip is the move `move.stack`.
+* - The fit `next` uses only the open shelf: the last shelf that the packing opened. The fit `first` uses the first
+*   shelf from the top where the rectangle fits. The fit `best` uses the place with the least height left over.
+* - In a shelf, the rectangle takes the place with the least height left over. A tie goes to a strip, from left to right.
+* - When no shelf has a place, the last shelf grows for a taller rectangle, if it fits. Else a new shelf opens.
+* - A rectangle wider than the outer rectangle overflows. Without `fixedSize`, it goes on a closed shelf of its own at the left edge.
+* - Each place is in the free space and crosses no locked rectangle. Without a space, the outer rectangle and the
+*   locked rectangles give the free space.
+*/
+function packShelvesInSpace(rects, outer, order, fit, space) {
+	if (!SHELF_FITS.includes(fit)) throw new RangeError(`The shelf fit "${String(fit)}" is not one of ${SHELF_FITS.join(", ")}.`);
+	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 whole = [{
+		start: 0,
+		end: Infinity
+	}];
+	const place = (start, w, top, h) => {
+		const spans = space === void 0 ? whole : 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);
+	};
+	const stepDown = (top, w, h) => Math.min(space === void 0 ? Infinity : space.nextY(top + oy, top + h + oy, w) - oy, nextTop(obstacles, top, top + h));
+	const spotsOn = (shelf, w, h, grow) => {
+		const ceiling = shelf.top + shelf.height;
+		const spots = [];
+		if (!grow) {
+			for (const strip of shelf.strips) if (w <= strip.w && strip.bottom + h <= ceiling) spots.push({
+				shelf,
+				x: strip.x,
+				y: strip.bottom,
+				left: ceiling - strip.bottom - h,
+				strip
+			});
+		}
+		const tall = grow ? h > shelf.height && shelf.top + h <= limit : h <= shelf.height;
+		if (Number.isFinite(shelf.cursor) && tall) spots.push({
+			shelf,
+			x: shelf.cursor,
+			y: shelf.top,
+			left: grow ? 0 : shelf.height - h,
+			...grow ? { grow } : {}
+		});
+		return spots.toSorted((a, b) => a.left - b.left);
+	};
+	const verify = (spot, w, h) => {
+		const x = place(spot.x, w, spot.y, h);
+		if (spot.strip !== void 0) return x === spot.x ? spot : void 0;
+		return x + w <= width ? {
+			...spot,
+			x
+		} : void 0;
+	};
+	const firstOn = (shelf, w, h) => {
+		for (const spot of spotsOn(shelf, w, h, false)) {
+			const found = verify(spot, w, h);
+			if (found !== void 0) return found;
+		}
+	};
+	const shelves = [];
+	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;
+		const open = shelves.at(-1);
+		const floor = open === void 0 ? 0 : open.top + open.height;
+		if (w > width) {
+			if (outer.fixedSize) continue;
+			let top = floor;
+			while (firstFreeX(obstacles, 0, w, top, top + h) !== 0) {
+				const next = nextTop(obstacles, top, top + h);
+				if (!Number.isFinite(next)) break;
+				top = next;
+			}
+			rect.position.set(ox, top + oy);
+			rect.wasPacked = true;
+			shelves.push({
+				top,
+				height: h,
+				cursor: Infinity,
+				strips: []
+			});
+			contentBottom = Math.max(contentBottom, top + h);
+			continue;
+		}
+		let spot;
+		let firstShelf;
+		if (fit === "best") {
+			for (const s of shelves.flatMap((shelf) => spotsOn(shelf, w, h, false)).toSorted((a, b) => a.left - b.left)) {
+				spot = verify(s, w, h);
+				if (spot !== void 0) break;
+			}
+			if (spot !== void 0) firstShelf = shelves.find((shelf) => shelf === spot.shelf || firstOn(shelf, w, h) !== void 0);
+		} else for (const shelf of fit === "next" ? shelves.slice(-1) : shelves) {
+			spot = firstOn(shelf, w, h);
+			if (spot !== void 0) break;
+		}
+		if (spot === void 0 && open !== void 0) {
+			const grown = spotsOn(open, w, h, true)[0];
+			if (grown !== void 0) spot = verify(grown, w, h);
+		}
+		if (spot === void 0) {
+			let top = floor;
+			let x = place(0, w, top, h);
+			while (!(x + w <= width) && top + h <= limit) {
+				const next = stepDown(top, w, h);
+				if (!Number.isFinite(next)) break;
+				top = next;
+				x = place(0, w, top, h);
+			}
+			if (!(x + w <= width) || top + h > limit) continue;
+			const shelf = {
+				top,
+				height: h,
+				cursor: x,
+				strips: []
+			};
+			shelves.push(shelf);
+			spot = {
+				shelf,
+				x,
+				y: top,
+				left: 0
+			};
+		} else {
+			if (spot.shelf !== open) countMove(MOVES.firstFit);
+			if (firstShelf !== void 0 && spot.shelf !== firstShelf) countMove(MOVES.bestFit);
+		}
+		const { shelf } = spot;
+		rect.position.set(spot.x + ox, spot.y + oy);
+		rect.wasPacked = true;
+		if (spot.strip !== void 0) {
+			countMove(MOVES.shelf);
+			spot.strip.bottom = spot.y + h;
+		} else {
+			shelf.cursor = spot.x + w;
+			shelf.strips.push({
+				x: spot.x,
+				w,
+				bottom: spot.y + h
+			});
+			if (spot.grow === true) shelf.height = h;
+		}
+		contentBottom = Math.max(contentBottom, spot.y + 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
@@ -956,6 +1173,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 +1201,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 +1219,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 +1229,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 +1239,8 @@ function lowestLimitedWindow(skyline, limit, width, rw, rh) {
 	}
 	return {
 		x: bestX,
-		y: bestY
+		y: bestY,
+		first
 	};
 }
 /**
@@ -1050,8 +1284,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 +1340,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 +1365,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 +1435,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 +1512,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);
@@ -1934,6 +2183,8 @@ const REL = Object.freeze({ rel: .01 });
 * - 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.
+* - `pack.overflow.forcedAreaMin` is a deprecated alias of `pack.overflow.forcedArea`. Its spec is the same, except the id.
+*   The alias stays until the next minor version.
 */
 const MEASURE_SPECS = Object.freeze({
 	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity, REL),
@@ -1959,6 +2210,8 @@ const MEASURE_SPECS = Object.freeze({
 	"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
@@ -2064,6 +2317,8 @@ function traceSum(output, id) {
 * - 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.forcedArea` is a lower bound of the overflow area. `pack.overflow.excessArea` is the overflow area above it.
+* - `pack.overflow.forcedAreaMin` is a deprecated alias of `pack.overflow.forcedArea`, with the same value.
 *
 * @example
 * ```ts
@@ -2107,6 +2362,8 @@ function measure(input, output, options = {}) {
 		if (unplaced.has(item.id)) unplacedArea += a;
 	}
 	const bound = overflowBound(input);
+	const overflowArea = itemArea > 0 ? unplacedArea / itemArea : 0;
+	const forcedArea = itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0;
 	return {
 		"pack.area": hullArea,
 		"pack.fill": fill,
@@ -2118,15 +2375,25 @@ function measure(input, output, options = {}) {
 		"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.area": overflowArea,
 		"pack.overflow.forced": bound.forced,
-		"pack.overflow.forcedArea": itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0,
+		"pack.overflow.forcedArea": forcedArea,
 		"pack.overflow.excess": Math.max(0, unplaced.size - bound.forced),
+		"pack.overflow.forcedAreaMin": forcedArea,
+		"pack.overflow.excessArea": excessAreaOf(overflowArea, forcedArea),
 		"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, forcedArea) {
+	const excess = overflowArea - forcedArea;
+	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.
 *
@@ -2470,15 +2737,28 @@ function supportsOf(cells) {
 		mode: [...cells.mode]
 	};
 }
+/** This function gives the fit of the options of a strategy: only `shelf` reads it. */
+function fitOf(id, options) {
+	return id === "shelf" && options.fit !== void 0 ? { fit: options.fit } : {};
+}
+/** This function gives the move counts of the trace of a strategy: its own move, and the moves of a shelf fit. */
+function movesOf(id, fit) {
+	const out = { [MOVES[id]]: moveCount(MOVES[id]) };
+	if (fit.fit !== void 0) for (const move of [MOVES.firstFit, MOVES.bestFit]) out[move] = moveCount(move);
+	return out;
+}
 /** This function packs an input with a fixed size or a fixed width with one strategy of `pack`. */
 function packFixedWidth(id, input, options) {
 	const start = now();
 	const frame = buildFrame(input);
 	const rects = rectsOf(frame);
+	const fit = fitOf(id, options);
+	clearMoves();
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
 		sortOrder: options.sortOrder,
-		space: spaceOf(input, frame)
+		space: spaceOf(input, frame),
+		...fit
 	});
 	const output = readFrame(input, frame, []);
 	return {
@@ -2486,7 +2766,10 @@ function packFixedWidth(id, input, options) {
 		trace: [{
 			id,
 			ms: now() - start,
-			measures: { "pack.overflow": output.overflow.length }
+			measures: {
+				"pack.overflow": output.overflow.length,
+				...movesOf(id, fit)
+			}
 		}]
 	};
 }
@@ -2544,6 +2827,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 item shapes throw `UnsupportedCell`.
+* The option `fit` selects a shelf rule of roadmap item k21: `next`, `first` or `best`. The default has no `fit`.
 */
 const shelf = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
 	obstacleMove: ["fixed"],
@@ -2569,13 +2853,15 @@ const logSweep = {
 		};
 		const start = now();
 		const frame = buildFrame(input);
+		const fit = fitOf(id, o);
 		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
+			aspectWeight: input.container.aspectWeight ?? 1,
+			...fit
 		});
 		const ms = now() - start;
 		const runs = result.tried.length + 1;
@@ -2592,7 +2878,10 @@ const logSweep = {
 			}, {
 				id,
 				ms: ms / runs,
-				measures: { "pack.overflow": output.overflow.length }
+				measures: {
+					"pack.overflow": output.overflow.length,
+					...movesOf(id, fit)
+				}
 			}]
 		};
 	}
@@ -2628,11 +2917,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;
@@ -2674,7 +2964,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,
@@ -3838,6 +4131,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, 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 };
+export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SHELF_FITS, 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