@mark1russell7/packing 0.1.7 → 0.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/packing",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "description": "Rectangle packing: shelf, guillotine and skyline strategies, push cascades and measures of a layout.",
   "keywords": [
     "rectangle-packing",
@@ -48,15 +48,18 @@
   "engines": {
     "node": ">=22.12"
   },
+  "dependencies": {
+    "@mark1russell7/layout-contract": "^0.2.1"
+  },
   "devDependencies": {
     "@mark1russell7/cue": "^1.0.2",
-    "@mark1russell7/layout-contract": "github:mark1russell7/layout-contract#710ec519027dbc122d111cc5e76a1c18877f4237&path:packages/layout-contract",
     "@types/node": "^26.6.4",
     "tsdown": "^0.23.1",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
   },
   "scripts": {
+    "bench": "node bench/main.ts",
     "build": "tsdown",
     "test": "vitest run",
     "test:watch": "vitest",

package/src/adapters.ts

@@ -8,6 +8,7 @@ import { pack } from "./pack.ts";
 import { pushCascade } from "./push.ts";
 import { Rect } from "./rect.ts";
 import { packSkyline } from "./skyline.ts";
+import { spaceOf } from "./space.ts";
 import { assertSupported, cellOf, UnsupportedCell, type PackContext, type SizeSearch, type Strategy, type Supports } from "./strategy.ts";
 
 /** The options of the strategies `rows`, `skyline` and `shelf`. */
@@ -26,10 +27,13 @@ export interface PushStrategyOptions {
   maxShovesPerItem: number;
 }
 
-/** The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. */
+/**
+ * The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. The container layer of `src/space.ts`
+ * gives them each container shape.
+ */
 const LAYOUT_CELLS = {
   containerSize: ["fixed", "freeHeight", "freeWidth", "freeAspect", "freeArea"],
-  containerShape: ["rect"],
+  containerShape: ["rect", "convex", "polygon", "circle", "ellipse", "holes"],
   itemShape: ["rect"],
   rotation: ["none"],
   groups: ["none"],
@@ -55,10 +59,9 @@ function packFixedWidth(id: "rows" | "skyline" | "shelf", input: PackInput, opti
   const start = now();
   const frame = buildFrame(input);
   const rects = rectsOf(frame);
-  if (frame.w > 0) pack(rects, outerOf(frame), { strategy: id, sortOrder: options.sortOrder });
+  if (frame.w > 0) pack(rects, outerOf(frame), { strategy: id, sortOrder: options.sortOrder, space: spaceOf(input, frame) });
   const output = readFrame(input, frame, []);
-  output.trace.push({ id, ms: now() - start, measures: { "pack.overflow": output.overflow.length } });
-  return output;
+  return { ...output, trace: [{ id, ms: now() - start, measures: { "pack.overflow": output.overflow.length } }] };
 }
 
 /** This function makes the strategy of one function of `pack`. */
@@ -92,17 +95,18 @@ function layoutStrategy(
 }
 
 /**
- * The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. It supports no obstacle and
- * no locked item, because `packRows` does not go around them. Turnable items, groups and shapes throw `UnsupportedCell`.
+ * The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. With obstacles, locked items or a
+ * container shape, the rows go around the holes of the free space and lose the gap fill. Turnable items, groups and item
+ * shapes throw `UnsupportedCell`.
  */
 export const rows: Strategy<LayoutStrategyOptions> = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
-  obstacleMove: [],
+  obstacleMove: ["fixed"],
   order: ["free", "soft", "hard"],
 });
 
 /**
  * The strategy `skyline` uses `packSkyline`: each item goes to the lowest place where it fits. It packs around the
- * locked items and the fixed obstacles. Turnable items, groups and shapes throw `UnsupportedCell`.
+ * locked items and the fixed obstacles, in each container shape. Turnable items, groups and item shapes throw `UnsupportedCell`.
  */
 export const skyline: Strategy<LayoutStrategyOptions> = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
   obstacleMove: ["fixed"],
@@ -111,7 +115,7 @@ export const skyline: Strategy<LayoutStrategyOptions> = layoutStrategy("skyline"
 
 /**
  * The strategy `shelf` uses `packShelf`: rows filled left to right, around the locked items and the fixed obstacles.
- * With the sort order `input`, the rows keep the rank order. Turnable items, groups and shapes throw `UnsupportedCell`.
+ * With the sort order `input`, the rows keep the rank order. Turnable items, groups and item shapes throw `UnsupportedCell`.
  */
 export const shelf: Strategy<LayoutStrategyOptions> = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
   obstacleMove: ["fixed"],
@@ -134,6 +138,7 @@ export const logSweep: SizeSearch = {
     const result = packFree(rectsOf(frame), new Rect<number>(), {
       strategy: id,
       sortOrder: o.sortOrder,
+      space: spaceOf(input, frame),
       samples: o.samples,
       aspect: input.container.aspect ?? 1,
       aspectWeight: input.container.aspectWeight ?? 1,
@@ -141,11 +146,13 @@ export const logSweep: SizeSearch = {
     const ms = now() - start;
     const runs = result.tried.length + 1;
     const output = readFrame(input, frame, []);
-    output.trace.push(
-      { id: "log-sweep", ms, measures: { "pack.search.widths": result.tried.length, "pack.search.ms": ms } },
-      { id, ms: ms / runs, measures: { "pack.overflow": output.overflow.length } },
-    );
-    return output;
+    return {
+      ...output,
+      trace: [
+        { id: "log-sweep", ms, measures: { "pack.search.widths": result.tried.length, "pack.search.ms": ms } },
+        { id, ms: ms / runs, measures: { "pack.overflow": output.overflow.length } },
+      ],
+    };
   },
 };
 
@@ -191,7 +198,7 @@ function pushFixedWidth(input: PackInput, options: PushStrategyOptions, previous
 
   // An obstacle that the cascade pushed out of the container or onto a locked item goes back to its start
   const { bounds } = frame;
-  const moved: PackOutput["moved"] = [];
+  const moved: { id: string; x: number; y: number }[] = [];
   for (const e of obstacles) {
     const startAt = starts.get(e)!;
     const x = e.rect.position.x + e.dx + frame.ox;
@@ -224,11 +231,13 @@ function pushFixedWidth(input: PackInput, options: PushStrategyOptions, previous
     packSkyline([...pending.map((e) => e.rect), ...kept], outerOf(frame), { sortOrder: options.sortOrder });
   }
   const output = readFrame(input, frame, [], moved);
-  output.trace.push(
-    { id: "push", ms: pushMs, measures: { "pack.push.moved": moved.length } },
-    { id: "skyline", ms: now() - skylineStart, measures: { "pack.push.replaced": pending.length, "pack.overflow": output.overflow.length } },
-  );
-  return output;
+  return {
+    ...output,
+    trace: [
+      { id: "push", ms: pushMs, measures: { "pack.push.moved": moved.length } },
+      { id: "skyline", ms: now() - skylineStart, measures: { "pack.push.replaced": pending.length, "pack.overflow": output.overflow.length } },
+    ],
+  };
 }
 
 /**

package/src/check.ts

@@ -1,13 +1,7 @@
-import { DEFAULT_TOLERANCE, marginOf, RECORD_EPS, turnItem, type Item, type PackInput, type PackOutput, type Tolerance } from "./contract.ts";
-import { boundsOf } from "./frame.ts";
+import { boundsOf, regionHitsRect, translate, type PackHard, type Rect, type Region } from "@mark1russell7/layout-contract";
+import { DEFAULT_TOLERANCE, marginOf, RECORD_EPS, turnItem, type Item, type PackInput, type PackOutput, type Placement, type Tolerance } from "./contract.ts";
 
-/** The count of the breaks of each hard rule of the packer (`docs/FORMAT.md`). A good run has 0 for each rule. */
-export interface HardBreaks {
-  "no-overlap": number;
-  "in-container": number;
-  "locked-kept": number;
-  complete: number;
-}
+export type { PackHard } from "@mark1russell7/layout-contract";
 
 /** A box with its margin: the left, top, right and bottom edges. */
 interface Box {
@@ -22,6 +16,11 @@ function overlap(a: Box, b: Box, tolerance: number): boolean {
   return Math.min(a.r, b.r) - Math.max(a.l, b.l) > tolerance && Math.min(a.b, b.b) - Math.max(a.t, b.t) > tolerance;
 }
 
+/** This function gives the box made smaller by a tolerance on each side, as a rectangle. */
+function inner(box: Box, tolerance: number): Rect {
+  return { x: box.l + tolerance, y: box.t + tolerance, w: box.r - box.l - 2 * tolerance, h: box.b - box.t - 2 * tolerance };
+}
+
 /**
  * This function counts the breaks of the 4 hard rules of the packer for an output.
  *
@@ -32,32 +31,35 @@ function overlap(a: Box, b: Box, tolerance: number): boolean {
  * - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
  *
  * A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
- * `x` or no `y` in the input is not locked for these rules.
+ * `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
  *
- * The rules read a shape of the container, of an obstacle 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.
+ * 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.
  */
-export function checkHard(input: PackInput, output: PackOutput, tolerance: Pick<Tolerance, "overlap"> = DEFAULT_TOLERANCE): HardBreaks {
+export function checkHard(input: PackInput, output: PackOutput, tolerance: Pick<Tolerance, "overlap"> = DEFAULT_TOLERANCE): PackHard {
   const tol = tolerance.overlap;
-  const placements = new Map<string, PackOutput["placements"][number]>();
+  const placements = new Map<string, Placement>();
   for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
   const overflow = new Set(output.overflow);
-  const breaks: HardBreaks = { "no-overlap": 0, "in-container": 0, "locked-kept": 0, complete: 0 };
+  let lockedKept = 0;
+  let complete = 0;
 
   const boxes: Box[] = [];
   for (const item of input.items) {
-    const lockedAt = item.locked === true && item.x !== undefined && item.y !== undefined ? { x: item.x, y: item.y } : undefined;
-    let p: Pick<PackOutput["placements"][number], "x" | "y" | "turn"> | undefined = placements.get(item.id);
+    if (item.locked === true && (item.x === undefined || item.y === undefined)) continue;
+    const lockedAt = item.locked === true ? { x: item.x!, y: item.y! } : undefined;
+    let p: Pick<Placement, "x" | "y" | "turn"> | undefined = placements.get(item.id);
     if (p === undefined) {
       if (lockedAt === undefined) {
-        if (!overflow.has(item.id)) breaks.complete += 1;
+        if (!overflow.has(item.id)) complete += 1;
         continue;
       }
       // A locked item with no placement breaks locked-kept, and it stays at its input position for the other rules
-      breaks["locked-kept"] += 1;
+      lockedKept += 1;
       p = lockedAt;
     } else if (lockedAt !== undefined) {
-      if (Math.abs(p.x - lockedAt.x) > RECORD_EPS || Math.abs(p.y - lockedAt.y) > RECORD_EPS) breaks["locked-kept"] += 1;
+      if (Math.abs(p.x - lockedAt.x) > RECORD_EPS || Math.abs(p.y - lockedAt.y) > RECORD_EPS) lockedKept += 1;
     }
     const placed: Item = p.turn === 90 ? turnItem(item) : item;
     const m = marginOf(placed);
@@ -68,15 +70,19 @@ export function checkHard(input: PackInput, output: PackOutput, tolerance: Pick<
   }
 
   const moved = new Map(output.moved.map((m) => [m.id, m]));
-  const obstacles: Box[] = (input.obstacles ?? []).map((o) => {
+  const obstacles: Region[] = (input.obstacles ?? []).map((o) => {
+    const at = moved.get(o.id);
+    if (at === undefined) return o.region;
     const b = boundsOf(o.region);
-    const at = moved.get(o.id) ?? b;
-    return { l: at.x, t: at.y, r: at.x + b.w, b: at.y + b.h };
+    return translate(o.region, at.x - b.x, at.y - b.y);
   });
 
+  let overlaps = 0;
   for (const [i, a] of boxes.entries()) {
-    for (let j = i + 1; j < boxes.length; j++) if (overlap(a, boxes[j]!, tol)) breaks["no-overlap"] += 1;
-    for (const o of obstacles) if (overlap(a, o, tol)) breaks["no-overlap"] += 1;
+    for (let j = i + 1; j < boxes.length; j++) if (overlap(a, boxes[j]!, tol)) overlaps += 1;
+    if (obstacles.length === 0) continue;
+    const rect = inner(a, tol);
+    for (const region of obstacles) if (regionHitsRect(region, rect)) overlaps += 1;
   }
 
   const { container } = input;
@@ -88,10 +94,11 @@ export function checkHard(input: PackInput, output: PackOutput, tolerance: Pick<
   const inset = container.inset ?? 0;
   const fixedW = container.fixed === "size" || container.fixed === "width";
   const fixedH = container.fixed === "size" || container.fixed === "height";
+  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) breaks["in-container"] += 1;
+    if (outX || outY) outside += 1;
   }
-  return breaks;
+  return { "no-overlap": overlaps, "in-container": outside, "locked-kept": lockedKept, complete };
 }

package/src/contract.ts

@@ -1,205 +1,43 @@
 // The data types of the Packer contract (docs/PACKER.md). They are plain data, with no class and no method.
-// The shared package `@mark1russell7/layout-contract` gets these types later. Until then, this file is a local copy.
-
-/** A region. The forms and the rules are those of `docs/FORMAT.md`. The y axis points down. */
-export type Region =
-  | { kind: "rect"; x: number; y: number; w: number; h: number }
-  | { kind: "polygon"; points: [number, number][]; holes?: [number, number][][] }
-  | { kind: "circle"; cx: number; cy: number; r: number }
-  | { kind: "ellipse"; cx: number; cy: number; rx: number; ry: number };
-
-/** The container of a packing. */
-export interface Container {
-  /** The width. Without it, the packer searches the width. */
-  w?: number;
-  /** The height. Without it, the packer searches the height. */
-  h?: number;
-  /** The sides that stay: `size` keeps `w` and `h`, `width` keeps `w`, `height` keeps `h`, and `none` searches both. */
-  fixed: "size" | "width" | "height" | "none";
-  /** The target aspect (the width divided by the height) for the value `none` of `fixed`. The default is 1. */
-  aspect?: number;
-  /** The weight of the aspect error in the objective. The value 0 gives the least area. The default is 1. */
-  aspectWeight?: number;
-  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */
-  shape?: Region;
-  /** The space between the border and the items with their margins. The default is 0. */
-  inset?: number;
-}
-
-/** An obstacle: an area that no item enters. */
-export interface Obstacle {
-  id: string;
-  region: Region;
-  /** Without it, the obstacle stays. With it, the packer can move the obstacle for `cost` times the distance. */
-  move?: { cost: number };
-}
-
-/** The margin of an item on each side. */
-export interface Margin {
-  top: number;
-  right: number;
-  bottom: number;
-  left: number;
-}
-
-/** A port on the border of an item. */
-export interface Port {
-  id: string;
-  side: "top" | "right" | "bottom" | "left";
-  /** The point on the border of the item, relative to its top-left corner. Without it, the router chooses the point. */
-  x?: number;
-  y?: number;
-}
-
-/** An item to pack. The file format names it a box. */
-export interface Item {
-  id: string;
-  w: number;
-  h: number;
-  /** The reading order. Without it, the index in the array is the rank. */
-  rank?: number;
-  group?: string;
-  parent?: string;
-  /** A shape relative to the origin of the item. Without it, the item is the rectangle `w` by `h`. */
-  shape?: Region;
-  /** A locked item keeps `x` and `y`. The packer reads it as an obstacle. */
-  locked?: boolean;
-  x?: number;
-  y?: number;
-  /** The value `true` lets the packer turn the item by 90 degrees. The default is `false`. */
-  turnable?: boolean;
-  /** A ring around the item that no other item and no route enters. The default is 0. */
-  margin?: number | Margin;
-  /** The ports. The packer keeps them, and turns them with the item. */
-  ports?: Port[];
-  /** The free data of the item. The packer does not read it, and the turn and the converters keep it. */
-  data?: Readonly<Record<string, unknown>>;
-}
-
-/** The input of a packing: a `layout-input/1` file without `edges`, with `items` for `boxes`. */
-export interface PackInput {
-  container: Container;
-  items: Item[];
-  obstacles?: Obstacle[];
-  /** The free space between two items with their margins. Routes use this space. The default is 0. */
-  gap?: number;
-}
-
-/** The position of one item after the packing. */
-export interface Placement {
-  id: string;
-  x: number;
-  y: number;
-  /** The turn: 0 or 90, only for an item with `turnable` set to `true`. */
-  turn?: 0 | 90;
-}
-
-/** The facts of one stage of a packing. */
-export interface StageTrace {
-  /** The id of the stage, for example `skyline` or `log-sweep`. */
-  id: string;
-  /** The time of the stage in milliseconds. */
-  ms: number;
-  /** The measures of the stage, by the names of `docs/FORMAT.md`. */
-  measures: Record<string, number>;
-}
-
-/** The output of a packing. The output does not change the input. */
-export interface PackOutput {
-  placements: Placement[];
-  /** The ids of the items that the packer did not place. */
-  overflow: string[];
-  /** The size of the container after the packing. For a free size, the size that the search found. */
-  size: { w: number; h: number };
-  /** The new positions of the obstacles that moved. */
-  moved: { id: string; x: number; y: number }[];
-  /** The facts of each stage, for the site and the records. */
-  trace: StageTrace[];
-}
-
-/** The tolerances of the hard rules. */
-export interface Tolerance {
-  /** The rule `no-overlap`: two boxes overlap only by more than this value. */
-  overlap: number;
-  /** The router rule that a route does not go through a box. */
-  through: number;
-}
-
-/** The tolerance for the comparison of two numbers in an engine. */
-export const EPS = 1e-6;
-
-/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
-export const RECORD_EPS = 1e-3;
-
-/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
-export const DEFAULT_TOLERANCE: Readonly<Tolerance> = Object.freeze({ overlap: 0.001, through: 0.5 });
+// Since 0.2.0, the types and the shared values come from `@mark1russell7/layout-contract`. This file adds the packer names.
+
+import { marginSides, turnBox, type Item, type Sides } from "@mark1russell7/layout-contract";
+
+export {
+  DEFAULT_TOLERANCE,
+  EPS,
+  RECORD_EPS,
+  checkInput,
+  turnPoint,
+  turnPort,
+  turnRegion,
+  type Item,
+  type LayoutContainer,
+  type Margin,
+  type Obstacle,
+  type PackInput,
+  type PackOutput,
+  type Placement,
+  type Port,
+  type Region,
+  type Side,
+  type Sides,
+  type StageTrace,
+  type Tolerance,
+} from "@mark1russell7/layout-contract";
 
 /** This function gives the margin of an item on each side. A number is the same margin on each side. */
-export function marginOf(item: Pick<Item, "margin">): Margin {
-  const m = item.margin ?? 0;
-  if (typeof m === "number") return { top: m, right: m, bottom: m, left: m };
+export function marginOf(item: Pick<Item, "margin">): Sides {
+  const m = marginSides(item.margin);
   return { top: m.top, right: m.right, bottom: m.bottom, left: m.left };
 }
 
-/** The side of a port after a turn of 90 degrees clockwise. */
-const TURNED_SIDE = { top: "right", right: "bottom", bottom: "left", left: "top" } as const;
-
-/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
-export function turnPoint(px: number, py: number, h: number): [number, number] {
-  return [h - py, px];
-}
-
-/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
-export function turnPort(port: Port, h: number): Port {
-  const turned: Port = { id: port.id, side: TURNED_SIDE[port.side] };
-  if (port.x !== undefined && port.y !== undefined) {
-    const [x, y] = turnPoint(port.x, port.y, h);
-    turned.x = x;
-    turned.y = y;
-  } else if (port.x !== undefined) {
-    // Only x is set: x becomes the new y, and the router chooses the new x
-    turned.y = port.x;
-  } else if (port.y !== undefined) {
-    // Only y is set: h - y becomes the new x, and the router chooses the new y
-    turned.x = h - port.y;
-  }
-  return turned;
-}
-
-/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
-export function turnRegion(region: Region, h: number): Region {
-  switch (region.kind) {
-    case "rect":
-      return { kind: "rect", x: h - region.y - region.h, y: region.x, w: region.h, h: region.w };
-    case "circle": {
-      const [cx, cy] = turnPoint(region.cx, region.cy, h);
-      return { kind: "circle", cx, cy, r: region.r };
-    }
-    case "ellipse": {
-      const [cx, cy] = turnPoint(region.cx, region.cy, h);
-      return { kind: "ellipse", cx, cy, rx: region.ry, ry: region.rx };
-    }
-    case "polygon": {
-      const turnRing = (ring: [number, number][]): [number, number][] => ring.map(([x, y]) => turnPoint(x, y, h));
-      const turned: Region = { kind: "polygon", points: turnRing(region.points) };
-      if (region.holes) turned.holes = region.holes.map(turnRing);
-      return turned;
-    }
-  }
-}
-
 /**
  * This function gives an item after a turn of 90 degrees clockwise, with the y axis down (decision 1 of
  * `docs/PACKER.md`). The width and the height change places. The top-left corner, the id and the other fields stay.
  * The ports, the shape and the margin turn with the item. The function does not change its argument.
+ * It is `turnBox` of the contract.
  */
 export function turnItem(item: Item): Item {
-  const turned: Item = { ...item, w: item.h, h: item.w };
-  if (item.ports) turned.ports = item.ports.map((p) => turnPort(p, item.h));
-  if (item.shape) turned.shape = turnRegion(item.shape, item.h);
-  if (item.margin !== undefined && typeof item.margin !== "number") {
-    const m = item.margin;
-    turned.margin = { top: m.left, right: m.top, bottom: m.right, left: m.bottom };
-  }
-  return turned;
+  return turnBox(item);
 }

package/src/convert.ts

@@ -10,21 +10,17 @@ import type { Rect } from "./rect.ts";
  */
 export function fromRects<T>(rects: readonly Rect<T>[], outer: Rect<T>): PackInput {
   const fixed = outer.fixedSize ? "size" : outer.fixedWidth ? "width" : "none";
-  const container: PackInput["container"] = { fixed };
-  if (fixed !== "none") container.w = outer.size.x;
-  if (fixed === "size") container.h = outer.size.y;
-  if (outer.position.x !== 0 || outer.position.y !== 0) {
-    container.shape = { kind: "rect", x: outer.position.x, y: outer.position.y, w: outer.size.x, h: outer.size.y };
-  }
-  const items = rects.map((r, i): Item => {
-    const item: Item = { id: String(i), w: r.size.x, h: r.size.y };
-    if (r.locked) {
-      item.locked = true;
-      item.x = r.position.x;
-      item.y = r.position.y;
-    }
-    return item;
-  });
+  const container: PackInput["container"] = {
+    fixed,
+    ...(fixed === "none" ? {} : { w: outer.size.x }),
+    ...(fixed === "size" ? { h: outer.size.y } : {}),
+    ...(outer.position.x !== 0 || outer.position.y !== 0
+      ? { shape: { kind: "rect", x: outer.position.x, y: outer.position.y, w: outer.size.x, h: outer.size.y } as const }
+      : {}),
+  };
+  const items = rects.map(
+    (r, i): Item => ({ id: String(i), w: r.size.x, h: r.size.y, ...(r.locked ? { locked: true, x: r.position.x, y: r.position.y } : {}) }),
+  );
   return { container, items };
 }
 

package/src/corpus.ts

@@ -1,7 +1,7 @@
 // The manifest of a corpus: `layout-corpus/1` of `docs/FORMAT.md`.
 
 import { generator } from "./generators.ts";
-import type { CorpusCell, GeneratorParams, LayoutInput } from "./layout-input.ts";
+import type { CorpusCell, GeneratedInput, GeneratorParams } from "./layout-input.ts";
 
 /** One spec of a corpus: a generator, its parameters and its seeds. */
 export interface CorpusSpec {
@@ -34,7 +34,7 @@ export interface CorpusManifest {
 /** A corpus: the manifest and the input files, in the order of the specs and the seeds. */
 export interface Corpus {
   manifest: CorpusManifest;
-  inputs: LayoutInput[];
+  inputs: GeneratedInput[];
 }
 
 /**
@@ -43,7 +43,7 @@ export interface Corpus {
  */
 export function corpus(name: string, specs: readonly CorpusSpec[]): Corpus {
   const manifest: CorpusManifest = { schema: "layout-corpus/1", corpus: name, specs: [], inputs: [] };
-  const inputs: LayoutInput[] = [];
+  const inputs: GeneratedInput[] = [];
   const ids = new Set<string>();
   for (const spec of specs) {
     const gen = generator(spec.generator);