@mark1russell7/packing 0.1.7 → 0.2.1

package/README.md

@@ -105,7 +105,7 @@ checkHard(input, output); // { "no-overlap": 0, "in-container": 0, "locked-kept"
 - `fixed` is `size`, `width`, `height` or `none`. A fixed height turns the axes. The value `none` uses the size search `logSweep`, which wraps `packFree`.
 - Each strategy declares its cells in `supports`. `cellOf(input)` gives the cell of an input. A strategy throws `UnsupportedCell` for an input outside its cells.
 - The strategies of this version do not turn items, read groups or pack shapes. A turnable item, a group or a shape gives `UnsupportedCell`.
-- `checkHard` counts the breaks of the hard rules: `no-overlap`, `in-container`, `locked-kept` and `complete`.
+- `checkHard` counts the breaks of the hard rules: `no-overlap`, `in-container`, `locked-kept` and `complete`. It reads the true shape of each obstacle, as `packHard` of `@mark1russell7/layout-contract` does.
 - `fromRects` and `toRects` connect the interface to the `Rect` objects.
 
 `docs/PACKER.md` in the repository gives the interface in full.

package/build/index.d.ts

@@ -1,3 +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";
 /** A mutable two-dimensional vector. */
 export declare class Vector {
   #private;
@@ -79,10 +80,77 @@ type SortOrder = "height-desc" | "height-asc" | "width-desc" | "area-desc" | "in
 export declare const SORT_ORDERS: readonly SortOrder[];
 /** This function gives the comparator of a sort order. The sort is stable, so `input` keeps the order. */
 export declare function compareRects(order: SortOrder): <T>(a: Rect<T>, b: Rect<T>) => number;
+/** This function gives the margin of an item on each side. A number is the same margin on each side. */
+export declare function marginOf(item: Pick<Item$1, "margin">): Sides$1;
+/**
+ * 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 declare function turnItem(item: Item$1): Item$1;
+/** A free interval on one axis, from `start` to `end`. A box fits when it starts at `start` or later and ends at `end` or earlier. */
+interface FreeSpan {
+  readonly start: number;
+  readonly end: number;
+}
+/** A rectangle of the frame: its top-left corner and its size. */
+interface SpaceRect {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+/**
+ * The free space of one input, in the coordinates of the frame of the adapters. A rectangle of the frame is an item with its
+ * margin, grown by half the gap on each side. Each method takes such a rectangle.
+ *
+ * - The outline of a container with a fixed size is exact. A free side uses the bounding box of the shape, and the holes stay.
+ * - The inset of the container counts as in `checkHard`: the item with its margin, grown by the inset, stays in the outline.
+ * - A rectangle obstacle and a locked item are holes with the exact rectangles of the frame.
+ * - Another obstacle blocks its range over the query, grown by half the gap on each axis.
+ */
+interface FreeSpace {
+  /** The width of the area of the frame. A free side has the width `Infinity`. */
+  readonly w: number;
+  /** The height of the area of the frame. A free side has the height `Infinity`. */
+  readonly h: number;
+  /**
+   * The value `true` tells that the container is a plain rectangle and that each obstacle is a rectangle. Then `band` does
+   * not test y, and `column` does not test x, because each strategy tests the fixed side itself. This is the fast path.
+   */
+  readonly plain: boolean;
+  /** This method gives the free x-spans, from left to right, for a rectangle from `y0` to `y1`. */
+  band(y0: number, y1: number): FreeSpan[];
+  /**
+   * This method gives the first free y-span for a rectangle from `x0` to `x1` that ends after `from`. The span starts
+   * at `from` or later. The method gives `undefined` when no such span is free.
+   */
+  column(x0: number, x1: number, from?: number): FreeSpan | undefined;
+  /** This method tells if a rectangle is in the free space. */
+  fits(rect: SpaceRect): boolean;
+  /** This method gives the first x from `x` where a rectangle of width `w` fits from `y0` to `y1`, or `Infinity`. */
+  fitX(x: number, w: number, y0: number, y1: number): number;
+  /**
+   * This method gives the next top edge after `y0` where the free spans of a rectangle of the height `y1 - y0` change, or
+   * `Infinity`. A row that has no place for a rectangle of width `w` steps down to this edge.
+   */
+  nextY(y0: number, y1: number, w: number): number;
+}
+/**
+ * This function gives the free space of an input, in the coordinates of the frame of the adapters. The origin of the
+ * frame is the corner of the container, moved in by the inset and out by half the gap. `FreeSpace` tells the methods.
+ */
+export declare function freeSpace(input: PackInput): FreeSpace;
 /** The options of `pack` and `packRows` */
 interface PackOptions {
   /** 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. With a space that is not plain, each strategy packs into
+   * the outline of the container and around its holes. The rows of `packRows` also go around the locked rectangles.
+   */
+  space?: FreeSpace;
 }
 /** The options of `pack` */
 interface PackLayoutOptions extends PackOptions {
@@ -96,6 +164,9 @@ interface PackLayoutOptions extends PackOptions {
  * This function packs rectangles into an outer rectangle of a given width with a guillotine row packing. It does
  * not change the width. Without `fixedSize`, the height grows until all rectangles fit. A `locked` rectangle keeps
  * its position, but the rows do not go around it. `pack` sets the width first and then uses this function.
+ *
+ * With `options.space`, the rows go around the locked rectangles and the holes of the space, inside its outline. A space
+ * that is plain, with no locked rectangle, gives the rows of 0.1.
  */
 export declare function packRows<T>(rects: Rect<T>[], outer: Rect<T>, options?: PackOptions): Rect<T>;
 /**
@@ -113,11 +184,24 @@ export declare function pack<T>(rects: Rect<T>[], outer?: Rect<T>, options?: Pac
  * This function finds the lowest window of width `rw` on a skyline. For each `x` in `[0, width - rw]`, the height
  * of the window is the largest value of `skyline[x, x + rw)`. The first `x` with the smallest height wins. A
  * monotonic deque makes the search O(width) for one rectangle.
+ *
+ * With `limit`, a window is valid only when its height plus `rh` is not more than the smallest value of
+ * `limit[x, x + rw)`. A second deque keeps that smallest value. No valid window gives the height `Infinity`.
  */
-export declare function lowestWindow(skyline: ArrayLike<number>, width: number, rw: number): {
+export declare function lowestWindow(skyline: ArrayLike<number>, width: number, rw: number, limit?: ArrayLike<number>, rh?: number): {
   x: number;
   y: number;
 };
+/** The options of `packSkyline` */
+interface SkylineOptions {
+  /** 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 skyline uses only the
+   * outer rectangle and the locked rectangles.
+   */
+  space?: FreeSpace;
+}
 /**
  * This function packs rectangles into an outer rectangle with a skyline. It puts each rectangle in the lowest place
  * where it fits, and it does not change the width of the outer rectangle.
@@ -129,14 +213,19 @@ export declare function lowestWindow(skyline: ArrayLike<number>, width: number,
  * - Without `fixedSize`, the height of the outer rectangle grows to the content. With `fixedSize`, a rectangle 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.
+ * - With a space that is not plain, each cell gets its start and its limit from `column` of the space. The space holds
+ *   the obstacles and the locked items, thus the locked rectangles only keep their positions.
  */
-export declare function packSkyline<T>(rects: Rect<T>[], outer: Rect<T>, options?: {
-  sortOrder?: SortOrder;
-}): Rect<T>;
+export declare function packSkyline<T>(rects: Rect<T>[], outer: Rect<T>, options?: SkylineOptions): Rect<T>;
 /** The options of `packShelf` */
 interface ShelfOptions {
   /** 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 packer uses only the
+   * outer rectangle and the locked rectangles.
+   */
+  space?: FreeSpace;
 }
 /**
  * This function packs rectangles into shelves: rows that it fills left to right in the sort order, and does not fill
@@ -149,6 +238,7 @@ interface ShelfOptions {
  * - A rectangle wider than the outer rectangle goes on its own row, at the left edge, and overflows.
  * - 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.
  */
 export declare function packShelf<T>(rects: Rect<T>[], outer: Rect<T>, options?: ShelfOptions): Rect<T>;
 /** The options of `packFree` */
@@ -258,186 +348,21 @@ interface MetricsOptions {
  * ```
  */
 export declare function packingMetrics(rects: readonly Rect[], options?: MetricsOptions): PackingMetrics;
-/** A region. The forms and the rules are those of `docs/FORMAT.md`. The y axis points down. */
-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. */
-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. */
-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. */
-interface Margin {
-  top: number;
-  right: number;
-  bottom: number;
-  left: number;
-}
-/** A port on the border of an item. */
-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. */
-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`. */
-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. */
-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. */
-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. */
-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. */
-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 declare const EPS = 1e-6;
-/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
-export declare const RECORD_EPS = .001;
-/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
-export declare const DEFAULT_TOLERANCE: Readonly<Tolerance>;
-/** This function gives the margin of an item on each side. A number is the same margin on each side. */
-export declare function marginOf(item: Pick<Item, "margin">): Margin;
-/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
-export declare function turnPoint(px: number, py: number, h: number): [number, number];
-/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
-export declare function turnPort(port: Port, h: number): Port;
-/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
-export declare function turnRegion(region: Region, h: number): Region;
-/**
- * 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.
- */
-export declare function turnItem(item: Item): Item;
-/** The direction of a measure: `lower` when a lower value is better, `higher` when a higher value is better. */
-type Direction = "lower" | "higher";
 /** 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";
-/** The facts of one measure: its family, its unit, its direction and its range. */
-interface MeasureSpec {
-  id: MeasureId;
-  family: MeasureFamily;
-  unit: string;
-  direction: Direction;
-  /** The lowest value. */
-  min: number;
-  /** The highest value. The value `Infinity` tells that the measure has no upper limit. */
-  max: number;
+/**
+ * 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.
+ */
+interface MeasureSpec extends MeasureSpec$1<MeasureId> {
+  readonly family: MeasureFamily;
   /**
    * The floor is the best value of a guard measure. The floor rule of `docs/PROMOTION.md` of `highways` reads it. Each
    * guard of the packer has the floor 0. A measure without a floor has no floor rule.
    */
-  floor?: number;
+  readonly floor?: number;
   /**
    * The tolerance is the absolute tolerance at the floor. A candidate within the tolerance ties with a default at the floor.
    *
@@ -446,7 +371,7 @@ interface MeasureSpec {
    * - `pack.stability.mean` has 0.005 container widths, and `pack.stability.q95` has 0.01. The default often moves no item.
    * - `pack.stability.moved` has 0.02: 2% of the items that stay. On a small change, the default often moves no item.
    */
-  tol?: number;
+  readonly tol?: number;
 }
 /** The measures of one layout, by id. `measure` gives them. The values are not rounded. */
 interface LayoutMeasures {
@@ -528,7 +453,7 @@ export declare function roundMeasures<T extends object>(measures: T): T;
  * - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
  * - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
  */
-export declare function pairedRatio(candidate: number, current: number, direction: Direction): number;
+export declare function pairedRatio(candidate: number, current: number, direction: Direction$1): number;
 /**
  * This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
  * position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
@@ -656,18 +581,19 @@ interface PushStrategyOptions {
   maxShovesPerItem: number;
 }
 /**
- * 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 declare const rows: Strategy<LayoutStrategyOptions>;
 /**
  * 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 declare const skyline: Strategy<LayoutStrategyOptions>;
 /**
  * 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 declare const shelf: Strategy<LayoutStrategyOptions>;
 /**
@@ -703,13 +629,6 @@ export declare function strategy(id: string): Strategy;
  * context gets `mulberry32` with the seed. The default seed is 0.
  */
 export declare function packWith(id: string, input: PackInput, options?: unknown, seed?: number): PackOutput;
-/** The count of the breaks of each hard rule of the packer (`docs/FORMAT.md`). A good run has 0 for each rule. */
-interface HardBreaks {
-  "no-overlap": number;
-  "in-container": number;
-  "locked-kept": number;
-  complete: number;
-}
 /**
  * This function counts the breaks of the 4 hard rules of the packer for an output.
  *
@@ -720,52 +639,38 @@ interface HardBreaks {
  * - `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 declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): HardBreaks;
-/** An edge between two boxes. The router reads it, and the packer ignores it. */
-interface Edge {
-  id: string;
-  source: string;
-  target: string;
-  sourcePort?: string;
-  targetPort?: string;
-  /** The free data of the edge. The packer does not read it. */
-  data?: Readonly<Record<string, unknown>>;
-}
+export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): PackHard$1;
 /** The parameters of a generator: a name and a string or a number for each parameter. */
 type GeneratorParams = Record<string, string | number>;
-/** The stamp of a generated input: the generator, its version, the full parameters and the seed. */
-interface GeneratorStamp {
-  name: string;
-  version: number;
-  params: GeneratorParams;
-  seed: number;
+/**
+ * The stamp of a generated input: the generator, its version, the full parameters and the seed.
+ * It is `LayoutGenerator` of the contract with a string or a number for each parameter.
+ */
+interface GeneratorStamp extends LayoutGenerator {
+  readonly params: Readonly<GeneratorParams>;
 }
-/** One input file `layout-input/1`. `docs/FORMAT.md` gives each field. */
-interface LayoutInput {
-  schema: "layout-input/1";
-  id: string;
-  set: string;
-  family: string;
-  seed: number;
+/**
+ * A generated input file `layout-input/1`. It is a `LayoutInput` with each field that a generator writes.
+ * `docs/FORMAT.md` gives each field.
+ */
+interface GeneratedInput extends LayoutInput$1 {
+  readonly set: string;
+  readonly family: string;
+  readonly seed: number;
   /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */
-  source: string;
+  readonly source: string;
   /** The generator of a generated input. A hand-made or published input has `null`. */
-  generator: GeneratorStamp | null;
-  container: Container;
-  obstacles?: Obstacle[];
-  gap?: number;
-  boxes: Item[];
-  edges: Edge[];
-  base?: string;
-  change?: string;
-  step?: number;
+  readonly generator: GeneratorStamp | null;
+  readonly container: LayoutContainer$1;
+  readonly edges: readonly LayoutEdge$1[];
   /** The first 16 hex characters of the SHA-256 of the canonical form of the other fields. */
-  hash: string;
+  readonly hash: string;
 }
 /** The layout of the obstacles (`docs/research/TAXONOMY.md`, dimension 3). */
 type ObstacleLayout = "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
@@ -793,11 +698,14 @@ export declare function round3(x: number): number;
  */
 export declare function canonicalJson(value: unknown): string;
 /** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
-export declare function hashInput(file: Omit<LayoutInput, "hash"> | LayoutInput): string;
+export declare function hashInput(file: LayoutInput$1): string;
 /** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
 export declare function countCell(count: number): CountScale;
-/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
-export declare function toPackInput(file: Pick<LayoutInput, "container" | "boxes" | "obstacles" | "gap">): PackInput;
+/**
+ * This function gives the packing input of a file. The boxes become the items, and the edges go.
+ * A file without a container gets `{ fixed: "none" }`, so the packer picks the size. It is `toPackInput` of the contract.
+ */
+export declare function toPackInput(file: Pick<LayoutInput$1, "container" | "boxes" | "obstacles" | "gap">): PackInput;
 /** A seeded generator of `layout-input/1` files. The same version, parameters and seed give the same file, byte for byte. */
 interface CorpusGenerator<P extends GeneratorParams = GeneratorParams> {
   /** The name. The file writes it in `generator.name`. */
@@ -815,7 +723,7 @@ interface CorpusGenerator<P extends GeneratorParams = GeneratorParams> {
   /** This method gives the cell of each input of the parameters. The cell does not depend on the seed. */
   cell(params?: Partial<P>): CorpusCell;
   /** This method gives the input file of a seed. The `id` is `<set>/<family>/s<seed>`. */
-  generate(seed: number, params?: Partial<P>, set?: string): LayoutInput;
+  generate(seed: number, params?: Partial<P>, set?: string): GeneratedInput;
 }
 /** The parameters of `rect-scattered`. */
 type RectScatteredParams = {
@@ -903,12 +811,12 @@ interface CorpusManifest {
 /** A corpus: the manifest and the input files, in the order of the specs and the seeds. */
 interface Corpus {
   manifest: CorpusManifest;
-  inputs: LayoutInput[];
+  inputs: GeneratedInput[];
 }
 /**
  * This function generates a corpus from specs. Each input gets the name of the corpus as its set. The function throws a
  * `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, ChangeMeasures, Container, Corpus, CorpusCell, CorpusEntry, CorpusGenerator, CorpusManifest, CorpusSpec, CountScale, Dimension, DimensionValue, Direction, Edge, EdgeCase, EdgeCaseParams, FreeWidthOptions, FreeWidthResult, FreeWidthTry, GeneratorParams, GeneratorStamp, HardBreaks, Item, LayoutInput, LayoutMeasures, LayoutStrategyOptions, Margin, MeasureFamily, MeasureId, MeasureOptions, MeasureSpec, MetricsOptions, Obstacle, ObstacleLayout, PackContext, PackInput, PackLayoutOptions, PackOptions, PackOutput, PackingMetrics, Placement, Port, PushOptions, PushStrategyOptions, RectGridParams, RectScatteredParams, Region, ShelfOptions, SizeDistribution, SizeSearch, SortOrder, StageTrace, Strategy, Supports, Tolerance, UiParams };
+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 };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/contract.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","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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"}