@mark1russell7/highways 0.3.0 → 0.4.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -41,6 +41,8 @@
     "bench:join": "node scripts/bench-join.ts",
     "profile": "node scripts/profile.ts",
     "levels": "node scripts/levels.ts",
+    "screen": "node scripts/screen.ts",
+    "screen:inputs": "node scripts/screen-inputs.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"
   }

package/src/bench/compare.ts

@@ -1,9 +1,12 @@
 import type { CurveSegment } from "../curves/model.ts";
+import { polylineLength } from "../geom.ts";
 import type { Graph, Result } from "../model.ts";
 import type { Section } from "../sections.ts";
+import { runKey, segmentsOf } from "../segments.ts";
 import { STRATEGIES } from "../strategies/builtins.ts";
-import { asRouter, getStrategy, listStrategies, type Registry, type Step } from "../strategies/model.ts";
+import { asRouter, getStrategy, listStrategies, type LaneBoard, type Registry, type Step } from "../strategies/model.ts";
 import { peakCurvature } from "./curves.ts";
+import { measureLevelFaults, sumFaults } from "./links.ts";
 import { paretoFront, type Objective } from "./measures/pareto.ts";
 import { boardUnit } from "./measures/routes.ts";
 import { changeGraph, routeStability } from "./measures/stability.ts";
@@ -20,8 +23,30 @@ function medianOf(values: readonly number[]): number {
   return a === b ? a : (a + b) / 2;
 }
 
