@mark1russell7/packing 0.2.4 → 0.2.6

package/src/maxrects.ts

@@ -0,0 +1,367 @@
+// The MaxRects family of roadmap item k24 (docs/PACKER.md, "The MaxRects family"). The packer keeps a list of the
+// maximal free rectangles. Each box goes to the top-left corner of one free rectangle. A rule chooses the free rectangle.
+// Then the box cuts each free rectangle that it hits into at most four parts, and the list loses each part that is in another.
+
+import { countMove, MOVES } from "./moves.ts";
+import { compareRects, type SortOrder } from "./order.ts";
+import type { Rect } from "./rect.ts";
+import { spaceParts, type FreeSpace, type FreeSpan, type SpaceRect } from "./space.ts";
+
+/**
+ * The rules of `maxrects` to choose a free rectangle for a box.
+ *
+ * - `bssf`: the best short side fit. The smaller leftover side is the smallest.
+ * - `blsf`: the best long side fit. The larger leftover side is the smallest.
+ * - `baf`: the best area fit. The leftover area is the smallest.
+ * - `bl`: the bottom-left rule. The bottom edge of the box is the highest, then the left edge is the leftmost.
+ * - `cp`: the contact point rule. The box touches the most length of the edges of the frame, the boxes and the obstacles.
+ */
+export const MAXRECTS_RULES: readonly ["bssf", "blsf", "baf", "bl", "cp"] = Object.freeze(["bssf", "blsf", "baf", "bl", "cp"] as const);
+
+/** A rule of `maxrects`: `bssf`, `blsf`, `baf`, `bl` or `cp`. `MAXRECTS_RULES` tells each rule. */
+export type MaxRectsRule = (typeof MAXRECTS_RULES)[number];
+
+/** The number of bands that the default band height gives. The default band height is the height to cut divided by this number. */
+export const MAXRECTS_BANDS = 128;
+
+/** The options of `packMaxRects` */
+export interface MaxRectsOptions {
+  /** The order of the rectangles before the packing. The default is `height-desc`. */
+  sortOrder?: SortOrder;
+  /**
+   * The free space of the container: `freeSpace` of the input. Without it, or when it is plain, the free rectangles are
+   * exact: the outer rectangle less the locked rectangles. Another space gives an inner approximation with bands.
+   */
+  space?: FreeSpace;
+  /** The rule to choose a free rectangle. The default is `bssf`. */
+  rule?: MaxRectsRule;
+  /**
+   * The largest height of a band of the approximation of a space that is not plain. The bands have equal heights. The
+   * default is the height to cut divided by `MAXRECTS_BANDS`. A fixed height cuts the height. A free height cuts to the
+   * lowest edge of the obstacles that are not rectangles.
+   */
+  bandHeight?: number;
+  /** The rectangles that can turn by 90 degrees. Without it, no rectangle turns. A locked rectangle does not turn. */
+  turnable?: ReadonlySet<unknown>;
+  /**
+   * The rectangles that the packing turned. Each call turns back the rectangles of this set first, and then it clears the
+   * set. Thus a size search can pack the same rectangles many times.
+   */
+  turned?: Set<unknown>;
+}
+
+/** A rectangle with its four edges, in the coordinates of the outer rectangle. */
+interface Box {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+}
+
+/** A place for a box: a free rectangle, the turn, and the two scores of the rule. Lower scores are better. */
+interface Choice {
+  index: number;
+  turn: boolean;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  s1: number;
+  s2: number;
+}
+
+/** The result of `runMaxRects`: the outer rectangle and the free rectangles at the end. */
+export interface MaxRectsRun<T> {
+  outer: Rect<T>;
+  /** The free rectangles at the end, in the coordinates of the rectangles. Each one is as wide as the narrowest box and as high as the lowest box. */
+  free: SpaceRect[];
+}
+
+/** This function tells if the box `a` is fully in the box `b`. */
+function inside(a: Box, b: Box): boolean {
+  return a.x0 >= b.x0 && a.y0 >= b.y0 && a.x1 <= b.x1 && a.y1 <= b.y1;
+}
+
+/**
+ * This function cuts each free rectangle that the box `b` hits into at most four parts. A part with a side less than
+ * `minW` or `minH` goes, because no box fits in it. A part that is in another rectangle of the list goes.
+ * The function gives the new list and the number of free rectangles that the box hit.
+ */
+function cut(free: Box[], b: Box, minW: number, minH: number): { free: Box[]; hits: number } {
+  const kept: Box[] = [];
+  const parts: Box[] = [];
+  let hits = 0;
+  const add = (x0: number, y0: number, x1: number, y1: number): void => {
+    if (x1 - x0 >= minW && y1 - y0 >= minH) parts.push({ x0, y0, x1, y1 });
+  };
+  for (const f of free) {
+    if (b.x0 >= f.x1 || b.x1 <= f.x0 || b.y0 >= f.y1 || b.y1 <= f.y0) {
+      kept.push(f);
+      continue;
+    }
+    hits++;
+    if (b.x0 > f.x0) add(f.x0, f.y0, b.x0, f.y1);
+    if (b.x1 < f.x1) add(b.x1, f.y0, f.x1, f.y1);
+    if (b.y0 > f.y0) add(f.x0, f.y0, f.x1, b.y0);
+    if (b.y1 < f.y1) add(f.x0, b.y1, f.x1, f.y1);
+  }
+  // Each part is in the free rectangle that it comes from. Thus a kept rectangle is never in a part.
+  const count = kept.length;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]!;
+    let drop = false;
+    for (let j = 0; j < parts.length && !drop; j++) {
+      if (j === i) continue;
+      const q = parts[j]!;
+      // Of two equal parts, the first part stays
+      if (inside(p, q) && (j < i || !inside(q, p))) drop = true;
+    }
+    for (let k = 0; k < count && !drop; k++) if (inside(p, kept[k]!)) drop = true;
+    if (!drop) kept.push(p);
+  }
+  return { free: kept, hits };
+}
+
+/** The edges of the boxes on one axis: for each coordinate, the flat list of the ranges on the other axis. */
+type Edges = Map<number, number[]>;
+
+/** This function adds a range to the edges at a coordinate. */
+function addEdge(edges: Edges, at: number, a: number, b: number): void {
+  const list = edges.get(at);
+  if (list === undefined) edges.set(at, [a, b]);
+  else list.push(a, b);
+}
+
+/** This function gives the length of the common part of the range from `a` to `b` and the edges at a coordinate. */
+function touch(edges: Edges, at: number, a: number, b: number): number {
+  const list = edges.get(at);
+  if (list === undefined) return 0;
+  let sum = 0;
+  for (let i = 0; i < list.length; i += 2) sum += Math.max(0, Math.min(b, list[i + 1]!) - Math.max(a, list[i]!));
+  return sum;
+}
+
+/**
+ * This function gives the walls of a space that is not plain: the parts of the bands that are not free. The bands cut the
+ * height from 0 to `top`. Two walls of neighbour bands with the same span become one wall.
+ */
+function bandWalls(query: (y0: number, y1: number) => FreeSpan[], w: number, top: number, bandHeight: number, grow: number, end: number): Box[] {
+  const walls: Box[] = [];
+  const count = Math.max(1, Math.ceil(top / bandHeight));
+  let open = new Map<string, Box>();
+  for (let k = 0; k < count; k++) {
+    const y0 = (top * k) / count;
+    const y1 = k === count - 1 ? top : (top * (k + 1)) / count;
+    // With a growth of the query less than 0, the band asks for a larger strip. Thus the bands cover each y of the outline.
+    const spans = query(Math.max(0, y0 - grow), Math.min(end, y1 + grow));
+    const next = new Map<string, Box>();
+    let x = 0;
+    const block = (a: number, b: number): void => {
+      if (!(b > a)) return;
+      const key = `${a}|${b}`;
+      const wall = open.get(key);
+      if (wall !== undefined) {
+        wall.y1 = y1;
+        open.delete(key);
+        next.set(key, wall);
+      } else next.set(key, { x0: a, y0, x1: b, y1 });
+    };
+    for (const s of spans) {
+      const start = Math.max(0, Math.min(w, s.start));
+      const stop = Math.max(0, Math.min(w, s.end));
+      if (!(stop > start)) continue;
+      block(x, start);
+      x = Math.max(x, stop);
+    }
+    block(x, w);
+    walls.push(...open.values());
+    open = next;
+  }
+  walls.push(...open.values());
+  return walls;
+}
+
+/**
+ * This function packs rectangles with MaxRects, as `packMaxRects` tells. It also gives the free rectangles at the end.
+ * The tests read them. The package root does not export this function.
+ */
+export function runMaxRects<T>(rects: Rect<T>[], outer: Rect<T>, options: MaxRectsOptions = {}): MaxRectsRun<T> {
+  const rule = options.rule ?? "bssf";
+  if (!(MAXRECTS_RULES as readonly string[]).includes(rule)) throw new RangeError(`The rule of maxrects is one of ${MAXRECTS_RULES.join(", ")}, not "${String(rule)}".`);
+  const turned = options.turned;
+  if (turned !== undefined) {
+    for (const r of rects) if (turned.has(r)) r.size.set(r.size.y, r.size.x);
+    turned.clear();
+  }
+  for (const r of rects) if (r.locked) r.wasPacked = true;
+
+  const W = outer.size.x;
+  if (!(W > 0)) return { outer, free: [] };
+  const ox = outer.position.x;
+  const oy = outer.position.y;
+  const fixed = outer.fixedSize;
+  const space = options.space;
+  const parts = space === undefined ? undefined : spaceParts(space);
+  const turnable = options.turnable;
+  const sorted = rects.toSorted(compareRects(options.sortOrder ?? "height-desc")).filter((r) => !r.wasPacked && r.size.x > 0 && r.size.y > 0);
+
+  // The smallest width and height of the boxes. A turnable box counts its short side for the two. A free rectangle with
+  // less room has no use, thus the list does not keep it.
+  let minW = Infinity;
+  let minH = Infinity;
+  let heights = 0;
+  for (const r of sorted) {
+    const turns = turnable?.has(r) === true;
+    const short = Math.min(r.size.x, r.size.y);
+    minW = Math.min(minW, turns ? short : r.size.x);
+    minH = Math.min(minH, turns ? short : r.size.y);
+    heights += turns ? Math.max(r.size.x, r.size.y) : r.size.y;
+  }
+
+  // The rectangle holes: the holes of the space, or the locked rectangles. The bands of another space hold its holes.
+  const holes: Box[] = [];
+  if (parts !== undefined) for (const h of parts.holes) holes.push({ x0: h.x - ox, y0: h.y - oy, x1: h.x + h.w - ox, y1: h.y + h.h - oy });
+  else if (space === undefined || space.plain) {
+    for (const r of rects) if (r.locked) holes.push({ x0: r.position.x - ox, y0: r.position.y - oy, x1: r.right() - ox, y1: r.bottom() - oy });
+  }
+
+  // A free height gets room below each obstacle for each box. The content gives the height at the end.
+  let floor = parts?.bottom ?? 0;
+  for (const h of holes) floor = Math.max(floor, h.y1);
+  const H = fixed ? outer.size.y : floor + heights;
+  const walls: Box[] = [];
+  for (const h of holes) {
+    const wall = { x0: Math.max(0, h.x0), y0: Math.max(0, h.y0), x1: Math.min(W, h.x1), y1: Math.min(H, h.y1) };
+    if (wall.x1 > wall.x0 && wall.y1 > wall.y0) walls.push(wall);
+  }
+  if (space !== undefined && !space.plain) {
+    const top = parts === undefined ? H : fixed ? H : Math.min(H, parts.bottom);
+    if (top > 0) {
+      const bandHeight = options.bandHeight ?? top / MAXRECTS_BANDS;
+      if (!(bandHeight > 0)) throw new RangeError(`The band height of maxrects is more than 0, not ${String(bandHeight)}.`);
+      const query = parts === undefined ? (y0: number, y1: number) => space.band(y0 + oy, y1 + oy) : (y0: number, y1: number) => parts.bare(y0 + oy, y1 + oy);
+      const shifted = (y0: number, y1: number): FreeSpan[] => query(y0, y1).map((s) => ({ start: s.start - ox, end: s.end - ox }));
+      walls.push(...bandWalls(shifted, W, top, bandHeight, parts === undefined ? 0 : Math.max(0, -parts.d), fixed ? H : Infinity));
+    }
+  }
+
+  let free: Box[] = [{ x0: 0, y0: 0, x1: W, y1: H }];
+  for (const wall of walls) free = cut(free, wall, minW, minH).free;
+
+  const cp = rule === "cp";
+  const vertical: Edges = new Map();
+  const horizontal: Edges = new Map();
+  const mark = (b: Box): void => {
+    if (!cp) return;
+    addEdge(vertical, b.x0, b.y0, b.y1);
+    addEdge(vertical, b.x1, b.y0, b.y1);
+    addEdge(horizontal, b.y0, b.x0, b.x1);
+    addEdge(horizontal, b.y1, b.x0, b.x1);
+  };
+  for (const wall of walls) mark(wall);
+  const contact = (x: number, y: number, w: number, h: number): number => {
+    let sum = 0;
+    if (x === 0) sum += h;
+    if (x + w === W) sum += h;
+    if (y === 0) sum += w;
+    if (fixed && y + h === H) sum += w;
+    return sum + touch(vertical, x, y, y + h) + touch(vertical, x + w, y, y + h) + touch(horizontal, y, x, x + w) + touch(horizontal, y + h, x, x + w);
+  };
+  // A space that is not plain checks each place, because the bands only approximate the outline
+  const check = space !== undefined && !space.plain;
+  let bottom = 0;
+  for (const wall of walls) bottom = Math.max(bottom, wall.y1);
+
+  for (const rect of sorted) {
+    const w = rect.size.x;
+    const h = rect.size.y;
+    const turns = turnable?.has(rect) === true && w !== h;
+    const banned = new Set<number>();
+    let best: Choice | undefined;
+    let low: Choice | undefined;
+    for (;;) {
+      best = undefined;
+      low = undefined;
+      for (let i = 0; i < free.length; i++) {
+        const f = free[i]!;
+        for (let t = 0; t < (turns ? 2 : 1); t++) {
+          if (banned.has(2 * i + t)) continue;
+          const bw = t === 1 ? h : w;
+          const bh = t === 1 ? w : h;
+          if (f.x0 + bw > f.x1 || f.y0 + bh > f.y1) continue;
+          const lw = f.x1 - f.x0 - bw;
+          const lh = f.y1 - f.y0 - bh;
+          let s1: number;
+          let s2: number;
+          switch (rule) {
+            case "bssf":
+              s1 = Math.min(lw, lh);
+              s2 = Math.max(lw, lh);
+              break;
+            case "blsf":
+              s1 = Math.max(lw, lh);
+              s2 = Math.min(lw, lh);
+              break;
+            case "baf":
+              s1 = (f.x1 - f.x0) * (f.y1 - f.y0) - bw * bh;
+              s2 = Math.min(lw, lh);
+              break;
+            case "bl":
+              s1 = f.y0 + bh;
+              s2 = f.x0;
+              break;
+            case "cp":
+              s1 = -contact(f.x0, f.y0, bw, bh);
+              s2 = f.y0 + bh;
+              break;
+          }
+          const c: Choice = { index: i, turn: t === 1, x: f.x0, y: f.y0, w: bw, h: bh, s1, s2 };
+          if (best === undefined || s1 < best.s1 || (s1 === best.s1 && (s2 < best.s2 || (s2 === best.s2 && (c.y < best.y || (c.y === best.y && c.x < best.x)))))) best = c;
+          const ly = f.y0 + bh;
+          if (low === undefined || ly < low.s1 || (ly === low.s1 && f.x0 < low.s2)) low = { ...c, s1: ly, s2: f.x0 };
+        }
+      }
+      if (best === undefined || !check || space.fits({ x: best.x + ox, y: best.y + oy, w: best.w, h: best.h })) break;
+      banned.add(2 * best.index + (best.turn ? 1 : 0));
+    }
+
+    let place: Box;
+    if (best !== undefined) {
+      place = { x0: best.x, y0: best.y, x1: best.x + best.w, y1: best.y + best.h };
+      if (rule !== "bl" && low !== undefined && (low.x !== best.x || low.y !== best.y || low.turn !== best.turn)) countMove(MOVES[rule]);
+      if (best.turn) {
+        rect.size.set(best.w, best.h);
+        turned?.add(rect);
+      }
+    } else {
+      // No free rectangle has room. A fixed size leaves the box out. A free height puts it under all others, at the left edge.
+      if (fixed) continue;
+      place = { x0: 0, y0: bottom, x1: w, y1: bottom + h };
+    }
+    rect.position.set(place.x0 + ox, place.y0 + oy);
+    rect.wasPacked = true;
+    bottom = Math.max(bottom, place.y1);
+    const result = cut(free, { x0: place.x0, y0: place.y0, x1: Math.min(W, place.x1), y1: place.y1 }, minW, minH);
+    free = result.free;
+    if (result.hits >= 2) countMove(MOVES.split);
+    mark(place);
+    if (!fixed) outer.size.y = Math.max(outer.size.y, place.y1);
+  }
+  return { outer, free: free.map((f) => ({ x: f.x0 + ox, y: f.y0 + oy, w: f.x1 - f.x0, h: f.y1 - f.y0 })) };
+}
+
+/**
+ * This function packs rectangles into an outer rectangle with MaxRects of Jylänki (2010). It keeps the list of the maximal
+ * free rectangles, and it does not change the width of the outer rectangle.
+ *
+ * - Each box goes to the top-left corner of the free rectangle that `options.rule` chooses. `MAXRECTS_RULES` tells the rules.
+ * - A tie goes to the higher place, then to the place on the left, then to the first free rectangle of the list.
+ * - A `locked` rectangle keeps its position, and the free rectangles go around it.
+ * - With a space that is not plain, the free rectangles start from bands of the outline. `MaxRectsOptions` tells the bands.
+ * - Without `fixedSize`, the height of the outer rectangle grows to the content. With `fixedSize`, a box 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.
+ */
+export function packMaxRects<T>(rects: Rect<T>[], outer: Rect<T>, options: MaxRectsOptions = {}): Rect<T> {
+  return runMaxRects(rects, outer, options).outer;
+}

package/src/moves.ts

@@ -10,6 +10,11 @@ export const MOVES: Readonly<{
   push: "move.cascade";
   firstFit: "move.firstFit";
   bestFit: "move.bestFit";
+  bssf: "move.bssf";
+  blsf: "move.blsf";
+  baf: "move.baf";
+  cp: "move.cp";
+  split: "move.split";
 }> = 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",
@@ -26,6 +31,16 @@ export const MOVES: Readonly<{
   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",
+  /** A rectangle that the rule `bssf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+  bssf: "move.bssf",
+  /** A rectangle that the rule `blsf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+  blsf: "move.blsf",
+  /** A rectangle that the rule `baf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+  baf: "move.baf",
+  /** A rectangle that the rule `cp` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+  cp: "move.cp",
+  /** A rectangle of `maxrects` that cuts two free rectangles or more. A shelf or a skyline has no such step. */
+  split: "move.split",
 });
 
 const counts = new Map<string, number>();

package/src/pack.ts

@@ -1,3 +1,4 @@
+import { packMaxRects, type MaxRectsRule } from "./maxrects.ts";
 import { clearMoves, countMove, MOVES } from "./moves.ts";
 import { compareRects, type SortOrder } from "./order.ts";
 import { Rect } from "./rect.ts";
@@ -20,12 +21,20 @@ export interface PackOptions {
 /** The options of `pack` */
 export interface PackLayoutOptions extends PackOptions {
   /**
-   * The packing: `rows` (the default), `skyline` or `shelf`. `skyline` and `shelf` pack around locked rectangles.
-   * Use `shelf` with the sort order `input` to keep the order of the array around locked rectangles.
+   * The packing: `rows` (the default), `skyline`, `shelf` or `maxrects`. `skyline`, `shelf` and `maxrects` pack around
+   * locked rectangles. Use `shelf` with the sort order `input` to keep the order of the array around locked rectangles.
    */
-  strategy?: "rows" | "skyline" | "shelf";
+  strategy?: "rows" | "skyline" | "shelf" | "maxrects";
   /** The rule of `shelf` to choose a shelf. Only `shelf` reads it. `ShelfOptions` tells it. Without it, `shelf` packs as in 0.2.3. */
   fit?: ShelfFit;
+  /** The rule of `maxrects` to choose a free rectangle. Only `maxrects` reads it. The default is `bssf`. */
+  rule?: MaxRectsRule;
+  /** The largest height of a band of `maxrects` in a space that is not plain. Only `maxrects` reads it. `MaxRectsOptions` tells it. */
+  bandHeight?: number;
+  /** The rectangles that `maxrects` can turn by 90 degrees. Only `maxrects` reads it. */
+  turnable?: ReadonlySet<unknown>;
+  /** The rectangles that `maxrects` turned. Only `maxrects` reads it. `MaxRectsOptions` tells it. */
+  turned?: Set<unknown>;
 }
 
 /** The depth of the calls of `packInto`. Only the outer gap fill counts its rectangles as moves. */
@@ -126,7 +135,7 @@ export function packRows<T>(rects: Rect<T>[], outer: Rect<T>, options: PackOptio
  *   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.
+ * - `options.strategy` selects `packRows` (the default), `packSkyline`, `packShelf` or `packMaxRects` after the width is set.
  */
 export function pack<T>(rects: Rect<T>[], outer: Rect<T> = new Rect(), options: PackLayoutOptions = {}): Rect<T> {
   let totalArea = 0;
@@ -150,6 +159,7 @@ export function pack<T>(rects: Rect<T>[], outer: Rect<T> = new Rect(), options:
   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 if (options.strategy === "maxrects") packMaxRects(rects, outer, options);
   else packRows(rects, outer, options);
 
   if (!outer.fixedSize) {

package/src/portfolio.ts

@@ -0,0 +1,103 @@
+// The portfolio of roadmap item k20, part 1 (`docs/PACKER.md`, "The portfolio"). A portfolio packs an input with each
+// member and keeps the best output by the one pick rule `selectBest` of the contract. Nothing default uses it.
+
+import { pickMoves, portfolio, type Member, type Portfolio, type PortfolioKey, type PortfolioPick, type SelectLevel } from "@mark1russell7/layout-contract";
+import { checkHard } from "./check.ts";
+import type { PackInput, PackOutput } from "./contract.ts";
+import { outputHash } from "./layout-input.ts";
+import { MEASURE_SPECS, measure, type LayoutMeasures } from "./measures.ts";
+import { packWith, strategy } from "./registry.ts";
+
+/** A member of `packPortfolio`: a strategy of the registry with some options. The id names the member in the trace. */
+export interface PortfolioEntry {
+  id: string;
+  /** The id of a strategy of the registry */
+  strategy: string;
+  /** The options of the member over the defaults of the strategy */
+  options?: unknown;
+}
+
+/** The options of `packPortfolio`. The time limit and the member limit are those of `portfolio` of the contract. */
+export interface PackPortfolioOptions {
+  /** The id of the portfolio. The default is `portfolio`. */
+  id?: string;
+  /** The seed of each member. The default is 0, as for `packWith`. */
+  seed?: number;
+  /** The time limit in milliseconds. Without it, each member runs. A cut member makes the pick not deterministic. */
+  budgetMs?: number;
+  /** The largest count of members that run */
+  maxMembers?: number;
+  /** The clock in milliseconds. The default is `performance.now`. */
+  now?: () => number;
+}
+
+/** The id of the trace stage of `packPortfolio`. Its measure `move.pick` is 1 when the pick is not member 0. */
+export const PORTFOLIO_STAGE = "portfolio";
+
+/**
+ * The levels of the pick of `packPortfolio` and of the portfolio report of the benchmark, in order. Level 0 is `hard`.
+ *
+ * - `hard`: the count of hard breaks of `checkHard` with `exactContainer`. Lower is better, with the minimum effect 0.
+ * - `pack.overflow.excessArea`: the overflow area above its bound. Lower is better.
+ * - `pack.fill`: the fill of the hull. Higher is better.
+ */
+export const PORTFOLIO_LEVELS: readonly SelectLevel[] = Object.freeze([
+  { id: "hard", spec: { direction: "lower", minEffect: 0 } },
+  { id: "pack.overflow.excessArea", spec: MEASURE_SPECS["pack.overflow.excessArea"] },
+  { id: "pack.fill", spec: MEASURE_SPECS["pack.fill"] },
+] as SelectLevel[]);
+
+/** This function gives the count of the hard breaks of an output: the sum of `checkHard` with `exactContainer`. */
+export function hardBreaks(input: PackInput, output: PackOutput): number {
+  return Object.values(checkHard(input, output, undefined, { exactContainer: true })).reduce((sum, n) => sum + n, 0);
+}
+
+/**
+ * This function makes an opt-in portfolio of strategies of the registry with `portfolio` of the contract.
+ * Its `pick(input)` packs the input with each member and gives the output of the winner, its id and the trace.
+ *
+ * - A member is a strategy id, or a `PortfolioEntry` with options. The members run in the given order.
+ * - The key is the hard breaks, then `pack.overflow.excessArea`, then `pack.fill`. `PORTFOLIO_LEVELS` gives the specs.
+ * - The hash of the key is `outputHash`. `selectBest` of the contract picks the winner.
+ * - The output of the winner gets the trace stage `portfolio` with `move.pick` of `pickMoves`.
+ * - The function throws a `RangeError` for an unknown strategy, an empty list and two members with the same id.
+ */
+export function packPortfolio(members: readonly (string | PortfolioEntry)[], options: PackPortfolioOptions = {}): Portfolio<PackInput, PackOutput> {
+  const seed = options.seed ?? 0;
+  const list: Member<PackInput, PackOutput>[] = members.map((m) => {
+    const e = typeof m === "string" ? { id: m, strategy: m } : m;
+    strategy(e.strategy);
+    return { id: e.id, run: (input: PackInput): PackOutput => packWith(e.strategy, input, e.options, seed) };
+  });
+  // Each level reads the measures of one output, so the measures of an output are computed one time
+  const cache = new WeakMap<PackOutput, LayoutMeasures>();
+  const measured = (input: PackInput, output: PackOutput): LayoutMeasures => {
+    let m = cache.get(output);
+    if (m === undefined) {
+      m = measure(input, output);
+      cache.set(output, m);
+    }
+    return m;
+  };
+  const key: PortfolioKey<PackInput, PackOutput> = {
+    hard: hardBreaks,
+    levels: PORTFOLIO_LEVELS.slice(1).map((level) => ({
+      id: level.id,
+      spec: level.spec,
+      value: (input: PackInput, output: PackOutput): number => measured(input, output)[level.id as "pack.fill" | "pack.overflow.excessArea"],
+    })),
+    hash: outputHash,
+  };
+  const limits = {
+    ...(options.budgetMs !== undefined ? { budgetMs: options.budgetMs } : {}),
+    ...(options.maxMembers !== undefined ? { maxMembers: options.maxMembers } : {}),
+    ...(options.now !== undefined ? { now: options.now } : {}),
+  };
+  const inner = portfolio(options.id ?? PORTFOLIO_STAGE, list, key, limits);
+  const pick = (input: PackInput): PortfolioPick<PackOutput> => {
+    const got = inner.pick(input);
+    const stage = { id: PORTFOLIO_STAGE, measures: { "move.pick": pickMoves(got.trace).pick } };
+    return { ...got, output: { ...got.output, trace: [...(got.output.trace ?? []), stage] } };
+  };
+  return { id: inner.id, pick, run: (input: PackInput): PackOutput => pick(input).output };
+}

package/src/registry.ts

@@ -1,9 +1,9 @@
-import { push, rows, shelf, skyline } from "./adapters.ts";
+import { maxrects, push, rows, shelf, skyline } from "./adapters.ts";
 import type { PackInput, PackOutput } from "./contract.ts";
 import { createContext, type Strategy } from "./strategy.ts";
 
 /** Each strategy of the package. The benchmark starts each one on each input of the corpus. */
-export const strategies: readonly Strategy[] = Object.freeze([rows, skyline, shelf, push] as Strategy[]);
+export const strategies: readonly Strategy[] = Object.freeze([rows, skyline, shelf, push, maxrects] as Strategy[]);
 
 /** This function gives the strategy with an id. It throws a `RangeError` for an id that the registry does not have. */
 export function strategy(id: string): Strategy {

package/src/space.ts

@@ -346,7 +346,7 @@ export function spaceOf(input: PackInput, frame: Frame): FreeSpace {
   const across = transposeLayer(layer);
 
   const band = (y0: number, y1: number): FreeSpan[] => spansOf(layer, y0, y1).map(([start, end]) => ({ start, end }));
-  return {
+  const space: FreeSpace = {
     w: frame.w,
     h: frame.h,
     plain,
@@ -368,6 +368,41 @@ export function spaceOf(input: PackInput, frame: Frame): FreeSpace {
       return nextOf(layer, y0, y1, w);
     },
   };
+  const bare: Layer = { ...layer, holes: [] };
+  let bottom = 0;
+  for (const b of blockers) bottom = Math.max(bottom, b.c1 + Math.max(0, b.g));
+  PARTS.set(space, {
+    kind: layer.kind,
+    d,
+    holes: holes.map((r) => ({ x: r.a0, y: r.c0, w: r.a1 - r.a0, h: r.c1 - r.c0 })),
+    bottom: Number.isFinite(frame.h) ? frame.h : bottom,
+    bare: (y0, y1) => spansOf(bare, y0, y1).map(([start, end]) => ({ start, end })),
+  });
+  return space;
+}
+
+/**
+ * The parts of a free space of `spaceOf`. The packer `maxrects` reads them to make its first free rectangles. The
+ * package root does not export them.
+ */
+export interface SpaceParts {
+  /** The kind of the outline: `plain`, `box`, `round` or `rings`. */
+  readonly kind: "plain" | "box" | "round" | "rings";
+  /** The growth of a query for the outline: the inset less half the gap. */
+  readonly d: number;
+  /** The rectangle holes: the locked items and the rectangle obstacles, in the coordinates of the frame. */
+  readonly holes: readonly SpaceRect[];
+  /** The height to cut into bands. A fixed height gives the height. A free height gives the lowest edge of the blockers. */
+  readonly bottom: number;
+  /** This method gives the free x-spans of the outline and the blockers from `y0` to `y1`, without the rectangle holes. */
+  bare(y0: number, y1: number): FreeSpan[];
+}
+
+const PARTS = new WeakMap<FreeSpace, SpaceParts>();
+
+/** This function gives the parts of a free space of `spaceOf`, or `undefined` for another free space. */
+export function spaceParts(space: FreeSpace): SpaceParts | undefined {
+  return PARTS.get(space);
 }
 
 /**