-/** The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list. */
-export type CompareStep = Exclude<Step, "room">;
+/**
+ * This function gives the measures of the level links of a result: the links through a box (`Z3.through`) and the length of all links (`Z3.length`).
+ * A result without a level with groups gives no measure.
+ */
+function levelLinkMeasures(result: Result): Record<string, number> {
+  const levels = (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1));
+  if (levels.length === 0) return {};
+  const length = levels.reduce((sum, l) => sum + l.links.reduce((s, k) => s + polylineLength(k.points), 0), 0);
+  return { "Z3.through": sumFaults(measureLevelFaults(result)).through, "Z3.length": length };
+}
+
+/** This function gives the lanes of a result with each shared segment open. A result without shared segments gives `undefined`. */
+function laneBoard(result: Result, lanes: { readonly width: number; readonly maxWidth?: number }): LaneBoard | undefined {
+  const graph = segmentsOf(result);
+  const open = new Set(graph.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  if (open.size === 0) return undefined;
+  return { graph, open, width: lanes.width, ...(lanes.maxWidth === undefined ? {} : { maxWidth: lanes.maxWidth }) };
+}
+
+/**
+ * The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list.
+ * The step `highway` gives a plan, not routes. The screen routes each plan with `follow` and compares it as a router.
+ */
+export type CompareStep = Exclude<Step, "room" | "highway">;
 
 /** The steps that `compareStep` compares, in the order of the pipeline. */
 export const COMPARE_STEPS: readonly CompareStep[] = ["group", "router", "curve"];
@@ -34,6 +59,11 @@ export interface CompareOptions {
   readonly options?: Readonly<Record<string, object>>;
   /** The router whose routes the step `curve` draws. The default is `corners`, as in `runSuite`. */
   readonly curveRouter?: string;
+  /**
+   * With this value, the step `curve` opens each shared segment of the routes of `curveRouter`, and each curve draws the lanes of `laneRoutes`.
+   * So the curve `highway` bends the lanes of a bundle as one. Without it, each curve draws the routes. A router without shared segments gives the routes in both cases.
+   */
+  readonly lanes?: { readonly width: number; readonly maxWidth?: number };
   /** The seed of the small change of the graph for the stability measures (Z10 and G9). The default is 1. */
   readonly seed?: number;
   /** The route stability (Z10) routes a changed graph again, so the function measures it only up to this number of nodes. The default is 1000. */
@@ -50,7 +80,10 @@ export interface CompareRow {
   readonly violations: number;
   /** The time of the step, in milliseconds. For the step `router`, it is the median of two routes. */
   readonly ms: number;
-  /** The measures, by the keys of `runSuite`, and `ms`. The step `router` adds `ink`, and the step `curve` adds `C5.peak`. */
+  /**
+   * The measures, by the keys of `runSuite`, and `ms`. The step `router` adds `ink`, and the step `curve` adds `C5.peak`.
+   * A router with zoom levels also gets `Z3.through` and `Z3.length`, the measures of its level links.
+   */
   readonly values: Readonly<Record<string, number>>;
   /** The reason when the strategy did not run, for example a graph over its `maxNodes`. */
   readonly skipped?: string;
@@ -79,7 +112,7 @@ export interface StepComparison {
 
 /**
  * This function runs each strategy of one step on one graph and measures it with the measures of `runSuite`. Then it gives the Pareto front.
- * The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve.
+ * The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve, or their lanes with the option `lanes`.
  * The step `group` routes the graph with `sections` on the tree of each grouping rule.
  *
  * The same graph and the same options give the same measures. Only the times change.
@@ -98,7 +131,7 @@ export function compareStep(step: CompareStep, graph: Graph, options: CompareOpt
       if (graph.nodes.length > (strategy.maxNodes ?? Infinity)) return { step, strategy: strategy.name, violations: 0, ms: 0, values: {}, skipped: `over ${strategy.maxNodes} nodes` };
       const router = asRouter(strategy, own[strategy.name]);
       const { row, result } = benchRun(router, name, graph, 2);
-      const values: Record<string, number> = { ...routeMeasures(graph, result, row), ink: row.quality.ink, ms: row.ms };
+      const values: Record<string, number> = { ...routeMeasures(graph, result, row), ...levelLinkMeasures(result), ink: row.quality.ink, ms: row.ms };
       if (change) {
         const s = routeStability(graph, result, router.route(change.graph), { seed });
         values["Z10.mean"] = s.mean;
@@ -111,11 +144,13 @@ export function compareStep(step: CompareStep, graph: Graph, options: CompareOpt
     const router = asRouter(getStrategy(registry, "router", options.curveRouter ?? "corners"));
     const result = router.route(graph);
     const u = boardUnit(graph);
+    const lanes = options.lanes && laneBoard(result, options.lanes);
     const runs = curveRuns(graph, result, listStrategies(registry, "curve"), {
       ...at,
       smooth: new Set(["rounded", "arc", "spline", "smooth", "clothoid", "highway"]),
       normals: new Set(["spline"]),
       curveOptions: own,
+      ...(lanes ? { lanes } : {}),
     });
     rows = runs.map(({ row, drawn, edges }): CompareRow => {
       const peaks = drawn.map((d) => peakCurvature(d) * u);

package/src/bench/screen/forms.ts

@@ -0,0 +1,372 @@
+import type { Edge, Graph, Node, Port, Side } from "../../model.ts";
+import { documentHash, round3 } from "./hash.ts";
+
+/** The side of a port in an input file. The router calls the same sides `north`, `east`, `south` and `west`. */
+export type LayoutSide = "top" | "right" | "bottom" | "left";
+
+/** A port of a box in an input file. */
+export interface LayoutPort {
+  readonly id: string;
+  /** The side of the box. Without it and without `x` and `y`, the router picks the side. */
+  readonly side?: LayoutSide;
+  /** The fixed place of the port, from the top-left corner of the box. The router does not move a port with `x` and `y`. */
+  readonly x?: number;
+  readonly y?: number;
+}
+
+/** A point of a region: `[x, y]`. The y axis points down. */
+export type RegionPoint = readonly [number, number];
+
+/**
+ * An area of the plane. The y axis points down. A ring of a polygon closes itself: its last point joins its first point.
+ * A hole of a polygon does not touch the outer ring. The router reads only the bounding box of a region.
+ */
+export type Region =
+  | { readonly kind: "rect"; readonly x: number; readonly y: number; readonly w: number; readonly h: number }
+  | { readonly kind: "polygon"; readonly points: readonly RegionPoint[]; readonly holes?: readonly (readonly RegionPoint[])[] }
+  | { readonly kind: "circle"; readonly cx: number; readonly cy: number; readonly r: number }
+  | { readonly kind: "ellipse"; readonly cx: number; readonly cy: number; readonly rx: number; readonly ry: number };
+
+/** An area that the boxes and the routes must not use. The router uses the bounding box of its region as a box without edges. */
+export interface LayoutObstacle {
+  readonly id: string;
+  readonly region: Region;
+  /** The cost to move the obstacle. Only the packer reads it. */
+  readonly move?: { readonly cost: number };
+}
+
+/** A box of an input file. */
+export interface LayoutBox {
+  readonly id: string;
+  readonly w: number;
+  readonly h: number;
+  /** The position of the top-left corner. The packer writes it. The router reads it. */
+  readonly x?: number;
+  readonly y?: number;
+  /** The id of the box that holds this box. */
+  readonly parent?: string;
+  /** The group of the box. */
+  readonly group?: string;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
+  readonly locked?: true;
+  /** The reading order that the caller wants. The router ignores it. */
+  readonly rank?: number;
+  readonly ports?: readonly LayoutPort[];
+  /** The shape of the box, relative to the top-left corner of the box. The router ignores it and uses `w` and `h` as the bounding box. */
+  readonly shape?: Region;
+  /** The free data of the node. The grouping rule `keys` reads `data.group`. */
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+/** An edge of an input file. `sourcePort` and `targetPort` name a port of the box at that end. */
+export interface LayoutEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+  readonly sourcePort?: string;
+  readonly targetPort?: string;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+/** The change of a variant against its base input. */
+export type LayoutChange = "add" | "remove" | "resize" | "reorder" | "packed";
+
+/** The origin of an input: `made-up`, `published:<set>` or `known-best:<construction>`. */
+export type LayoutSource = "made-up" | `published:${string}` | `known-best:${string}`;
+
+/** The generator of an input. The same name, version, parameters and seed give the same file, byte for byte. */
+export interface LayoutGenerator {
+  readonly name: string;
+  readonly version: number;
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly seed: number;
+}
+
+/**
+ * The cell of an input in the taxonomy of the corpus, with one value for each dimension.
+ * The packer reads the first six dimensions. The router reads the last four.
+ */
+export interface LayoutCell {
+  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
+  readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
+  readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
+  readonly count?: "1" | "10" | "100" | "1k" | "10k";
+  readonly mode?: "offline" | "online" | "incremental";
+  readonly edgeDensity?: "sparse" | "medium" | "dense";
+  readonly edgeShape?: "random" | "clustered" | "hubChain" | "longRange" | "tree" | "bundled";
+  readonly groups?: "none" | "flat" | "nested";
+  readonly ports?: "free" | "sides" | "fixed";
+}
+
+/** The outer rectangle of a packing. The router ignores it. */
+export interface LayoutContainer {
+  readonly w?: number;
+  readonly h?: number;
+  /** `none`: the packer picks the size. `width`: the width stays. `height`: the height stays. `size`: the width and the height stay. */
+  readonly fixed: "none" | "width" | "height" | "size";
+  /** The ratio `w / h` that the packer aims for. */
+  readonly aspect?: number;
+  /** The shape of the container. */
+  readonly shape?: Region;
+}
+
+/** The identity of an input in a set: the set, the family, the seed, and the base of a variant. */
+export interface LayoutInputHead {
+  /** The id: `<set>/<family>/s<seed>`. */
+  readonly id: string;
+  readonly set: string;
+  readonly family: string;
+  readonly seed: number;
+  /** The id of the base input of a variant. The stability measures compare the run on the variant with the run on its base. */
+  readonly base?: string;
+  readonly change?: LayoutChange;
+  /** The place of the input in a change sequence. */
+  readonly step?: number;
+  /** The generator of the input. The default is `null`: a hand-made input. */
+  readonly generator?: LayoutGenerator | null;
+  /** The origin of the input. The default is `made-up`. */
+  readonly source?: LayoutSource;
+  readonly cell?: LayoutCell;
+}
+
+/**
+ * An input file of the form `layout-input/1`. The packer and the router read the same files.
+ * The file `docs/LAYOUT-RECORDS.md` gives the form. The repository `packing` keeps a twin of that document.
+ */
+export interface LayoutInput extends LayoutInputHead {
+  readonly schema: "layout-input/1";
+  /** The origin of the input. The data of this repository is made-up, because the repository is public. */
+  readonly source: LayoutSource;
+  /** The generator of the input, or `null` for a hand-made input. */
+  readonly generator: LayoutGenerator | null;
+  /** The first 16 hex characters of the SHA-256 of the canonical file without this field. `documentHash` calculates it. */
+  readonly hash: string;
+  readonly container?: LayoutContainer;
+  /** The space between two boxes. The router ignores it. */
+  readonly gap?: number;
+  /** The areas that the boxes and the routes must not use. */
+  readonly obstacles?: readonly LayoutObstacle[];
+  readonly boxes: readonly LayoutBox[];
+  readonly edges: readonly LayoutEdge[];
+}
+
+/** One run of one strategy on one input and one seed: a line of the form `layout-record/1`. */
+export interface LayoutRecord {
+  readonly schema: "layout-record/1";
+  /** `pack`, `route` or `joint`. The screen of this package writes `route`. */
+  readonly stage: "pack" | "route" | "joint";
+  readonly step: string;
+  readonly strategy: string;
+  /** The options of the run: the defaults of the strategy with the options of the caller. A function is the text `function:<name>`. */
+  readonly options: Readonly<Record<string, unknown>>;
+  /** The corpus version, for example `screen-v1`. */
+  readonly corpus: string;
+  /** The id of the input. */
+  readonly input: string;
+  /** The `hash` of the input file. */
+  readonly inputHash: string;
+  readonly set: string;
+  readonly seed: number;
+  readonly nodes: number;
+  readonly edges: number;
+  /** The measures, by the names of `MEASURES`. A measure without a finite value is not in the record. */
+  readonly measures: Readonly<Record<string, number>>;
+  /** The count of the breaks of each hard rule. A good run has 0 for each rule. */
+  readonly hard: Readonly<Record<string, number>>;
+  /** The tolerance of each hard rule of the run, for example `{ through: 0.5 }`. */
+  readonly tolerance?: Readonly<Record<string, number>>;
+  /** This value is `true` when two runs on the same input give the same output. */
+  readonly deterministic: boolean;
+  /** The id of the prediction of this run, from the predictions file. */
+  readonly prediction?: string;
+  /** The time of the run, in milliseconds. Only the times of CI compare. */
+  readonly ms: number;
+  /** The commit of the code that made the record. */
+  readonly commit?: string;
+  /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */
+  readonly skipped?: string;
+}
+
+/** The comparison of a prediction. Without it, `<=` applies to a measure where lower is better, and `>=` to the other measures. */
+export type PredictionOp = "<" | "<=" | "=" | ">=" | ">";
+
+/** A prediction about a run: one line of a predictions file. A commit adds the file before the run starts. */
+export interface LayoutPrediction {
+  readonly schema?: "layout-prediction/1";
+  readonly id: string;
+  readonly strategy: string;
+  readonly set: string;
+  /** The id of one input. Without it, the prediction is about the median of the measure over the set. */
+  readonly input?: string;
+  /** The name of the measure, from `MEASURES`. */
+  readonly measure: string;
+  readonly expected: number;
+  readonly op?: PredictionOp;
+  readonly reason: string;
+}
+
+const TO_FILE: Readonly<Record<Side, LayoutSide>> = { north: "top", east: "right", south: "bottom", west: "left" };
+const TO_MODEL: Readonly<Record<LayoutSide, Side>> = { top: "north", right: "east", bottom: "south", left: "west" };
+
+/** This function gives the side of a box that holds a point, relative to the top-left corner of the box. */
+function sideAt(p: { x: number; y: number }, w: number, h: number): LayoutSide {
+  const d: [LayoutSide, number][] = [
+    ["top", Math.abs(p.y)],
+    ["right", Math.abs(w - p.x)],
+    ["bottom", Math.abs(h - p.y)],
+    ["left", Math.abs(p.x)],
+  ];
+  return d.reduce((a, b) => (b[1] < a[1] ? b : a))[0];
+}
+
+/** This function gives 0 for -0, because JSON writes -0 as 0. Then a file and the graph that it comes from hold the same numbers. */
+const num = round3;
+
+function portToFile(p: Port, n: Node): LayoutPort {
+  const side = p.side ? TO_FILE[p.side] : p.at ? sideAt(p.at, n.box.w, n.box.h) : undefined;
+  return { id: p.id, ...(side ? { side } : {}), ...(p.at ? { x: num(p.at.x), y: num(p.at.y) } : {}) };
+}
+
+function portToModel(p: LayoutPort): Port {
+  if (p.x !== undefined && p.y !== undefined) return { id: p.id, at: { x: p.x, y: p.y } };
+  return { id: p.id, ...(p.side ? { side: TO_MODEL[p.side] } : {}) };
+}
+
+/**
+ * This function writes a graph as an input file of the form `layout-input/1`, with its hash.
+ * A fixed plug gets `x`, `y` and the side that holds it. `inputGraph` reads the file back.
+ */
+export function graphInput(graph: Graph, head: LayoutInputHead): LayoutInput {
+  const boxes = graph.nodes.map(
+    (n): LayoutBox => ({
+      id: n.id,
+      w: num(n.box.w),
+      h: num(n.box.h),
+      x: num(n.box.x),
+      y: num(n.box.y),
+      ...(n.ports ? { ports: n.ports.map((p) => portToFile(p, n)) } : {}),
+      ...(n.data ? { data: n.data } : {}),
+    }),
+  );
+  const edges = graph.edges.map(
+    (e): LayoutEdge => ({
+      id: e.id,
+      source: e.source.node,
+      target: e.target.node,
+      ...(e.source.port !== undefined ? { sourcePort: e.source.port } : {}),
+      ...(e.target.port !== undefined ? { targetPort: e.target.port } : {}),
+      ...(e.data ? { data: e.data } : {}),
+    }),
+  );
+  const body = {
+    schema: "layout-input/1" as const,
+    id: head.id,
+    set: head.set,
+    family: head.family,
+    seed: head.seed,
+    ...(head.base !== undefined ? { base: head.base } : {}),
+    ...(head.change !== undefined ? { change: head.change } : {}),
+    ...(head.step !== undefined ? { step: head.step } : {}),
+    source: head.source ?? "made-up",
+    generator: head.generator ?? null,
+    ...(head.cell !== undefined ? { cell: head.cell } : {}),
+    boxes,
+    edges,
+  };
+  return { ...body, hash: documentHash(body) };
+}
+
+/**
+ * This function gives the bounding box of a region: the smallest box that holds it.
+ */
+export function regionBounds(region: Region): { x: number; y: number; w: number; h: number } {
+  if (region.kind === "rect") return { x: region.x, y: region.y, w: region.w, h: region.h };
+  if (region.kind === "circle") return { x: region.cx - region.r, y: region.cy - region.r, w: 2 * region.r, h: 2 * region.r };
+  if (region.kind === "ellipse") return { x: region.cx - region.rx, y: region.cy - region.ry, w: 2 * region.rx, h: 2 * region.ry };
+  const xs = region.points.map((p) => p[0]);
+  const ys = region.points.map((p) => p[1]);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, w: Math.max(...xs) - x, h: Math.max(...ys) - y };
+}
+
+/**
+ * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
+ * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
+ * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
+ * A box without `x` and `y` is an error.
+ */
+export function inputGraph(input: LayoutInput): Graph {
+  const nodes = input.boxes.map((b): Node => {
+    if (b.x === undefined || b.y === undefined) throw new Error(`The box "${b.id}" of the input "${input.id}" has no position. The router needs a placed input.`);
+    return { id: b.id, box: { x: b.x, y: b.y, w: b.w, h: b.h }, ...(b.ports ? { ports: b.ports.map(portToModel) } : {}), ...(b.data ? { data: b.data } : {}) };
+  });
+  for (const o of input.obstacles ?? []) nodes.push({ id: o.id, box: regionBounds(o.region) });
+  const edges = input.edges.map(
+    (e): Edge => ({
+      id: e.id,
+      source: { node: e.source, ...(e.sourcePort !== undefined ? { port: e.sourcePort } : {}) },
+      target: { node: e.target, ...(e.targetPort !== undefined ? { port: e.targetPort } : {}) },
+      ...(e.data ? { data: e.data } : {}),
+    }),
+  );
+  return { nodes, edges };
+}
+
+/**
+ * This function writes an input file as text: the keys in sorted order, and one box or one edge on each line.
+ * `JSON.parse` of the text gives the input again.
+ */
+export function formatInput(input: LayoutInput): string {
+  const o = input as unknown as Record<string, unknown>;
+  const keys = Object.keys(o)
+    .filter((k) => o[k] !== undefined)
+    .sort();
+  const lines = keys.map((k) => {
+    const v = o[k];
+    if (Array.isArray(v)) return `  ${JSON.stringify(k)}: [${v.length === 0 ? "]" : `\n${v.map((x) => `    ${canonical(x)}`).join(",\n")}\n  ]`}`;
+    return `  ${JSON.stringify(k)}: ${canonical(v)}`;
+  });
+  return `{\n${lines.join(",\n")}\n}\n`;
+}
+
+/** This function writes a value as canonical JSON with a space after each colon and comma, for a line of a file. */
+function canonical(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonical).join(", ")}]`;
+  const o = value as Record<string, unknown>;
+  const keys = Object.keys(o)
+    .filter((k) => o[k] !== undefined)
+    .sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}: ${canonical(o[k])}`).join(", ")}}`;
+}
+
+/** This function writes records as JSON Lines: one record on each line. */
+export function recordLines(records: readonly LayoutRecord[]): string {
+  return records.map((r) => JSON.stringify(r) + "\n").join("");
+}
+
+/** This function reads JSON Lines. It ignores an empty line. */
+export function parseLines<T>(text: string): T[] {
+  return text
+    .split(/\r?\n/)
+    .filter((l) => l.trim().length > 0)
+    .map((l) => JSON.parse(l) as T);
+}
+
+/**
+ * This function gives a copy of a value that JSON keeps.
+ * A function becomes the text `function:<name>`, and a number that is not finite becomes its text.
+ */
+export function jsonSafe(value: unknown): unknown {
+  if (typeof value === "function") return `function:${(value as { name?: string }).name || "anonymous"}`;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(jsonSafe);
+  if (value instanceof Set) return [...value].map(jsonSafe);
+  if (value instanceof Map) return Object.fromEntries([...value].map(([k, v]) => [String(k), jsonSafe(v)]));
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(value)) if (v !== undefined) out[k] = jsonSafe(v);
+  return out;
+}

package/src/bench/screen/generators.ts

@@ -0,0 +1,54 @@
+import type { LayoutInput, LayoutObstacle } from "./forms.ts";
+import { documentHash, mulberry32, stepSeed } from "./hash.ts";
+
+/** This function gives a whole number from `lo` to `hi`, both included, from a generator of random numbers. */
+export function randomInt(r: () => number, lo: number, hi: number): number {
+  return lo + Math.floor(r() * (hi - lo + 1));
+}
+
+/** The parameters of the generator `rect-scattered`. */
+export interface RectScatteredParams {
+  /** The number of boxes. */
+  readonly count: number;
+}
+
+/**
+ * This function makes the input of the shared generator `rect-scattered`, version 1: a fixed rectangle container, scattered obstacles and boxes without positions.
+ * The repository `packing` makes the same file, byte for byte. A test in each repository pins the hashes of the seeds 1, 2 and 3.
+ * The steps are `container`, `obstacles` and `boxes`. Each step has its own generator from `stepSeed`.
+ */
+export function rectScattered(seed: number, params: RectScatteredParams, set = "xcheck-v1"): LayoutInput {
+  let r = mulberry32(stepSeed(seed, "container"));
+  const w = randomInt(r, 600, 1000);
+  const h = randomInt(r, 400, 800);
+  r = mulberry32(stepSeed(seed, "obstacles"));
+  const n = randomInt(r, 3, 8);
+  const obstacles: LayoutObstacle[] = [];
+  for (let i = 0; i < n; i++) {
+    const ow = randomInt(r, 40, 160);
+    const oh = randomInt(r, 40, 160);
+    const x = randomInt(r, 0, w - ow);
+    const y = randomInt(r, 0, h - oh);
+    obstacles.push({ id: `o${i}`, region: { kind: "rect", x, y, w: ow, h: oh } });
+  }
+  r = mulberry32(stepSeed(seed, "boxes"));
+  const boxes = Array.from({ length: params.count }, (_, i) => {
+    const bw = randomInt(r, 20, 120);
+    const bh = randomInt(r, 20, 80);
+    return { id: `b${i}`, w: bw, h: bh };
+  });
+  const body = {
+    schema: "layout-input/1" as const,
+    id: `${set}/rect-scattered/s${seed}`,
+    set,
+    family: "rect-scattered",
+    seed,
+    source: "made-up" as const,
+    generator: { name: "rect-scattered", version: 1, params: { count: params.count }, seed },
+    container: { w, h, fixed: "size" as const },
+    obstacles,
+    boxes,
+    edges: [],
+  };
+  return { ...body, hash: documentHash(body) };
+}

package/src/bench/screen/hash.ts

@@ -0,0 +1,129 @@
+// The core runs in any host, so this file has its own SHA-256. It needs no API of Node or of the browser.
+
+const K: readonly number[] = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe,
+  0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+  0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+/** This function gives the bytes of a string in UTF-8. */
+export function utf8(text: string): Uint8Array {
+  const out: number[] = [];
+  for (const ch of text) {
+    const c = ch.codePointAt(0)!;
+    if (c < 0x80) out.push(c);
+    else if (c < 0x800) out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+    else if (c < 0x10000) out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    else out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+  }
+  return Uint8Array.from(out);
+}
+
+/** This function gives the SHA-256 digest of a string, as 64 lowercase hex characters. It encodes the string in UTF-8. */
+export function sha256Hex(text: string): string {
+  const bytes = utf8(text);
+  const bits = bytes.length * 8;
+  const total = Math.ceil((bytes.length + 9) / 64) * 64;
+  const data = new Uint8Array(total);
+  data.set(bytes);
+  data[bytes.length] = 0x80;
+  const view = new DataView(data.buffer);
+  view.setUint32(total - 8, Math.floor(bits / 0x100000000));
+  view.setUint32(total - 4, bits >>> 0);
+  const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+  const w = new Uint32Array(64);
+  const rotr = (x: number, n: number): number => (x >>> n) | (x << (32 - n));
+  for (let off = 0; off < total; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + 4 * i);
+    for (let i = 16; i < 64; i++) {
+      const a = w[i - 15]!;
+      const b = w[i - 2]!;
+      const s0 = rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3);
+      const s1 = rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10);
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, k] = h as [number, number, number, number, number, number, number, number];
+    for (let i = 0; i < 64; i++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (k + s1 + ch + K[i]! + w[i]!) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (s0 + maj) >>> 0;
+      k = g;
+      g = f;
+      f = e;
+      e = (d + t1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+    h[0] = (h[0]! + a) >>> 0;
+    h[1] = (h[1]! + b) >>> 0;
+    h[2] = (h[2]! + c) >>> 0;
+    h[3] = (h[3]! + d) >>> 0;
+    h[4] = (h[4]! + e) >>> 0;
+    h[5] = (h[5]! + f) >>> 0;
+    h[6] = (h[6]! + g) >>> 0;
+    h[7] = (h[7]! + k) >>> 0;
+  }
+  return h.map((x) => x.toString(16).padStart(8, "0")).join("");
+}
+
+/**
+ * This function writes a value as canonical JSON: the keys of each object in sorted order, and no whitespace.
+ * It drops a key whose value is `undefined`, as `JSON.stringify` does.
+ */
+export function canonicalJson(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map((v) => (v === undefined ? "null" : canonicalJson(v))).join(",")}]`;
+  const o = value as Record<string, unknown>;
+  const keys = Object.keys(o)
+    .filter((k) => o[k] !== undefined)
+    .sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(",")}}`;
+}
+
+/**
+ * This function gives the hash of a JSON document: the first 16 hex characters of the SHA-256 of its canonical JSON.
+ * The document does not include its own field `hash`. The function removes that field before it calculates the hash.
+ */
+export function documentHash(value: object): string {
+  const { hash: _hash, ...rest } = value as { hash?: unknown };
+  return sha256Hex(canonicalJson(rest)).slice(0, 16);
+}
+
+/** This function gives the 32-bit FNV-1a hash of the UTF-8 bytes of a text, as an unsigned integer. */
+export function fnv1a32(text: string): number {
+  let h = 0x811c9dc5;
+  for (const byte of utf8(text)) {
+    h ^= byte;
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/** This function gives the seed of one step of a generator: `fnv1a32("<seed>:<step>")`. */
+export function stepSeed(seed: number, step: string): number {
+  return fnv1a32(`${seed}:${step}`);
+}
+
+/** This function gives the generator `mulberry32` for a seed. Each call gives the next number from 0 to below 1. */
+export function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return (): number => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** This function rounds a number to 3 decimals, as the files of a corpus keep it. The value `-0` becomes `0`. */
+export function round3(value: number): number {
+  const r = Math.round(value * 1000) / 1000;
+  return r === 0 ? 0 : r;
+}