@mark1russell7/layout-contract 0.2.2 → 0.2.3

package/README.md

@@ -14,6 +14,8 @@ The package has no runtime dependencies.
 | The record `layout-record/1` | `LayoutRecord`, `Stage`, `Supports`, `RunFacts`, `RunEnv`, `toLayoutRecord` |
 | The strategies | `StrategyInfo` |
 | The measures | `MeasureSpec`, `Direction`, `JointMeasureId`, `JOINT_MEASURES`, `JOINT_MOVED_MIN`, `Verdict`, `compareMeasure`, `minEffectOf` |
+| The edges step | `edgeStep`, `EdgeShape`, `EdgeStepParams`, `EDGE_DENSITY`, `EDGE_STEP_VERSION` |
+| The random numbers | `mulberry32`, `fnv1a32`, `stepRandom`, `randomInt` |
 | The turn | `turnBox`, `turnPort`, `turnMargin`, `turnRegion`, `turnSide`, `turnPoint` |
 | The tolerances | `EPS`, `RECORD_EPS`, `Tolerance`, `DEFAULT_TOLERANCE` |
 | The hard rules | `countOverlaps`, `countObstacleHits`, `regionHitsRect`, `countOutside`, `countPortsOffBorder`, `packHard`, `PackHard`, `placedRect`, `checkInput` |
@@ -44,4 +46,4 @@ const placed = applyPack(input, output);
 const hard = packHard(input, output);
 ```
 
-The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository.
+The formats are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`. The joint measures are in `docs/JOINT-MEASURES.md` of this repository, and the joint corpus is in `docs/JOINT-CORPUS.md`.

package/build/index.d.ts

@@ -187,6 +187,8 @@ export interface LayoutInput {
   readonly hash?: string;
   /** The generator of the input. `null` or no value tells that a person made the input. */
   readonly generator?: LayoutGenerator | null;
+  /** The steps that changed the input after its generator, in their order. `edgeStep` adds one. */
+  readonly steps?: readonly LayoutGenerator[];
   readonly cell?: LayoutCell;
   /** The place of the input in a sequence of changes. */
   readonly step?: number;
@@ -439,4 +441,38 @@ export interface StrategyInfo<O = unknown, S extends Supports = Supports> {
   /** The value is `true` when the result depends only on the input, the options and the seed. */
   readonly deterministic: boolean;
 }
+/** This function gives a generator of random numbers in [0, 1). It is `mulberry32`, as in `docs/FORMAT.md` of `packing`. */
+export declare function mulberry32(seed: number): () => number;
+/** This function gives the FNV-1a hash of 32 bits of the UTF-8 bytes of a string. */
+export declare function fnv1a32(text: string): number;
+/** This function gives the generator of one step of a seeded generator: `mulberry32(fnv1a32("<seed>:<step>"))`. */
+export declare function stepRandom(seed: number, step: string): () => number;
+/** This function gives a whole number from `lo` to `hi`, both included. */
+export declare function randomInt(r: () => number, lo: number, hi: number): number;
+/**
+ * The shape of the edges of `edgeStep`. The values are the cells of `edgeShape`, and `hubs`.
+ * `hubs` waits for the next breaking change to become a value of `LayoutCell.edgeShape`.
+ */
+export type EdgeShape = "random" | "clustered" | "hubChain" | "hubs" | "longRange" | "tree" | "bundled";
+/** The parameters of `edgeStep`. */
+export interface EdgeStepParams {
+  readonly edgeDensity: "sparse" | "medium" | "dense";
+  readonly edgeShape: EdgeShape;
+  /** The default is `none`. */
+  readonly groups?: "none" | "flat" | "nested";
+  /** The default is `free`. */
+  readonly ports?: "free" | "sides" | "fixed";
+  /** The order of the hubs of `hubs` and `tree`: the largest box first, or a random order. The default is `area`. */
+  readonly hubBy?: "area" | "random";
+}
+/** The mean count of the edges of each box for each value of `edgeDensity`. */
+export declare const EDGE_DENSITY: Readonly<Record<EdgeStepParams["edgeDensity"], number>>;
+/** The version of `edgeStep`. A change of its output gives a new version. */
+export declare const EDGE_STEP_VERSION = 1;
+/**
+ * This function gives the input with edges, groups and ports from its topology alone: a joint input has no positions before the pack.
+ * The random numbers come from the steps `edges` and `ports` of `seed`. The function appends its stamp to `steps`, and removes the old `hash`.
+ * The rules of each shape are in `docs/JOINT-CORPUS.md`.
+ */
+export declare function edgeStep(input: LayoutInput, params: EdgeStepParams, seed?: number): LayoutInput;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts"],"mappings":";YACY;;qBAGC,gBAAgB;iBAEZ;WACN;WACA;;;iBAIM;WACN;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA;WACA;;;;;;YAOC;WACG;WAAuB;WAAoB;WAAoB;WAAoB;;WAEnF;WACA;WACA;;WAEA;WAAyB;WAAqB;WAAqB;;WACnE;WAA0B;WAAqB;WAAqB;WAAqB;;;YAG5F,kBAAkB;;wBAGd,YAAY,QAAQ,qBAAqB;;wBAOzC,KAAK,MAAM,MAAM,QAAQ,qBAAqB;;wBAM9C,SAAS,QAAQ,SAAS;;wBAyB1B,UAAU,QAAQ,QAAQ,YAAY,aAAa;;;;;wBAoBnD,UAAU,GAAG,MAAM,GAAG;WAAkB;WAAoB;;;qBCtG/D;;;;;qBAMA;;;;;iBAMI;;WAEN;;WAEA;;;;;;qBAOE,mBAAmB;;;;;;iBCjBf;WACN;WACA,OAAO;WACP;WACA;;;iBAIM;WACN;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA,QAAQ;WACR,iBAAiB;;WAEjB,SAAS;;WAET;;WAEA,OAAO,SAAS;;;YAIf,OAAO;;iBAGF;WACN;WACA;WACA;WACA;WACA;WACA,OAAO,SAAS;;;iBAIV;WACN;WACA;WACA;;WAEA;;WAEA;;WAEA,QAAQ;;WAER;;;iBAIM;WACN;WACA,QAAQ;WACR;aAAkB;;;;iBAIZ;WACN;WACA;WACA,QAAQ,SAAS;WACjB;;;iBAIM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;WAEA,YAAY;WACZ,OAAO;;WAEP;;WAEA,YAAY;;WAEZ;WACA,gBAAgB;WAChB,iBAAiB;WACjB,qBAAqB;;;;;WAKrB;WACA;;;iBAIM;WACN,WAAW;WACX,gBAAgB;WAChB,qBAAqB;WACrB;;;wBAIK,YAAY,OAAO,cAAc;;iBCnIhC;WACN;WACA;WACA;WACA;;;iBAIM;WACN;WACA;WACA,WAAW,SAAS;;;iBAId;WACN,qBAAqB;;WAErB;;WAEA;aAAiB;aAAoB;;;WAErC;aAA2B;aAAqB;aAAoB;;WACpE,iBAAiB;;;;;;;wBAQZ,UAAU,OAAO,aAAa,QAAQ,aAAa;;YChCvD;;iBAGK;WACN;WACA,OAAO;WACP;WACA;;WAEA,SAAS,SAAS;WAClB;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA,UAAU,SAAS;;WAEnB,MAAM,SAAS;;WAEf,YAAY,SAAS,QAAQ;;WAE7B;;WAEA;;WAEA;;WAEA;;;;;WAKA;;WAEA,MAAM;;WAEN;WACA;;;;;;YAOC,WAAW,SAAS;;iBAGf;WACN;WACA;WACA;;WAEA;;WAEA;;WAEA;;;YAIC,WAAW,KAAK;;wBAGZ,eAAe,OAAO,aAAa,KAAK,WAAW;;wBClEnD,WAAW,KAAK,YAAY;;;;;wBAW5B,cAAc,gBAAgB,aAAa;;;;;;wBAyB3C,aAAa,OAAO,aAAa;;wBAoBjC,oBAAoB,gBAAgB,aAAa;;iBAehD;WACN;WACA;WACA;WACA;;;wBAIK,eAAe,QAAQ,QAAQ,MAAM;;;;;wBAmFrC,kBACd,gBAAgB,aAChB,oBAAoB,wBACpB;;;;;;;;;wBAsBc,SAAS,OAAO,aAAa,QAAQ,YAAY,qBAAgD;;;;;wBAiCjG,WAAW,OAAO;;wBCvNlB,SAAS,MAAM,OAAO;;wBAKtB,UAAU,WAAW,WAAW;;wBAKhC,SAAS,MAAM,MAAM,YAAY;;wBAWjC,WAAW,QAAQ,SAAS;;wBAO5B,WAAW,QAAQ,QAAQ,YAAY;;wBAkBvC,QAAQ,KAAK,YAAY;;YCtD7B;;;;;;iBAOK,YAAY;WAClB,IAAI;WACJ;WACA,WAAW;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;;;;WAKA;aAAgC;;;WAEhC;;;YAIC;;qBAYC,yBAAyB,YAAY;;qBAarC;;YAGD;;;;;;wBAOI,YAAY,MAAM,KAAK,2BAA2B,YAAO;;;;;;wBAWzD,eAAe,mBAAmB,kBAAkB,MAAM,KAAK,0CAA0C;;;;;iBC1ExG,aAAa,aAAa,UAAU,WAAW;;WAErD;;WAEA;;WAEA;;WAEA,UAAU;;WAEV,UAAU;;WAEV"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/turn.ts","../src/measures.ts","../src/strategy.ts","../src/random.ts","../src/edges.ts"],"mappings":"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"}

package/build/index.js

@@ -608,6 +608,239 @@ function compareMeasure(candidate, baseline, spec) {
 	if (!(Math.abs(delta) > minEffectOf(spec, candidate, baseline))) return "tie";
 	return (spec.direction === "lower" ? delta < 0 : delta > 0) ? "better" : "worse";
 }
-export { DEFAULT_TOLERANCE, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, SIDES, applyPack, boundsOf, checkInput, compareMeasure, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, grow, marginSides, minEffectOf, overlapOf, packHard, placedRect, regionHitsRect, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
+// src/random.ts
+/** This function gives a generator of random numbers in [0, 1). It is `mulberry32`, as in `docs/FORMAT.md` of `packing`. */
+function mulberry32(seed) {
+	let s = seed >>> 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = Math.imul(s ^ s >>> 15, 1 | s);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** This function gives the FNV-1a hash of 32 bits of the UTF-8 bytes of a string. */
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
+	return h;
+}
+/** The UTF-8 bytes of a string. The package has no runtime dependencies, thus it does not use `TextEncoder`. */
+function utf8(text) {
+	const bytes = [];
+	for (const ch of text) {
+		const c = ch.codePointAt(0);
+		if (c < 128) bytes.push(c);
+		else if (c < 2048) bytes.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return bytes;
+}
+/** This function gives the generator of one step of a seeded generator: `mulberry32(fnv1a32("<seed>:<step>"))`. */
+function stepRandom(seed, step) {
+	return mulberry32(fnv1a32(`${seed}:${step}`));
+}
+/** This function gives a whole number from `lo` to `hi`, both included. */
+function randomInt(r, lo, hi) {
+	return lo + Math.floor(r() * (hi - lo + 1));
+}
+// src/edges.ts
+/** The mean count of the edges of each box for each value of `edgeDensity`. */
+const EDGE_DENSITY = Object.freeze({
+	sparse: .5,
+	medium: 1.5,
+	dense: 4
+});
+/** The version of `edgeStep`. A change of its output gives a new version. */
+const EDGE_STEP_VERSION = 1;
+const CLUSTER = 8;
+const CHAIN = 32;
+const INSIDE = .85;
+const FAN_SHARE = .6;
+const FIXED_SHARE = .2;
+const COLLECTIONS = [
+	"users",
+	"orders",
+	"items",
+	"events"
+];
+const round3 = (x) => Math.round(x * 1e3) / 1e3;
+/**
+* This function gives the input with edges, groups and ports from its topology alone: a joint input has no positions before the pack.
+* The random numbers come from the steps `edges` and `ports` of `seed`. The function appends its stamp to `steps`, and removes the old `hash`.
+* The rules of each shape are in `docs/JOINT-CORPUS.md`.
+*/
+function edgeStep(input, params, seed = input.seed ?? 0) {
+	if ((input.edges?.length ?? 0) > 0) throw new RangeError("edgeStep: the input has edges already");
+	const full = {
+		groups: "none",
+		ports: "free",
+		hubBy: "area",
+		...params
+	};
+	const n = input.boxes.length;
+	const r = stepRandom(seed, "edges");
+	const perm = input.boxes.map((_, i) => i);
+	for (let i = n - 1; i > 0; i--) {
+		const j = randomInt(r, 0, i);
+		[perm[i], perm[j]] = [perm[j], perm[i]];
+	}
+	const clusterOf = new Array(n);
+	perm.forEach((box, p) => clusterOf[box] = Math.floor(p / CLUSTER));
+	const clusters = Math.ceil(n / CLUSTER);
+	const members = (c) => perm.slice(c * CLUSTER, (c + 1) * CLUSTER);
+	const collectionOf = full.edgeShape === "bundled" ? clusterOf.map((c) => `${COLLECTIONS[c % COLLECTIONS.length]}-${c}`) : input.boxes.map(() => COLLECTIONS[randomInt(r, 0, COLLECTIONS.length - 1)]);
+	const area = (i) => input.boxes[i].w * input.boxes[i].h;
+	const rank = full.hubBy === "area" ? input.boxes.map((_, i) => i).sort((a, b) => area(b) - area(a) || a - b) : perm;
+	const pairs = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (u, v) => {
+		const key = u < v ? `${u}-${v}` : `${v}-${u}`;
+		if (u === v || seen.has(key)) return;
+		seen.add(key);
+		pairs.push([u, v]);
+	};
+	const anyBox = () => randomInt(r, 0, n - 1);
+	const inCluster = (c) => {
+		const m = members(c);
+		return m[randomInt(r, 0, m.length - 1)];
+	};
+	const otherCluster = (c) => {
+		const o = randomInt(r, 0, clusters - 2);
+		return o >= c ? o + 1 : o;
+	};
+	const target = Math.min(Math.round(n * EDGE_DENSITY[full.edgeDensity]), n * (n - 1) / 2);
+	const fill = (pick) => {
+		for (let tries = 0; pairs.length < target && tries < target * 30; tries++) add(...pick());
+	};
+	const clustered = () => {
+		const u = anyBox();
+		return [u, r() < INSIDE ? inCluster(clusterOf[u]) : anyBox()];
+	};
+	if (n >= 2) switch (full.edgeShape) {
+		case "random":
+			fill(() => [anyBox(), anyBox()]);
+			break;
+		case "clustered":
+			fill(clustered);
+			break;
+		case "longRange":
+			fill(() => {
+				const u = anyBox();
+				return [u, clusters > 1 ? inCluster(otherCluster(clusterOf[u])) : anyBox()];
+			});
+			break;
+		case "hubs":
+			fill(() => [anyBox(), rank[Math.floor(n * r() ** 3)]]);
+			break;
+		case "tree":
+			for (let i = 1; i < n; i++) add(rank[randomInt(r, 0, i - 1)], rank[i]);
+			break;
+		case "hubChain": {
+			const k = Math.ceil(n / CHAIN);
+			const length = Math.ceil(n / k);
+			const chains = Array.from({ length: k }, (_, c) => perm.slice(c * length, (c + 1) * length));
+			for (const chain of chains) for (let i = 0; i + 1 < chain.length; i++) add(chain[i], chain[i + 1]);
+			const skips = Math.max(0, target - pairs.length);
+			for (let s = 0; s < skips; s++) {
+				const c = k > 1 ? randomInt(r, 0, k - 2) : 0;
+				const from = chains[c];
+				const to = chains[k > 1 ? c + 1 : 0];
+				const i = randomInt(r, 0, from.length - 1);
+				const j = i + Math.floor(from.length / 8) + randomInt(r, 0, Math.floor(from.length / 2));
+				if (j < to.length) add(from[i], to[j]);
+			}
+			break;
+		}
+		case "bundled":
+			for (let rounds = 0; pairs.length < target * FAN_SHARE && clusters > 1 && rounds < target; rounds++) {
+				const u = anyBox();
+				const c = otherCluster(clusterOf[u]);
+				const fan = randomInt(r, 4, 15);
+				for (let f = 0; f < fan && pairs.length < target; f++) add(u, inCluster(c));
+			}
+			fill(clustered);
+	}
+	const rp = stepRandom(seed, "ports");
+	const ports = input.boxes.map((b) => [...b.ports ?? []]);
+	const portOn = (box, id, side, fixed) => {
+		if (!fixed) return {
+			id,
+			side
+		};
+		const along = round3(rp() * (side === "top" || side === "bottom" ? box.w : box.h));
+		const at = {
+			top: [along, 0],
+			bottom: [along, box.h],
+			left: [0, along],
+			right: [box.w, along]
+		}[side];
+		return {
+			id,
+			side,
+			x: at[0],
+			y: at[1]
+		};
+	};
+	const out = /* @__PURE__ */ new Set();
+	if (full.ports === "fixed") input.boxes.forEach((box, i) => {
+		if (rp() >= FIXED_SHARE) return;
+		const side = SIDES[randomInt(rp, 0, 3)];
+		ports[i].push(portOn(box, "out", side, true));
+		out.add(i);
+	});
+	const edges = pairs.map(([u, v], k) => {
+		const id = `e${k}`;
+		const s = input.boxes[u];
+		const t = input.boxes[v];
+		let ends = {};
+		if (full.ports === "sides") {
+			ports[u].push(portOn(s, `${id}.s`, SIDES[randomInt(rp, 0, 3)], false));
+			ports[v].push(portOn(t, `${id}.t`, SIDES[randomInt(rp, 0, 3)], false));
+			ends = {
+				sourcePort: `${id}.s`,
+				targetPort: `${id}.t`
+			};
+		} else if (out.has(u)) ends = { sourcePort: "out" };
+		return {
+			id,
+			source: s.id,
+			target: t.id,
+			...ends,
+			data: { collection: collectionOf[v] }
+		};
+	});
+	const boxes = input.boxes.map((box, i) => {
+		const c = clusterOf[i];
+		const group = full.groups === "none" ? void 0 : `g${c}`;
+		const path = full.groups === "nested" ? `G${Math.floor(c / 4)}/g${c}` : group;
+		return {
+			...box,
+			...group === void 0 ? {} : {
+				group,
+				data: {
+					...box.data,
+					group: path
+				}
+			},
+			...ports[i].length === 0 ? {} : { ports: ports[i] }
+		};
+	});
+	const stamp = {
+		name: "edges",
+		version: 1,
+		params: { ...full },
+		seed
+	};
+	const { hash: _old, ...rest } = input;
+	return {
+		...rest,
+		boxes,
+		edges,
+		steps: [...input.steps ?? [], stamp]
+	};
+}
+export { DEFAULT_TOLERANCE, EDGE_DENSITY, EDGE_STEP_VERSION, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, SIDES, applyPack, boundsOf, checkInput, compareMeasure, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, edgeStep, fnv1a32, grow, marginSides, minEffectOf, mulberry32, overlapOf, packHard, placedRect, randomInt, regionHitsRect, stepRandom, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
 
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/turn.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/measures.ts"],"sourcesContent":["/** A side of a box. The y axis points down, so `top` has the smallest y. */\nexport type Side = \"top\" | \"right\" | \"bottom\" | \"left\";\n\n/** The sides in clockwise order, from the top. */\nexport const SIDES: readonly Side[] = [\"top\", \"right\", \"bottom\", \"left\"];\n\nexport interface Point {\n  readonly x: number;\n  readonly y: number;\n}\n\n/** A rectangle: its top-left corner and its size. */\nexport interface Rect {\n  readonly x: number;\n  readonly y: number;\n  readonly w: number;\n  readonly h: number;\n}\n\n/** A value for each side of a box. */\nexport interface Sides {\n  readonly top: number;\n  readonly right: number;\n  readonly bottom: number;\n  readonly left: number;\n}\n\n/**\n * A region. The forms and the rules are those of `docs/FORMAT.md` of `packing`.\n * A ring of a polygon closes without a copy of its first point.\n */\nexport type Region =\n  | { readonly kind: \"rect\"; readonly x: number; readonly y: number; readonly w: number; readonly h: number }\n  | {\n      readonly kind: \"polygon\";\n      readonly points: readonly (readonly [number, number])[];\n      readonly holes?: readonly (readonly (readonly [number, number])[])[];\n    }\n  | { readonly kind: \"circle\"; readonly cx: number; readonly cy: number; readonly r: number }\n  | { readonly kind: \"ellipse\"; readonly cx: number; readonly cy: number; readonly rx: number; readonly ry: number };\n\n/** A margin: one value for the four sides, or one value for each side. */\nexport type Margin = number | Sides;\n\n/** This function gives the value of each side of a margin. No margin gives 0 on each side. */\nexport function marginSides(margin: Margin | undefined): Sides {\n  if (margin === undefined) return { top: 0, right: 0, bottom: 0, left: 0 };\n  if (typeof margin === \"number\") return { top: margin, right: margin, bottom: margin, left: margin };\n  return margin;\n}\n\n/** This function gives the rectangle made larger by the margin on each side. */\nexport function grow(rect: Rect, margin: Margin | undefined): Rect {\n  const m = marginSides(margin);\n  return { x: rect.x - m.left, y: rect.y - m.top, w: rect.w + m.left + m.right, h: rect.h + m.top + m.bottom };\n}\n\n/** This function gives the bounding box of a region. */\nexport function boundsOf(region: Region): Rect {\n  switch (region.kind) {\n    case \"rect\":\n      return { x: region.x, y: region.y, w: region.w, h: region.h };\n    case \"circle\":\n      return { x: region.cx - region.r, y: region.cy - region.r, w: 2 * region.r, h: 2 * region.r };\n    case \"ellipse\":\n      return { x: region.cx - region.rx, y: region.cy - region.ry, w: 2 * region.rx, h: 2 * region.ry };\n    case \"polygon\": {\n      let x0 = Infinity;\n      let y0 = Infinity;\n      let x1 = -Infinity;\n      let y1 = -Infinity;\n      for (const [x, y] of region.points) {\n        x0 = Math.min(x0, x);\n        y0 = Math.min(y0, y);\n        x1 = Math.max(x1, x);\n        y1 = Math.max(y1, y);\n      }\n      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };\n    }\n  }\n}\n\n/** This function gives the region moved by `dx` and `dy`. */\nexport function translate(region: Region, dx: number, dy: number): Region {\n  switch (region.kind) {\n    case \"rect\":\n      return { ...region, x: region.x + dx, y: region.y + dy };\n    case \"circle\":\n    case \"ellipse\":\n      return { ...region, cx: region.cx + dx, cy: region.cy + dy };\n    case \"polygon\": {\n      const move = (ring: readonly (readonly [number, number])[]): [number, number][] => ring.map(([x, y]) => [x + dx, y + dy]);\n      return region.holes === undefined\n        ? { kind: \"polygon\", points: move(region.points) }\n        : { kind: \"polygon\", points: move(region.points), holes: region.holes.map(move) };\n    }\n  }\n}\n\n/**\n * This function gives the overlap of the insides of two rectangles on each axis.\n * A value of 0 or less on an axis is no overlap. Two rectangles with a common edge have an overlap of 0.\n */\nexport function overlapOf(a: Rect, b: Rect): { readonly x: number; readonly y: number } {\n  return {\n    x: Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x),\n    y: Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y),\n  };\n}\n","/** The epsilon for the float compares in an engine. */\nexport const EPS = 1e-6;\n\n/**\n * The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,\n * so a difference of two values can move by up to 0.001.\n */\nexport const RECORD_EPS = 1e-3;\n\n/**\n * The tolerance of each hard rule, in layout units. A record writes the tolerance that its run used,\n * in its field `tolerance`, next to `hard`.\n */\nexport interface Tolerance {\n  /** Two boxes with their margins break `no-overlap` when their insides overlap by more than this on each axis. */\n  readonly overlap: number;\n  /** A route breaks `no-pass-through` when a part longer than this is inside a box made this much smaller. */\n  readonly through: number;\n}\n\n/**\n * The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.\n * Routes are sampled curves that follow the margin line, so `through` is larger.\n */\nexport const DEFAULT_TOLERANCE: Tolerance = Object.freeze({ overlap: 0.001, through: 0.5 });\n","import type { Margin, Region, Side } from \"./geometry.ts\";\n\n/**\n * A port of a box: a place where edges go into the box.\n * With `x` and `y`, the port is fixed on the border of the box, relative to its top-left corner.\n * Without them, the router places the port on its `side`. Without a side, the router picks the side.\n */\nexport interface Port {\n  readonly id: string;\n  readonly side?: Side;\n  readonly x?: number;\n  readonly y?: number;\n}\n\n/** A box of an input. In the packer, its name is item. */\nexport interface LayoutBox {\n  readonly id: string;\n  readonly w: number;\n  readonly h: number;\n  /** The packer writes the position. The router reads it. */\n  readonly x?: number;\n  readonly y?: number;\n  /** A locked box keeps `x` and `y`. The packer reads it as an obstacle. */\n  readonly locked?: boolean;\n  /** The reading order. Without it, the order of the array is the rank. */\n  readonly rank?: number;\n  readonly parent?: string;\n  readonly group?: string;\n  /** A region relative to the origin of the box. Without it, the box is the rectangle `w` by `h`. */\n  readonly shape?: Region;\n  readonly ports?: readonly Port[];\n  /** A ring around the box. No other box enters it. Only a route from a port of the box enters it, at a right angle. */\n  readonly margin?: Margin;\n  /** The packer can turn the box by 90 degrees. The output has the turned box and ports. */\n  readonly turnable?: boolean;\n  /** The free data of the node. The grouping rule `keys` of `highways` reads `data.group`. */\n  readonly data?: Readonly<Record<string, unknown>>;\n}\n\n/** The packer name of a box. It is the same type. */\nexport type Item = LayoutBox;\n\n/** An edge between two boxes, with optional ports. */\nexport interface LayoutEdge {\n  readonly id: string;\n  readonly source: string;\n  readonly target: string;\n  readonly sourcePort?: string;\n  readonly targetPort?: string;\n  readonly data?: Readonly<Record<string, unknown>>;\n}\n\n/** The container. `fixed` tells which sides of the size stay. */\nexport interface LayoutContainer {\n  readonly w?: number;\n  readonly h?: number;\n  readonly fixed: \"size\" | \"width\" | \"height\" | \"none\";\n  /** The target aspect: the width divided by the height. The default is 1. */\n  readonly aspect?: number;\n  /** The weight of the aspect error in the objective. 0 gives the least area. The default is 1. */\n  readonly aspectWeight?: number;\n  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */\n  readonly shape?: Region;\n  /** The space between the border and the boxes with their margins. */\n  readonly inset?: number;\n}\n\n/** An area that boxes and routes avoid. Without `move`, it stays. With `move`, the packer can move it for `cost` times the distance. */\nexport interface Obstacle {\n  readonly id: string;\n  readonly region: Region;\n  readonly move?: { readonly cost: number };\n}\n\n/** The generator of an input. The same name, version, parameters and seed give the same file, byte for byte. */\nexport interface LayoutGenerator {\n  readonly name: string;\n  readonly version: number;\n  readonly params: Readonly<Record<string, unknown>>;\n  readonly seed: number;\n}\n\n/** The cell of an input in the taxonomy: one value for each dimension. The dimensions are in `docs/FORMAT.md` of `packing`. */\nexport interface LayoutCell {\n  readonly containerSize?: \"fixed\" | \"freeHeight\" | \"freeWidth\" | \"freeAspect\" | \"freeArea\";\n  readonly containerShape?: \"rect\" | \"convex\" | \"polygon\" | \"circle\" | \"ellipse\" | \"holes\";\n  readonly obstacles?: \"none\" | \"center\" | \"scattered\" | \"wall\" | \"corridors\" | \"touching\" | \"edge\";\n  readonly sizes?: \"identical\" | \"uniform\" | \"heavyTail\" | \"bimodal\" | \"extremeAspect\" | \"nearIdentical\";\n  readonly count?: \"1\" | \"10\" | \"100\" | \"1k\" | \"10k\";\n  readonly mode?: \"offline\" | \"online\" | \"incremental\";\n  readonly edgeDensity?: \"sparse\" | \"medium\" | \"dense\";\n  readonly edgeShape?: \"random\" | \"clustered\" | \"hubChain\" | \"longRange\" | \"tree\" | \"bundled\";\n  readonly groups?: \"none\" | \"flat\" | \"nested\";\n  readonly ports?: \"free\" | \"sides\" | \"fixed\";\n}\n\n/** An input of the corpus: the format `layout-input/1`. */\nexport interface LayoutInput {\n  readonly schema: \"layout-input/1\";\n  readonly id: string;\n  readonly set?: string;\n  readonly family?: string;\n  readonly seed?: number;\n  /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */\n  readonly source?: string;\n  /** The first 16 hex characters of the SHA-256 of the canonical file without this field. */\n  readonly hash?: string;\n  /** The generator of the input. `null` or no value tells that a person made the input. */\n  readonly generator?: LayoutGenerator | null;\n  readonly cell?: LayoutCell;\n  /** The place of the input in a sequence of changes. */\n  readonly step?: number;\n  /** A router input can have no container. */\n  readonly container?: LayoutContainer;\n  /** The free space between two boxes with their margins. Routes use it. */\n  readonly gap?: number;\n  readonly boxes: readonly LayoutBox[];\n  readonly edges?: readonly LayoutEdge[];\n  readonly obstacles?: readonly Obstacle[];\n  /**\n   * A variant names its base input and its change.\n   * With `packed`, the variant is the packed output of its base input: the router routes the positions of that pack.\n   */\n  readonly base?: string;\n  readonly change?: \"add\" | \"remove\" | \"resize\" | \"reorder\" | \"packed\";\n}\n\n/** The input of a packer: a `layout-input/1` file without the edges. */\nexport interface PackInput {\n  readonly container: LayoutContainer;\n  readonly items: readonly Item[];\n  readonly obstacles?: readonly Obstacle[];\n  readonly gap?: number;\n}\n\n/** This function gives the packer input of a file. An input without a container gets `{ fixed: \"none\" }`, so the packer picks the size. */\nexport function toPackInput(input: LayoutInput): PackInput {\n  return {\n    container: input.container ?? { fixed: \"none\" },\n    items: input.boxes,\n    ...(input.obstacles === undefined ? {} : { obstacles: input.obstacles }),\n    ...(input.gap === undefined ? {} : { gap: input.gap }),\n  };\n}\n","import { SIDES, marginSides, type Margin, type Region, type Side } from \"./geometry.ts\";\nimport type { LayoutBox, Port } from \"./input.ts\";\n\n/*\n * The turn: 90 degrees clockwise, with the y axis down. The turned box has `w` and `h` swapped,\n * and its top-left corner stays at the position of the box. A point (px, py) of a box of height h\n * goes to (h - py, px). Thus the top-left corner goes to the top-right corner, and each side moves\n * one step clockwise: top to right, right to bottom, bottom to left, left to top.\n */\n\n/** This function gives the side after a turn of 90 degrees clockwise. */\nexport function turnSide(side: Side): Side {\n  return SIDES[(SIDES.indexOf(side) + 1) % 4]!;\n}\n\n/** This function gives a point of a box of height `h` after the turn. */\nexport function turnPoint(x: number, y: number, h: number): [number, number] {\n  return [h - y, x];\n}\n\n/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */\nexport function turnPort(port: Port, h: number): Port {\n  const { side, x, y, ...rest } = port;\n  return {\n    ...rest,\n    ...(side === undefined ? {} : { side: turnSide(side) }),\n    ...(y === undefined ? {} : { x: h - y }),\n    ...(x === undefined ? {} : { y: x }),\n  };\n}\n\n/** This function gives a margin after the turn: the value of each side moves one side clockwise. */\nexport function turnMargin(margin: Margin): Margin {\n  if (typeof margin === \"number\") return margin;\n  const m = marginSides(margin);\n  return { top: m.left, right: m.top, bottom: m.right, left: m.bottom };\n}\n\n/** This function gives a region relative to the origin of a box of height `h` after the turn. */\nexport function turnRegion(region: Region, h: number): Region {\n  switch (region.kind) {\n    case \"rect\":\n      return { kind: \"rect\", x: h - region.y - region.h, y: region.x, w: region.h, h: region.w };\n    case \"circle\":\n      return { ...region, cx: h - region.cy, cy: region.cx };\n    case \"ellipse\":\n      return { kind: \"ellipse\", cx: h - region.cy, cy: region.cx, rx: region.ry, ry: region.rx };\n    case \"polygon\": {\n      const turn = (ring: readonly (readonly [number, number])[]): [number, number][] => ring.map(([x, y]) => turnPoint(x, y, h));\n      return region.holes === undefined\n        ? { kind: \"polygon\", points: turn(region.points) }\n        : { kind: \"polygon\", points: turn(region.points), holes: region.holes.map(turn) };\n    }\n  }\n}\n\n/** This function gives a box after the turn: the size, the ports, the margin and the shape turn. The position stays. */\nexport function turnBox(box: LayoutBox): LayoutBox {\n  return {\n    ...box,\n    w: box.h,\n    h: box.w,\n    ...(box.ports === undefined ? {} : { ports: box.ports.map((p) => turnPort(p, box.h)) }),\n    ...(box.margin === undefined ? {} : { margin: turnMargin(box.margin) }),\n    ...(box.shape === undefined ? {} : { shape: turnRegion(box.shape, box.h) }),\n  };\n}\n","import { boundsOf, translate } from \"./geometry.ts\";\nimport type { LayoutInput } from \"./input.ts\";\nimport { turnBox } from \"./turn.ts\";\n\n/** The position of one item. `turn` is 90 when the packer turned a turnable item. */\nexport interface Placement {\n  readonly id: string;\n  readonly x: number;\n  readonly y: number;\n  readonly turn?: 0 | 90;\n}\n\n/** The facts of one stage of a strategy, for the records and the site. */\nexport interface StageTrace {\n  readonly id: string;\n  readonly ms?: number;\n  readonly measures?: Readonly<Record<string, number>>;\n}\n\n/** The output of a packer. It does not change the input. */\nexport interface PackOutput {\n  readonly placements: readonly Placement[];\n  /** The ids of the items that the packer did not place. */\n  readonly overflow: readonly string[];\n  /** The size of the container after the pack. For a free size, the size that the search found. */\n  readonly size: { readonly w: number; readonly h: number };\n  /** The new top-left corner of the bounding box of each obstacle that moved. */\n  readonly moved: readonly { readonly id: string; readonly x: number; readonly y: number }[];\n  readonly trace?: readonly StageTrace[];\n}\n\n/**\n * This function gives the input with the output of a packer applied. Each placed box gets its position.\n * A turned box gets its turned size, ports, margin and shape. Each moved obstacle moves.\n * The container gets the size of the output. The router reads this result. It does not read `turn`.\n */\nexport function applyPack(input: LayoutInput, output: PackOutput): LayoutInput {\n  const at = new Map(output.placements.map((p) => [p.id, p]));\n  const moved = new Map(output.moved.map((m) => [m.id, m]));\n  const boxes = input.boxes.map((box) => {\n    const p = at.get(box.id);\n    if (p === undefined) return box;\n    const turned = p.turn === 90 ? turnBox(box) : box;\n    return { ...turned, x: p.x, y: p.y };\n  });\n  const obstacles = input.obstacles?.map((o) => {\n    const m = moved.get(o.id);\n    if (m === undefined) return o;\n    const b = boundsOf(o.region);\n    return { ...o, region: translate(o.region, m.x - b.x, m.y - b.y) };\n  });\n  return {\n    ...input,\n    container: { ...(input.container ?? { fixed: \"none\" }), w: output.size.w, h: output.size.h },\n    boxes,\n    ...(obstacles === undefined ? {} : { obstacles }),\n  };\n}\n","import type { Tolerance } from \"./tolerance.ts\";\nimport type { LayoutInput } from \"./input.ts\";\n\n/** The stage of a record: the packer, the router, or both together. */\nexport type Stage = \"pack\" | \"route\" | \"joint\";\n\n/** One run of one strategy on one input and seed: the format `layout-record/1`. A run writes one line of JSON Lines. */\nexport interface LayoutRecord {\n  readonly schema: \"layout-record/1\";\n  readonly stage: Stage;\n  readonly step: string;\n  readonly strategy: string;\n  /** The options in full, with the defaults. */\n  readonly options: Readonly<Record<string, unknown>>;\n  readonly corpus: string;\n  /** The id of the input. */\n  readonly input: string;\n  /** The `hash` of the input file. */\n  readonly inputHash: string;\n  readonly set: string;\n  readonly seed: number;\n  readonly nodes: number;\n  readonly edges: number;\n  /** The value of each measure, by its name: `pack.*`, `route.*` or `joint.*`. */\n  readonly measures: Readonly<Record<string, number>>;\n  /** The count of the breaks of each hard rule. A good run has 0 for each rule. */\n  readonly hard: Readonly<Record<string, number>>;\n  /** The tolerance of each hard rule of the run. */\n  readonly tolerance?: Readonly<Partial<Tolerance>>;\n  /** `true` when two runs with the same seed give the same positions. */\n  readonly deterministic: boolean;\n  /** The id of the prediction that was written before the run. */\n  readonly prediction?: string;\n  /** The median of `msRuns`, or the time of the one run. */\n  readonly ms: number;\n  /** The time of each timed repeat, in milliseconds. */\n  readonly msRuns?: readonly number[];\n  /**\n   * The first 16 hex characters of the SHA-256 of the canonical output of the stage.\n   * The packer hashes its placements by the order of the ids. The router hashes its routes by the order of the edge ids.\n   */\n  readonly outputHash?: string;\n  /** The facts of the computer of the run. */\n  readonly env?: RunEnv;\n  /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */\n  readonly skipped?: string;\n  readonly commit?: string;\n}\n\n/**\n * The values that a strategy supports, for each dimension of a taxonomy.\n * The dimension names are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`.\n */\nexport type Supports = Readonly<Record<string, readonly string[]>>;\n\n/** The facts of the computer of a run. */\nexport interface RunEnv {\n  readonly node: string;\n  readonly os: string;\n  readonly arch: string;\n  /** The name of the runner, for example `ubuntu-latest` or `local`. */\n  readonly runner: string;\n  /** The model of the processor. */\n  readonly cpu: string;\n  /** The count of the logical processors. */\n  readonly cpus: number;\n}\n\n/** The facts of a run that the input does not give. */\nexport type RunFacts = Omit<LayoutRecord, \"schema\" | \"input\" | \"inputHash\" | \"set\" | \"nodes\" | \"edges\">;\n\n/** This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges. */\nexport function toLayoutRecord(input: LayoutInput, run: RunFacts): LayoutRecord {\n  return {\n    schema: \"layout-record/1\",\n    ...run,\n    input: input.id,\n    inputHash: input.hash ?? \"\",\n    set: input.set ?? \"\",\n    nodes: input.boxes.length,\n    edges: input.edges?.length ?? 0,\n  };\n}\n","import { boundsOf, grow, overlapOf, type Rect, type Region } from \"./geometry.ts\";\nimport type { LayoutBox, LayoutInput, Obstacle } from \"./input.ts\";\nimport { applyPack, type PackOutput } from \"./output.ts\";\nimport { DEFAULT_TOLERANCE, RECORD_EPS } from \"./tolerance.ts\";\n\n/** This function gives the area of a placed box: its shape or its rectangle, at its position. A box without a position gives `undefined`. */\nexport function placedRect(box: LayoutBox): Rect | undefined {\n  if (box.x === undefined || box.y === undefined) return undefined;\n  if (box.shape === undefined) return { x: box.x, y: box.y, w: box.w, h: box.h };\n  const b = boundsOf(box.shape);\n  return { x: box.x + b.x, y: box.y + b.y, w: b.w, h: b.h };\n}\n\n/**\n * This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.\n * A box with a shape counts as its bounding box. That area is larger, thus the count is safe.\n */\nexport function countOverlaps(boxes: readonly LayoutBox[], tolerance: number = DEFAULT_TOLERANCE.overlap): number {\n  const rects: Rect[] = [];\n  for (const box of boxes) {\n    const r = placedRect(box);\n    if (r !== undefined) rects.push(grow(r, box.margin));\n  }\n  rects.sort((a, b) => a.x - b.x);\n  let count = 0;\n  for (let i = 0; i < rects.length; i++) {\n    const a = rects[i]!;\n    for (let j = i + 1; j < rects.length; j++) {\n      const b = rects[j]!;\n      if (b.x >= a.x + a.w - tolerance) break;\n      const o = overlapOf(a, b);\n      if (o.x > tolerance && o.y > tolerance) count++;\n    }\n  }\n  return count;\n}\n\n/**\n * This function counts the placed boxes that go out of the container.\n * Each box with its margin must stay inside the container made smaller by `inset`. Only the fixed sides of the size count. A shaped container counts as its bounding box.\n * An input without a container gives 0.\n */\nexport function countOutside(input: LayoutInput, tolerance: number = DEFAULT_TOLERANCE.overlap): number {\n  const c = input.container;\n  if (c === undefined) return 0;\n  const area = c.shape === undefined ? { x: 0, y: 0, w: c.w ?? Infinity, h: c.h ?? Infinity } : boundsOf(c.shape);\n  const inset = c.inset ?? 0;\n  const fixW = c.fixed === \"size\" || c.fixed === \"width\";\n  const fixH = c.fixed === \"size\" || c.fixed === \"height\";\n  let count = 0;\n  for (const box of input.boxes) {\n    const r0 = placedRect(box);\n    if (r0 === undefined) continue;\n    const r = grow(r0, box.margin);\n    const outX = r.x < area.x + inset - tolerance || r.x + r.w > area.x + area.w - inset + tolerance;\n    const outY = r.y < area.y + inset - tolerance || r.y + r.h > area.y + area.h - inset + tolerance;\n    if ((fixW && outX) || (fixH && outY)) count++;\n  }\n  return count;\n}\n\n/** This function counts the fixed ports that are not on the border of their box, with the epsilon of a written file. A port without a side does not count. */\nexport function countPortsOffBorder(boxes: readonly LayoutBox[], eps: number = RECORD_EPS): number {\n  let count = 0;\n  for (const box of boxes) {\n    for (const p of box.ports ?? []) {\n      if (p.x === undefined || p.y === undefined || p.side === undefined) continue;\n      const along = p.side === \"top\" || p.side === \"bottom\" ? p.x : p.y;\n      const length = p.side === \"top\" || p.side === \"bottom\" ? box.w : box.h;\n      const across = { top: p.y, bottom: p.y - box.h, left: p.x, right: p.x - box.w }[p.side];\n      if (Math.abs(across) > eps || along < -eps || along > length + eps) count++;\n    }\n  }\n  return count;\n}\n\n/** The count of the breaks of each hard rule of a pack. */\nexport interface PackHard {\n  readonly \"no-overlap\": number;\n  readonly \"in-container\": number;\n  readonly \"locked-kept\": number;\n  readonly complete: number;\n}\n\n/** This function tells if the inside of `region` and the inside of `rect` have a common point. */\nexport function regionHitsRect(region: Region, rect: Rect): boolean {\n  if (rect.w <= 0 || rect.h <= 0) return false;\n  switch (region.kind) {\n    case \"rect\": {\n      const o = overlapOf(region, rect);\n      return o.x > 0 && o.y > 0;\n    }\n    case \"circle\":\n      return circleHitsRect(region.cx, region.cy, region.r, region.r, rect);\n    case \"ellipse\":\n      return circleHitsRect(region.cx, region.cy, region.rx, region.ry, rect);\n    case \"polygon\": {\n      const rings = [region.points, ...(region.holes ?? [])];\n      const inside = (x: number, y: number): boolean => x > rect.x && x < rect.x + rect.w && y > rect.y && y < rect.y + rect.h;\n      if (region.points.some(([x, y]) => inside(x, y))) return true;\n      for (const ring of rings) {\n        for (let i = 0; i < ring.length; i++) {\n          const a = ring[i]!;\n          const b = ring[(i + 1) % ring.length]!;\n          const m = clipMid(a[0], a[1], b[0], b[1], rect);\n          if (m !== undefined && inside(m[0], m[1])) return true;\n        }\n      }\n      return pointInRings(rect.x + rect.w / 2, rect.y + rect.h / 2, rings);\n    }\n  }\n}\n\n/** An ellipse with the radii `rx` and `ry` scales to a unit circle. The rectangle scales with it. */\nfunction circleHitsRect(cx: number, cy: number, rx: number, ry: number, rect: Rect): boolean {\n  if (rx <= 0 || ry <= 0) return false;\n  const x0 = (rect.x - cx) / rx;\n  const x1 = (rect.x + rect.w - cx) / rx;\n  const y0 = (rect.y - cy) / ry;\n  const y1 = (rect.y + rect.h - cy) / ry;\n  const dx = Math.max(x0, 0, -x1);\n  const dy = Math.max(y0, 0, -y1);\n  return dx * dx + dy * dy < 1;\n}\n\n/** This function gives the middle of the part of a segment inside a rectangle, or `undefined` when that part is a point or empty. */\nfunction clipMid(ax: number, ay: number, bx: number, by: number, r: Rect): readonly [number, number] | undefined {\n  let t0 = 0;\n  let t1 = 1;\n  const dx = bx - ax;\n  const dy = by - ay;\n  const edges: readonly (readonly [number, number])[] = [\n    [-dx, ax - r.x],\n    [dx, r.x + r.w - ax],\n    [-dy, ay - r.y],\n    [dy, r.y + r.h - ay],\n  ];\n  for (const [p, q] of edges) {\n    if (p === 0) {\n      if (q < 0) return undefined;\n    } else if (p < 0) {\n      t0 = Math.max(t0, q / p);\n    } else {\n      t1 = Math.min(t1, q / p);\n    }\n  }\n  if (t1 <= t0) return undefined;\n  const t = (t0 + t1) / 2;\n  return [ax + t * dx, ay + t * dy];\n}\n\n/** The even-odd rule over the outer ring and the holes. */\nfunction pointInRings(x: number, y: number, rings: readonly (readonly (readonly [number, number])[])[]): boolean {\n  let inside = false;\n  for (const ring of rings) {\n    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {\n      const [xi, yi] = ring[i]!;\n      const [xj, yj] = ring[j]!;\n      if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n    }\n  }\n  return inside;\n}\n\n/**\n * This function counts the pairs of a placed box and an obstacle that overlap by more than `tolerance`.\n * The box counts with its margin. A box with a shape counts as its bounding box.\n */\nexport function countObstacleHits(\n  boxes: readonly LayoutBox[],\n  obstacles: readonly Obstacle[] | undefined,\n  tolerance: number = DEFAULT_TOLERANCE.overlap,\n): number {\n  if (obstacles === undefined || obstacles.length === 0) return 0;\n  let count = 0;\n  for (const box of boxes) {\n    const r0 = placedRect(box);\n    if (r0 === undefined) continue;\n    const r = grow(r0, box.margin);\n    const small = { x: r.x + tolerance, y: r.y + tolerance, w: r.w - 2 * tolerance, h: r.h - 2 * tolerance };\n    for (const o of obstacles) if (regionHitsRect(o.region, small)) count++;\n  }\n  return count;\n}\n\n/**\n * This function gives the count of each hard rule of the output of a packer.\n * It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.\n * `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle.\n * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.\n * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.\n * Another box without a placement that is not in `overflow` breaks `complete`.\n */\nexport function packHard(input: LayoutInput, output: PackOutput, tolerance: number = DEFAULT_TOLERANCE.overlap): PackHard {\n  const after = applyPack(input, output);\n  const placed = new Set(output.placements.map((p) => p.id));\n  const out = new Set(output.overflow);\n  const was = new Map(input.boxes.map((b) => [b.id, b]));\n  let lockedMoved = 0;\n  let incomplete = 0;\n  const kept: LayoutBox[] = [];\n  for (const box of after.boxes) {\n    const old = was.get(box.id);\n    if (old?.locked === true) {\n      if (old.x === undefined || old.y === undefined) continue;\n      const moved = Math.abs(old.x - (box.x ?? old.x)) > RECORD_EPS || Math.abs(old.y - (box.y ?? old.y)) > RECORD_EPS;\n      if (!placed.has(box.id) || moved) lockedMoved++;\n      kept.push(box);\n    } else if (placed.has(box.id)) {\n      kept.push(box);\n    } else if (!out.has(box.id)) {\n      incomplete++;\n    }\n  }\n  return {\n    \"no-overlap\": countOverlaps(kept, tolerance) + countObstacleHits(kept, after.obstacles, tolerance),\n    \"in-container\": countOutside({ ...after, boxes: kept }, tolerance),\n    \"locked-kept\": lockedMoved,\n    complete: incomplete,\n  };\n}\n\n/**\n * This function gives the problems of an input file. An empty list tells that the file is good.\n * A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.\n */\nexport function checkInput(input: LayoutInput): readonly string[] {\n  const problems: string[] = [];\n  const ids = new Set<string>();\n  for (const box of input.boxes) {\n    if (ids.has(box.id)) problems.push(`box ${box.id}: the id is not unique`);\n    ids.add(box.id);\n    if (!(box.w > 0 && box.h > 0 && Number.isFinite(box.w) && Number.isFinite(box.h))) problems.push(`box ${box.id}: the size is not positive and finite`);\n    if (box.locked === true && (box.x === undefined || box.y === undefined)) problems.push(`box ${box.id}: a locked box has no position`);\n  }\n  if (countPortsOffBorder(input.boxes) > 0) problems.push(\"a fixed port is not on the border of its box\");\n  for (const edge of input.edges ?? []) {\n    if (!ids.has(edge.source) || !ids.has(edge.target)) problems.push(`edge ${edge.id}: a box of the edge is not in the input`);\n  }\n  return problems;\n}\n","import { RECORD_EPS } from \"./tolerance.ts\";\n\n/** The direction of a measure: the side of the better values. */\nexport type Direction = \"lower\" | \"higher\";\n\n/**\n * The facts of one measure: its unit, its direction and its range.\n * `floor` and `tol` are the parameters of the floor rule of the promotion rule (`docs/PROMOTION.md` of `highways`).\n * Each engine exports the specs of its own measures. This package exports the specs of the `joint.*` measures.\n */\nexport interface MeasureSpec<Id extends string = string> {\n  readonly id: Id;\n  readonly unit: string;\n  readonly direction: Direction;\n  /** The lowest value. */\n  readonly min: number;\n  /** The highest value. The value `Infinity` tells that the measure has no upper limit. */\n  readonly max: number;\n  /** The family of the measure in the measure note of its engine. */\n  readonly family?: string;\n  /** The best value. Without it, the measure has no floor. */\n  readonly floor?: number;\n  /** The absolute tolerance at the floor. */\n  readonly tol?: number;\n  /**\n   * The smallest change that counts as better or worse. A number is an absolute change. `{ rel }` is a share of the larger of the two values.\n   * `docs/JOINT-MEASURES.md` gives the reason of each joint value.\n   */\n  readonly minEffect?: number | { readonly rel: number };\n  /** The role of the measure in the joint selector. */\n  readonly role?: \"guard\" | \"change-guard\" | \"diagnostic\" | \"time\";\n}\n\n/** The id of a joint measure. `docs/JOINT-MEASURES.md` gives the definitions. */\nexport type JointMeasureId =\n  | \"joint.fill\"\n  | \"joint.aspectError\"\n  | \"joint.spill\"\n  | \"joint.straight.crossings\"\n  | \"joint.straight.length\"\n  | \"joint.stability.mean\"\n  | \"joint.stability.moved\"\n  | \"joint.proxy.rank\"\n  | \"joint.ms\";\n\n/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */\nexport const JOINT_MEASURES: readonly MeasureSpec<JointMeasureId>[] = Object.freeze([\n  { id: \"joint.fill\", minEffect: 0.001, unit: \"0 to 1\", direction: \"higher\", min: 0, max: 1, floor: 1, role: \"guard\" },\n  { id: \"joint.aspectError\", minEffect: 0.01, unit: \"natural log\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.01, role: \"guard\" },\n  { id: \"joint.spill\", minEffect: 0.001, unit: \"0 to 1\", direction: \"lower\", min: 0, max: 1, floor: 0, tol: 0.001, role: \"guard\" },\n  { id: \"joint.straight.crossings\", minEffect: 0, unit: \"count\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0, role: \"guard\" },\n  { id: \"joint.straight.length\", minEffect: 0.01, unit: \"S for each edge\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.01, role: \"guard\" },\n  { id: \"joint.stability.mean\", minEffect: 0.005, unit: \"W\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.005, role: \"change-guard\" },\n  { id: \"joint.stability.moved\", minEffect: 0.02, unit: \"0 to 1\", direction: \"lower\", min: 0, max: 1, floor: 0, tol: 0.02, role: \"change-guard\" },\n  { id: \"joint.proxy.rank\", unit: \"-1 to 1\", direction: \"higher\", min: -1, max: 1, role: \"diagnostic\" },\n  { id: \"joint.ms\", unit: \"milliseconds\", direction: \"lower\", min: 0, max: Infinity, role: \"time\" },\n] as const);\n\n/** The threshold of `joint.stability.moved`, in widths `W` of the base. */\nexport const JOINT_MOVED_MIN = 0.01;\n\n/** The result of a compare of a candidate with a baseline on one measure. A tie is not better. */\nexport type Verdict = \"better\" | \"worse\" | \"tie\";\n\n/**\n * This function gives the smallest change of a measure that counts between the values `a` and `b`.\n * The value is `max(RECORD_EPS, minEffect)`, or `max(RECORD_EPS, rel * max(|a|, |b|))` for a relative `minEffect`.\n * The larger value makes the threshold the same after a swap of `a` and `b`.\n */\nexport function minEffectOf(spec: Pick<MeasureSpec, \"minEffect\">, a = 0, b = 0): number {\n  const m = spec.minEffect ?? 0;\n  const t = typeof m === \"number\" ? m : m.rel * Math.max(Math.abs(a), Math.abs(b));\n  return Math.max(RECORD_EPS, Number.isFinite(t) ? t : 0);\n}\n\n/**\n * This function compares the value `candidate` with the value `baseline` of one measure on one input.\n * A change of at most `minEffectOf(spec, candidate, baseline)` is a tie. The test is symmetric: a swap of the two values swaps better and worse.\n * Two equal values are a tie, also two infinite values. A value `NaN` is an error.\n */\nexport function compareMeasure(candidate: number, baseline: number, spec: Pick<MeasureSpec, \"direction\" | \"minEffect\">): Verdict {\n  if (Number.isNaN(candidate) || Number.isNaN(baseline)) throw new RangeError(\"compareMeasure: a value is NaN\");\n  if (candidate === baseline) return \"tie\";\n  const delta = candidate - baseline;\n  if (!(Math.abs(delta) > minEffectOf(spec, candidate, baseline))) return \"tie\";\n  const better = spec.direction === \"lower\" ? delta < 0 : delta > 0;\n  return better ? \"better\" : \"worse\";\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/geometry.ts","../src/tolerance.ts","../src/input.ts","../src/turn.ts","../src/output.ts","../src/record.ts","../src/rules.ts","../src/measures.ts","../src/random.ts","../src/edges.ts"],"sourcesContent":["/** A side of a box. The y axis points down, so `top` has the smallest y. */\nexport type Side = \"top\" | \"right\" | \"bottom\" | \"left\";\n\n/** The sides in clockwise order, from the top. */\nexport const SIDES: readonly Side[] = [\"top\", \"right\", \"bottom\", \"left\"];\n\nexport interface Point {\n  readonly x: number;\n  readonly y: number;\n}\n\n/** A rectangle: its top-left corner and its size. */\nexport interface Rect {\n  readonly x: number;\n  readonly y: number;\n  readonly w: number;\n  readonly h: number;\n}\n\n/** A value for each side of a box. */\nexport interface Sides {\n  readonly top: number;\n  readonly right: number;\n  readonly bottom: number;\n  readonly left: number;\n}\n\n/**\n * A region. The forms and the rules are those of `docs/FORMAT.md` of `packing`.\n * A ring of a polygon closes without a copy of its first point.\n */\nexport type Region =\n  | { readonly kind: \"rect\"; readonly x: number; readonly y: number; readonly w: number; readonly h: number }\n  | {\n      readonly kind: \"polygon\";\n      readonly points: readonly (readonly [number, number])[];\n      readonly holes?: readonly (readonly (readonly [number, number])[])[];\n    }\n  | { readonly kind: \"circle\"; readonly cx: number; readonly cy: number; readonly r: number }\n  | { readonly kind: \"ellipse\"; readonly cx: number; readonly cy: number; readonly rx: number; readonly ry: number };\n\n/** A margin: one value for the four sides, or one value for each side. */\nexport type Margin = number | Sides;\n\n/** This function gives the value of each side of a margin. No margin gives 0 on each side. */\nexport function marginSides(margin: Margin | undefined): Sides {\n  if (margin === undefined) return { top: 0, right: 0, bottom: 0, left: 0 };\n  if (typeof margin === \"number\") return { top: margin, right: margin, bottom: margin, left: margin };\n  return margin;\n}\n\n/** This function gives the rectangle made larger by the margin on each side. */\nexport function grow(rect: Rect, margin: Margin | undefined): Rect {\n  const m = marginSides(margin);\n  return { x: rect.x - m.left, y: rect.y - m.top, w: rect.w + m.left + m.right, h: rect.h + m.top + m.bottom };\n}\n\n/** This function gives the bounding box of a region. */\nexport function boundsOf(region: Region): Rect {\n  switch (region.kind) {\n    case \"rect\":\n      return { x: region.x, y: region.y, w: region.w, h: region.h };\n    case \"circle\":\n      return { x: region.cx - region.r, y: region.cy - region.r, w: 2 * region.r, h: 2 * region.r };\n    case \"ellipse\":\n      return { x: region.cx - region.rx, y: region.cy - region.ry, w: 2 * region.rx, h: 2 * region.ry };\n    case \"polygon\": {\n      let x0 = Infinity;\n      let y0 = Infinity;\n      let x1 = -Infinity;\n      let y1 = -Infinity;\n      for (const [x, y] of region.points) {\n        x0 = Math.min(x0, x);\n        y0 = Math.min(y0, y);\n        x1 = Math.max(x1, x);\n        y1 = Math.max(y1, y);\n      }\n      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };\n    }\n  }\n}\n\n/** This function gives the region moved by `dx` and `dy`. */\nexport function translate(region: Region, dx: number, dy: number): Region {\n  switch (region.kind) {\n    case \"rect\":\n      return { ...region, x: region.x + dx, y: region.y + dy };\n    case \"circle\":\n    case \"ellipse\":\n      return { ...region, cx: region.cx + dx, cy: region.cy + dy };\n    case \"polygon\": {\n      const move = (ring: readonly (readonly [number, number])[]): [number, number][] => ring.map(([x, y]) => [x + dx, y + dy]);\n      return region.holes === undefined\n        ? { kind: \"polygon\", points: move(region.points) }\n        : { kind: \"polygon\", points: move(region.points), holes: region.holes.map(move) };\n    }\n  }\n}\n\n/**\n * This function gives the overlap of the insides of two rectangles on each axis.\n * A value of 0 or less on an axis is no overlap. Two rectangles with a common edge have an overlap of 0.\n */\nexport function overlapOf(a: Rect, b: Rect): { readonly x: number; readonly y: number } {\n  return {\n    x: Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x),\n    y: Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y),\n  };\n}\n","/** The epsilon for the float compares in an engine. */\nexport const EPS = 1e-6;\n\n/**\n * The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,\n * so a difference of two values can move by up to 0.001.\n */\nexport const RECORD_EPS = 1e-3;\n\n/**\n * The tolerance of each hard rule, in layout units. A record writes the tolerance that its run used,\n * in its field `tolerance`, next to `hard`.\n */\nexport interface Tolerance {\n  /** Two boxes with their margins break `no-overlap` when their insides overlap by more than this on each axis. */\n  readonly overlap: number;\n  /** A route breaks `no-pass-through` when a part longer than this is inside a box made this much smaller. */\n  readonly through: number;\n}\n\n/**\n * The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.\n * Routes are sampled curves that follow the margin line, so `through` is larger.\n */\nexport const DEFAULT_TOLERANCE: Tolerance = Object.freeze({ overlap: 0.001, through: 0.5 });\n","import type { Margin, Region, Side } from \"./geometry.ts\";\n\n/**\n * A port of a box: a place where edges go into the box.\n * With `x` and `y`, the port is fixed on the border of the box, relative to its top-left corner.\n * Without them, the router places the port on its `side`. Without a side, the router picks the side.\n */\nexport interface Port {\n  readonly id: string;\n  readonly side?: Side;\n  readonly x?: number;\n  readonly y?: number;\n}\n\n/** A box of an input. In the packer, its name is item. */\nexport interface LayoutBox {\n  readonly id: string;\n  readonly w: number;\n  readonly h: number;\n  /** The packer writes the position. The router reads it. */\n  readonly x?: number;\n  readonly y?: number;\n  /** A locked box keeps `x` and `y`. The packer reads it as an obstacle. */\n  readonly locked?: boolean;\n  /** The reading order. Without it, the order of the array is the rank. */\n  readonly rank?: number;\n  readonly parent?: string;\n  readonly group?: string;\n  /** A region relative to the origin of the box. Without it, the box is the rectangle `w` by `h`. */\n  readonly shape?: Region;\n  readonly ports?: readonly Port[];\n  /** A ring around the box. No other box enters it. Only a route from a port of the box enters it, at a right angle. */\n  readonly margin?: Margin;\n  /** The packer can turn the box by 90 degrees. The output has the turned box and ports. */\n  readonly turnable?: boolean;\n  /** The free data of the node. The grouping rule `keys` of `highways` reads `data.group`. */\n  readonly data?: Readonly<Record<string, unknown>>;\n}\n\n/** The packer name of a box. It is the same type. */\nexport type Item = LayoutBox;\n\n/** An edge between two boxes, with optional ports. */\nexport interface LayoutEdge {\n  readonly id: string;\n  readonly source: string;\n  readonly target: string;\n  readonly sourcePort?: string;\n  readonly targetPort?: string;\n  readonly data?: Readonly<Record<string, unknown>>;\n}\n\n/** The container. `fixed` tells which sides of the size stay. */\nexport interface LayoutContainer {\n  readonly w?: number;\n  readonly h?: number;\n  readonly fixed: \"size\" | \"width\" | \"height\" | \"none\";\n  /** The target aspect: the width divided by the height. The default is 1. */\n  readonly aspect?: number;\n  /** The weight of the aspect error in the objective. 0 gives the least area. The default is 1. */\n  readonly aspectWeight?: number;\n  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */\n  readonly shape?: Region;\n  /** The space between the border and the boxes with their margins. */\n  readonly inset?: number;\n}\n\n/** An area that boxes and routes avoid. Without `move`, it stays. With `move`, the packer can move it for `cost` times the distance. */\nexport interface Obstacle {\n  readonly id: string;\n  readonly region: Region;\n  readonly move?: { readonly cost: number };\n}\n\n/** The generator of an input. The same name, version, parameters and seed give the same file, byte for byte. */\nexport interface LayoutGenerator {\n  readonly name: string;\n  readonly version: number;\n  readonly params: Readonly<Record<string, unknown>>;\n  readonly seed: number;\n}\n\n/** The cell of an input in the taxonomy: one value for each dimension. The dimensions are in `docs/FORMAT.md` of `packing`. */\nexport interface LayoutCell {\n  readonly containerSize?: \"fixed\" | \"freeHeight\" | \"freeWidth\" | \"freeAspect\" | \"freeArea\";\n  readonly containerShape?: \"rect\" | \"convex\" | \"polygon\" | \"circle\" | \"ellipse\" | \"holes\";\n  readonly obstacles?: \"none\" | \"center\" | \"scattered\" | \"wall\" | \"corridors\" | \"touching\" | \"edge\";\n  readonly sizes?: \"identical\" | \"uniform\" | \"heavyTail\" | \"bimodal\" | \"extremeAspect\" | \"nearIdentical\";\n  readonly count?: \"1\" | \"10\" | \"100\" | \"1k\" | \"10k\";\n  readonly mode?: \"offline\" | \"online\" | \"incremental\";\n  readonly edgeDensity?: \"sparse\" | \"medium\" | \"dense\";\n  readonly edgeShape?: \"random\" | \"clustered\" | \"hubChain\" | \"longRange\" | \"tree\" | \"bundled\";\n  readonly groups?: \"none\" | \"flat\" | \"nested\";\n  readonly ports?: \"free\" | \"sides\" | \"fixed\";\n}\n\n/** An input of the corpus: the format `layout-input/1`. */\nexport interface LayoutInput {\n  readonly schema: \"layout-input/1\";\n  readonly id: string;\n  readonly set?: string;\n  readonly family?: string;\n  readonly seed?: number;\n  /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */\n  readonly source?: string;\n  /** The first 16 hex characters of the SHA-256 of the canonical file without this field. */\n  readonly hash?: string;\n  /** The generator of the input. `null` or no value tells that a person made the input. */\n  readonly generator?: LayoutGenerator | null;\n  /** The steps that changed the input after its generator, in their order. `edgeStep` adds one. */\n  readonly steps?: readonly LayoutGenerator[];\n  readonly cell?: LayoutCell;\n  /** The place of the input in a sequence of changes. */\n  readonly step?: number;\n  /** A router input can have no container. */\n  readonly container?: LayoutContainer;\n  /** The free space between two boxes with their margins. Routes use it. */\n  readonly gap?: number;\n  readonly boxes: readonly LayoutBox[];\n  readonly edges?: readonly LayoutEdge[];\n  readonly obstacles?: readonly Obstacle[];\n  /**\n   * A variant names its base input and its change.\n   * With `packed`, the variant is the packed output of its base input: the router routes the positions of that pack.\n   */\n  readonly base?: string;\n  readonly change?: \"add\" | \"remove\" | \"resize\" | \"reorder\" | \"packed\";\n}\n\n/** The input of a packer: a `layout-input/1` file without the edges. */\nexport interface PackInput {\n  readonly container: LayoutContainer;\n  readonly items: readonly Item[];\n  readonly obstacles?: readonly Obstacle[];\n  readonly gap?: number;\n}\n\n/** This function gives the packer input of a file. An input without a container gets `{ fixed: \"none\" }`, so the packer picks the size. */\nexport function toPackInput(input: LayoutInput): PackInput {\n  return {\n    container: input.container ?? { fixed: \"none\" },\n    items: input.boxes,\n    ...(input.obstacles === undefined ? {} : { obstacles: input.obstacles }),\n    ...(input.gap === undefined ? {} : { gap: input.gap }),\n  };\n}\n","import { SIDES, marginSides, type Margin, type Region, type Side } from \"./geometry.ts\";\nimport type { LayoutBox, Port } from \"./input.ts\";\n\n/*\n * The turn: 90 degrees clockwise, with the y axis down. The turned box has `w` and `h` swapped,\n * and its top-left corner stays at the position of the box. A point (px, py) of a box of height h\n * goes to (h - py, px). Thus the top-left corner goes to the top-right corner, and each side moves\n * one step clockwise: top to right, right to bottom, bottom to left, left to top.\n */\n\n/** This function gives the side after a turn of 90 degrees clockwise. */\nexport function turnSide(side: Side): Side {\n  return SIDES[(SIDES.indexOf(side) + 1) % 4]!;\n}\n\n/** This function gives a point of a box of height `h` after the turn. */\nexport function turnPoint(x: number, y: number, h: number): [number, number] {\n  return [h - y, x];\n}\n\n/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */\nexport function turnPort(port: Port, h: number): Port {\n  const { side, x, y, ...rest } = port;\n  return {\n    ...rest,\n    ...(side === undefined ? {} : { side: turnSide(side) }),\n    ...(y === undefined ? {} : { x: h - y }),\n    ...(x === undefined ? {} : { y: x }),\n  };\n}\n\n/** This function gives a margin after the turn: the value of each side moves one side clockwise. */\nexport function turnMargin(margin: Margin): Margin {\n  if (typeof margin === \"number\") return margin;\n  const m = marginSides(margin);\n  return { top: m.left, right: m.top, bottom: m.right, left: m.bottom };\n}\n\n/** This function gives a region relative to the origin of a box of height `h` after the turn. */\nexport function turnRegion(region: Region, h: number): Region {\n  switch (region.kind) {\n    case \"rect\":\n      return { kind: \"rect\", x: h - region.y - region.h, y: region.x, w: region.h, h: region.w };\n    case \"circle\":\n      return { ...region, cx: h - region.cy, cy: region.cx };\n    case \"ellipse\":\n      return { kind: \"ellipse\", cx: h - region.cy, cy: region.cx, rx: region.ry, ry: region.rx };\n    case \"polygon\": {\n      const turn = (ring: readonly (readonly [number, number])[]): [number, number][] => ring.map(([x, y]) => turnPoint(x, y, h));\n      return region.holes === undefined\n        ? { kind: \"polygon\", points: turn(region.points) }\n        : { kind: \"polygon\", points: turn(region.points), holes: region.holes.map(turn) };\n    }\n  }\n}\n\n/** This function gives a box after the turn: the size, the ports, the margin and the shape turn. The position stays. */\nexport function turnBox(box: LayoutBox): LayoutBox {\n  return {\n    ...box,\n    w: box.h,\n    h: box.w,\n    ...(box.ports === undefined ? {} : { ports: box.ports.map((p) => turnPort(p, box.h)) }),\n    ...(box.margin === undefined ? {} : { margin: turnMargin(box.margin) }),\n    ...(box.shape === undefined ? {} : { shape: turnRegion(box.shape, box.h) }),\n  };\n}\n","import { boundsOf, translate } from \"./geometry.ts\";\nimport type { LayoutInput } from \"./input.ts\";\nimport { turnBox } from \"./turn.ts\";\n\n/** The position of one item. `turn` is 90 when the packer turned a turnable item. */\nexport interface Placement {\n  readonly id: string;\n  readonly x: number;\n  readonly y: number;\n  readonly turn?: 0 | 90;\n}\n\n/** The facts of one stage of a strategy, for the records and the site. */\nexport interface StageTrace {\n  readonly id: string;\n  readonly ms?: number;\n  readonly measures?: Readonly<Record<string, number>>;\n}\n\n/** The output of a packer. It does not change the input. */\nexport interface PackOutput {\n  readonly placements: readonly Placement[];\n  /** The ids of the items that the packer did not place. */\n  readonly overflow: readonly string[];\n  /** The size of the container after the pack. For a free size, the size that the search found. */\n  readonly size: { readonly w: number; readonly h: number };\n  /** The new top-left corner of the bounding box of each obstacle that moved. */\n  readonly moved: readonly { readonly id: string; readonly x: number; readonly y: number }[];\n  readonly trace?: readonly StageTrace[];\n}\n\n/**\n * This function gives the input with the output of a packer applied. Each placed box gets its position.\n * A turned box gets its turned size, ports, margin and shape. Each moved obstacle moves.\n * The container gets the size of the output. The router reads this result. It does not read `turn`.\n */\nexport function applyPack(input: LayoutInput, output: PackOutput): LayoutInput {\n  const at = new Map(output.placements.map((p) => [p.id, p]));\n  const moved = new Map(output.moved.map((m) => [m.id, m]));\n  const boxes = input.boxes.map((box) => {\n    const p = at.get(box.id);\n    if (p === undefined) return box;\n    const turned = p.turn === 90 ? turnBox(box) : box;\n    return { ...turned, x: p.x, y: p.y };\n  });\n  const obstacles = input.obstacles?.map((o) => {\n    const m = moved.get(o.id);\n    if (m === undefined) return o;\n    const b = boundsOf(o.region);\n    return { ...o, region: translate(o.region, m.x - b.x, m.y - b.y) };\n  });\n  return {\n    ...input,\n    container: { ...(input.container ?? { fixed: \"none\" }), w: output.size.w, h: output.size.h },\n    boxes,\n    ...(obstacles === undefined ? {} : { obstacles }),\n  };\n}\n","import type { Tolerance } from \"./tolerance.ts\";\nimport type { LayoutInput } from \"./input.ts\";\n\n/** The stage of a record: the packer, the router, or both together. */\nexport type Stage = \"pack\" | \"route\" | \"joint\";\n\n/** One run of one strategy on one input and seed: the format `layout-record/1`. A run writes one line of JSON Lines. */\nexport interface LayoutRecord {\n  readonly schema: \"layout-record/1\";\n  readonly stage: Stage;\n  readonly step: string;\n  readonly strategy: string;\n  /** The options in full, with the defaults. */\n  readonly options: Readonly<Record<string, unknown>>;\n  readonly corpus: string;\n  /** The id of the input. */\n  readonly input: string;\n  /** The `hash` of the input file. */\n  readonly inputHash: string;\n  readonly set: string;\n  readonly seed: number;\n  readonly nodes: number;\n  readonly edges: number;\n  /** The value of each measure, by its name: `pack.*`, `route.*` or `joint.*`. */\n  readonly measures: Readonly<Record<string, number>>;\n  /** The count of the breaks of each hard rule. A good run has 0 for each rule. */\n  readonly hard: Readonly<Record<string, number>>;\n  /** The tolerance of each hard rule of the run. */\n  readonly tolerance?: Readonly<Partial<Tolerance>>;\n  /** `true` when two runs with the same seed give the same positions. */\n  readonly deterministic: boolean;\n  /** The id of the prediction that was written before the run. */\n  readonly prediction?: string;\n  /** The median of `msRuns`, or the time of the one run. */\n  readonly ms: number;\n  /** The time of each timed repeat, in milliseconds. */\n  readonly msRuns?: readonly number[];\n  /**\n   * The first 16 hex characters of the SHA-256 of the canonical output of the stage.\n   * The packer hashes its placements by the order of the ids. The router hashes its routes by the order of the edge ids.\n   */\n  readonly outputHash?: string;\n  /** The facts of the computer of the run. */\n  readonly env?: RunEnv;\n  /** The reason when the strategy did not run, for example an input over its `maxNodes`. Then the record has no measures. */\n  readonly skipped?: string;\n  readonly commit?: string;\n}\n\n/**\n * The values that a strategy supports, for each dimension of a taxonomy.\n * The dimension names are in `docs/FORMAT.md` of `packing` and `docs/LAYOUT-RECORDS.md` of `highways`.\n */\nexport type Supports = Readonly<Record<string, readonly string[]>>;\n\n/** The facts of the computer of a run. */\nexport interface RunEnv {\n  readonly node: string;\n  readonly os: string;\n  readonly arch: string;\n  /** The name of the runner, for example `ubuntu-latest` or `local`. */\n  readonly runner: string;\n  /** The model of the processor. */\n  readonly cpu: string;\n  /** The count of the logical processors. */\n  readonly cpus: number;\n}\n\n/** The facts of a run that the input does not give. */\nexport type RunFacts = Omit<LayoutRecord, \"schema\" | \"input\" | \"inputHash\" | \"set\" | \"nodes\" | \"edges\">;\n\n/** This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges. */\nexport function toLayoutRecord(input: LayoutInput, run: RunFacts): LayoutRecord {\n  return {\n    schema: \"layout-record/1\",\n    ...run,\n    input: input.id,\n    inputHash: input.hash ?? \"\",\n    set: input.set ?? \"\",\n    nodes: input.boxes.length,\n    edges: input.edges?.length ?? 0,\n  };\n}\n","import { boundsOf, grow, overlapOf, type Rect, type Region } from \"./geometry.ts\";\nimport type { LayoutBox, LayoutInput, Obstacle } from \"./input.ts\";\nimport { applyPack, type PackOutput } from \"./output.ts\";\nimport { DEFAULT_TOLERANCE, RECORD_EPS } from \"./tolerance.ts\";\n\n/** This function gives the area of a placed box: its shape or its rectangle, at its position. A box without a position gives `undefined`. */\nexport function placedRect(box: LayoutBox): Rect | undefined {\n  if (box.x === undefined || box.y === undefined) return undefined;\n  if (box.shape === undefined) return { x: box.x, y: box.y, w: box.w, h: box.h };\n  const b = boundsOf(box.shape);\n  return { x: box.x + b.x, y: box.y + b.y, w: b.w, h: b.h };\n}\n\n/**\n * This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.\n * A box with a shape counts as its bounding box. That area is larger, thus the count is safe.\n */\nexport function countOverlaps(boxes: readonly LayoutBox[], tolerance: number = DEFAULT_TOLERANCE.overlap): number {\n  const rects: Rect[] = [];\n  for (const box of boxes) {\n    const r = placedRect(box);\n    if (r !== undefined) rects.push(grow(r, box.margin));\n  }\n  rects.sort((a, b) => a.x - b.x);\n  let count = 0;\n  for (let i = 0; i < rects.length; i++) {\n    const a = rects[i]!;\n    for (let j = i + 1; j < rects.length; j++) {\n      const b = rects[j]!;\n      if (b.x >= a.x + a.w - tolerance) break;\n      const o = overlapOf(a, b);\n      if (o.x > tolerance && o.y > tolerance) count++;\n    }\n  }\n  return count;\n}\n\n/**\n * This function counts the placed boxes that go out of the container.\n * Each box with its margin must stay inside the container made smaller by `inset`. Only the fixed sides of the size count. A shaped container counts as its bounding box.\n * An input without a container gives 0.\n */\nexport function countOutside(input: LayoutInput, tolerance: number = DEFAULT_TOLERANCE.overlap): number {\n  const c = input.container;\n  if (c === undefined) return 0;\n  const area = c.shape === undefined ? { x: 0, y: 0, w: c.w ?? Infinity, h: c.h ?? Infinity } : boundsOf(c.shape);\n  const inset = c.inset ?? 0;\n  const fixW = c.fixed === \"size\" || c.fixed === \"width\";\n  const fixH = c.fixed === \"size\" || c.fixed === \"height\";\n  let count = 0;\n  for (const box of input.boxes) {\n    const r0 = placedRect(box);\n    if (r0 === undefined) continue;\n    const r = grow(r0, box.margin);\n    const outX = r.x < area.x + inset - tolerance || r.x + r.w > area.x + area.w - inset + tolerance;\n    const outY = r.y < area.y + inset - tolerance || r.y + r.h > area.y + area.h - inset + tolerance;\n    if ((fixW && outX) || (fixH && outY)) count++;\n  }\n  return count;\n}\n\n/** This function counts the fixed ports that are not on the border of their box, with the epsilon of a written file. A port without a side does not count. */\nexport function countPortsOffBorder(boxes: readonly LayoutBox[], eps: number = RECORD_EPS): number {\n  let count = 0;\n  for (const box of boxes) {\n    for (const p of box.ports ?? []) {\n      if (p.x === undefined || p.y === undefined || p.side === undefined) continue;\n      const along = p.side === \"top\" || p.side === \"bottom\" ? p.x : p.y;\n      const length = p.side === \"top\" || p.side === \"bottom\" ? box.w : box.h;\n      const across = { top: p.y, bottom: p.y - box.h, left: p.x, right: p.x - box.w }[p.side];\n      if (Math.abs(across) > eps || along < -eps || along > length + eps) count++;\n    }\n  }\n  return count;\n}\n\n/** The count of the breaks of each hard rule of a pack. */\nexport interface PackHard {\n  readonly \"no-overlap\": number;\n  readonly \"in-container\": number;\n  readonly \"locked-kept\": number;\n  readonly complete: number;\n}\n\n/** This function tells if the inside of `region` and the inside of `rect` have a common point. */\nexport function regionHitsRect(region: Region, rect: Rect): boolean {\n  if (rect.w <= 0 || rect.h <= 0) return false;\n  switch (region.kind) {\n    case \"rect\": {\n      const o = overlapOf(region, rect);\n      return o.x > 0 && o.y > 0;\n    }\n    case \"circle\":\n      return circleHitsRect(region.cx, region.cy, region.r, region.r, rect);\n    case \"ellipse\":\n      return circleHitsRect(region.cx, region.cy, region.rx, region.ry, rect);\n    case \"polygon\": {\n      const rings = [region.points, ...(region.holes ?? [])];\n      const inside = (x: number, y: number): boolean => x > rect.x && x < rect.x + rect.w && y > rect.y && y < rect.y + rect.h;\n      if (region.points.some(([x, y]) => inside(x, y))) return true;\n      for (const ring of rings) {\n        for (let i = 0; i < ring.length; i++) {\n          const a = ring[i]!;\n          const b = ring[(i + 1) % ring.length]!;\n          const m = clipMid(a[0], a[1], b[0], b[1], rect);\n          if (m !== undefined && inside(m[0], m[1])) return true;\n        }\n      }\n      return pointInRings(rect.x + rect.w / 2, rect.y + rect.h / 2, rings);\n    }\n  }\n}\n\n/** An ellipse with the radii `rx` and `ry` scales to a unit circle. The rectangle scales with it. */\nfunction circleHitsRect(cx: number, cy: number, rx: number, ry: number, rect: Rect): boolean {\n  if (rx <= 0 || ry <= 0) return false;\n  const x0 = (rect.x - cx) / rx;\n  const x1 = (rect.x + rect.w - cx) / rx;\n  const y0 = (rect.y - cy) / ry;\n  const y1 = (rect.y + rect.h - cy) / ry;\n  const dx = Math.max(x0, 0, -x1);\n  const dy = Math.max(y0, 0, -y1);\n  return dx * dx + dy * dy < 1;\n}\n\n/** This function gives the middle of the part of a segment inside a rectangle, or `undefined` when that part is a point or empty. */\nfunction clipMid(ax: number, ay: number, bx: number, by: number, r: Rect): readonly [number, number] | undefined {\n  let t0 = 0;\n  let t1 = 1;\n  const dx = bx - ax;\n  const dy = by - ay;\n  const edges: readonly (readonly [number, number])[] = [\n    [-dx, ax - r.x],\n    [dx, r.x + r.w - ax],\n    [-dy, ay - r.y],\n    [dy, r.y + r.h - ay],\n  ];\n  for (const [p, q] of edges) {\n    if (p === 0) {\n      if (q < 0) return undefined;\n    } else if (p < 0) {\n      t0 = Math.max(t0, q / p);\n    } else {\n      t1 = Math.min(t1, q / p);\n    }\n  }\n  if (t1 <= t0) return undefined;\n  const t = (t0 + t1) / 2;\n  return [ax + t * dx, ay + t * dy];\n}\n\n/** The even-odd rule over the outer ring and the holes. */\nfunction pointInRings(x: number, y: number, rings: readonly (readonly (readonly [number, number])[])[]): boolean {\n  let inside = false;\n  for (const ring of rings) {\n    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {\n      const [xi, yi] = ring[i]!;\n      const [xj, yj] = ring[j]!;\n      if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n    }\n  }\n  return inside;\n}\n\n/**\n * This function counts the pairs of a placed box and an obstacle that overlap by more than `tolerance`.\n * The box counts with its margin. A box with a shape counts as its bounding box.\n */\nexport function countObstacleHits(\n  boxes: readonly LayoutBox[],\n  obstacles: readonly Obstacle[] | undefined,\n  tolerance: number = DEFAULT_TOLERANCE.overlap,\n): number {\n  if (obstacles === undefined || obstacles.length === 0) return 0;\n  let count = 0;\n  for (const box of boxes) {\n    const r0 = placedRect(box);\n    if (r0 === undefined) continue;\n    const r = grow(r0, box.margin);\n    const small = { x: r.x + tolerance, y: r.y + tolerance, w: r.w - 2 * tolerance, h: r.h - 2 * tolerance };\n    for (const o of obstacles) if (regionHitsRect(o.region, small)) count++;\n  }\n  return count;\n}\n\n/**\n * This function gives the count of each hard rule of the output of a packer.\n * It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.\n * `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle.\n * A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.\n * A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.\n * Another box without a placement that is not in `overflow` breaks `complete`.\n */\nexport function packHard(input: LayoutInput, output: PackOutput, tolerance: number = DEFAULT_TOLERANCE.overlap): PackHard {\n  const after = applyPack(input, output);\n  const placed = new Set(output.placements.map((p) => p.id));\n  const out = new Set(output.overflow);\n  const was = new Map(input.boxes.map((b) => [b.id, b]));\n  let lockedMoved = 0;\n  let incomplete = 0;\n  const kept: LayoutBox[] = [];\n  for (const box of after.boxes) {\n    const old = was.get(box.id);\n    if (old?.locked === true) {\n      if (old.x === undefined || old.y === undefined) continue;\n      const moved = Math.abs(old.x - (box.x ?? old.x)) > RECORD_EPS || Math.abs(old.y - (box.y ?? old.y)) > RECORD_EPS;\n      if (!placed.has(box.id) || moved) lockedMoved++;\n      kept.push(box);\n    } else if (placed.has(box.id)) {\n      kept.push(box);\n    } else if (!out.has(box.id)) {\n      incomplete++;\n    }\n  }\n  return {\n    \"no-overlap\": countOverlaps(kept, tolerance) + countObstacleHits(kept, after.obstacles, tolerance),\n    \"in-container\": countOutside({ ...after, boxes: kept }, tolerance),\n    \"locked-kept\": lockedMoved,\n    complete: incomplete,\n  };\n}\n\n/**\n * This function gives the problems of an input file. An empty list tells that the file is good.\n * A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.\n */\nexport function checkInput(input: LayoutInput): readonly string[] {\n  const problems: string[] = [];\n  const ids = new Set<string>();\n  for (const box of input.boxes) {\n    if (ids.has(box.id)) problems.push(`box ${box.id}: the id is not unique`);\n    ids.add(box.id);\n    if (!(box.w > 0 && box.h > 0 && Number.isFinite(box.w) && Number.isFinite(box.h))) problems.push(`box ${box.id}: the size is not positive and finite`);\n    if (box.locked === true && (box.x === undefined || box.y === undefined)) problems.push(`box ${box.id}: a locked box has no position`);\n  }\n  if (countPortsOffBorder(input.boxes) > 0) problems.push(\"a fixed port is not on the border of its box\");\n  for (const edge of input.edges ?? []) {\n    if (!ids.has(edge.source) || !ids.has(edge.target)) problems.push(`edge ${edge.id}: a box of the edge is not in the input`);\n  }\n  return problems;\n}\n","import { RECORD_EPS } from \"./tolerance.ts\";\n\n/** The direction of a measure: the side of the better values. */\nexport type Direction = \"lower\" | \"higher\";\n\n/**\n * The facts of one measure: its unit, its direction and its range.\n * `floor` and `tol` are the parameters of the floor rule of the promotion rule (`docs/PROMOTION.md` of `highways`).\n * Each engine exports the specs of its own measures. This package exports the specs of the `joint.*` measures.\n */\nexport interface MeasureSpec<Id extends string = string> {\n  readonly id: Id;\n  readonly unit: string;\n  readonly direction: Direction;\n  /** The lowest value. */\n  readonly min: number;\n  /** The highest value. The value `Infinity` tells that the measure has no upper limit. */\n  readonly max: number;\n  /** The family of the measure in the measure note of its engine. */\n  readonly family?: string;\n  /** The best value. Without it, the measure has no floor. */\n  readonly floor?: number;\n  /** The absolute tolerance at the floor. */\n  readonly tol?: number;\n  /**\n   * The smallest change that counts as better or worse. A number is an absolute change. `{ rel }` is a share of the larger of the two values.\n   * `docs/JOINT-MEASURES.md` gives the reason of each joint value.\n   */\n  readonly minEffect?: number | { readonly rel: number };\n  /** The role of the measure in the joint selector. */\n  readonly role?: \"guard\" | \"change-guard\" | \"diagnostic\" | \"time\";\n}\n\n/** The id of a joint measure. `docs/JOINT-MEASURES.md` gives the definitions. */\nexport type JointMeasureId =\n  | \"joint.fill\"\n  | \"joint.aspectError\"\n  | \"joint.spill\"\n  | \"joint.straight.crossings\"\n  | \"joint.straight.length\"\n  | \"joint.stability.mean\"\n  | \"joint.stability.moved\"\n  | \"joint.proxy.rank\"\n  | \"joint.ms\";\n\n/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */\nexport const JOINT_MEASURES: readonly MeasureSpec<JointMeasureId>[] = Object.freeze([\n  { id: \"joint.fill\", minEffect: 0.001, unit: \"0 to 1\", direction: \"higher\", min: 0, max: 1, floor: 1, role: \"guard\" },\n  { id: \"joint.aspectError\", minEffect: 0.01, unit: \"natural log\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.01, role: \"guard\" },\n  { id: \"joint.spill\", minEffect: 0.001, unit: \"0 to 1\", direction: \"lower\", min: 0, max: 1, floor: 0, tol: 0.001, role: \"guard\" },\n  { id: \"joint.straight.crossings\", minEffect: 0, unit: \"count\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0, role: \"guard\" },\n  { id: \"joint.straight.length\", minEffect: 0.01, unit: \"S for each edge\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.01, role: \"guard\" },\n  { id: \"joint.stability.mean\", minEffect: 0.005, unit: \"W\", direction: \"lower\", min: 0, max: Infinity, floor: 0, tol: 0.005, role: \"change-guard\" },\n  { id: \"joint.stability.moved\", minEffect: 0.02, unit: \"0 to 1\", direction: \"lower\", min: 0, max: 1, floor: 0, tol: 0.02, role: \"change-guard\" },\n  { id: \"joint.proxy.rank\", unit: \"-1 to 1\", direction: \"higher\", min: -1, max: 1, role: \"diagnostic\" },\n  { id: \"joint.ms\", unit: \"milliseconds\", direction: \"lower\", min: 0, max: Infinity, role: \"time\" },\n] as const);\n\n/** The threshold of `joint.stability.moved`, in widths `W` of the base. */\nexport const JOINT_MOVED_MIN = 0.01;\n\n/** The result of a compare of a candidate with a baseline on one measure. A tie is not better. */\nexport type Verdict = \"better\" | \"worse\" | \"tie\";\n\n/**\n * This function gives the smallest change of a measure that counts between the values `a` and `b`.\n * The value is `max(RECORD_EPS, minEffect)`, or `max(RECORD_EPS, rel * max(|a|, |b|))` for a relative `minEffect`.\n * The larger value makes the threshold the same after a swap of `a` and `b`.\n */\nexport function minEffectOf(spec: Pick<MeasureSpec, \"minEffect\">, a = 0, b = 0): number {\n  const m = spec.minEffect ?? 0;\n  const t = typeof m === \"number\" ? m : m.rel * Math.max(Math.abs(a), Math.abs(b));\n  return Math.max(RECORD_EPS, Number.isFinite(t) ? t : 0);\n}\n\n/**\n * This function compares the value `candidate` with the value `baseline` of one measure on one input.\n * A change of at most `minEffectOf(spec, candidate, baseline)` is a tie. The test is symmetric: a swap of the two values swaps better and worse.\n * Two equal values are a tie, also two infinite values. A value `NaN` is an error.\n */\nexport function compareMeasure(candidate: number, baseline: number, spec: Pick<MeasureSpec, \"direction\" | \"minEffect\">): Verdict {\n  if (Number.isNaN(candidate) || Number.isNaN(baseline)) throw new RangeError(\"compareMeasure: a value is NaN\");\n  if (candidate === baseline) return \"tie\";\n  const delta = candidate - baseline;\n  if (!(Math.abs(delta) > minEffectOf(spec, candidate, baseline))) return \"tie\";\n  const better = spec.direction === \"lower\" ? delta < 0 : delta > 0;\n  return better ? \"better\" : \"worse\";\n}\n","/** This function gives a generator of random numbers in [0, 1). It is `mulberry32`, as in `docs/FORMAT.md` of `packing`. */\nexport function mulberry32(seed: number): () => number {\n  let s = seed >>> 0;\n  return () => {\n    s = (s + 0x6d2b79f5) | 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/** This function gives the FNV-1a hash of 32 bits of the UTF-8 bytes of a string. */\nexport function fnv1a32(text: string): number {\n  let h = 0x811c9dc5;\n  for (const b of utf8(text)) h = Math.imul(h ^ b, 0x01000193) >>> 0;\n  return h;\n}\n\n/** The UTF-8 bytes of a string. The package has no runtime dependencies, thus it does not use `TextEncoder`. */\nfunction utf8(text: string): number[] {\n  const bytes: number[] = [];\n  for (const ch of text) {\n    const c = ch.codePointAt(0)!;\n    if (c < 0x80) bytes.push(c);\n    else if (c < 0x800) bytes.push(0xc0 | (c >> 6), 0x80 | (c & 63));\n    else if (c < 0x10000) bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));\n    else bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));\n  }\n  return bytes;\n}\n\n/** This function gives the generator of one step of a seeded generator: `mulberry32(fnv1a32(\"<seed>:<step>\"))`. */\nexport function stepRandom(seed: number, step: string): () => number {\n  return mulberry32(fnv1a32(`${seed}:${step}`));\n}\n\n/** This function gives a whole number from `lo` to `hi`, both included. */\nexport function randomInt(r: () => number, lo: number, hi: number): number {\n  return lo + Math.floor(r() * (hi - lo + 1));\n}\n","import { SIDES, type Side } from \"./geometry.ts\";\nimport type { LayoutBox, LayoutEdge, LayoutGenerator, LayoutInput, Port } from \"./input.ts\";\nimport { randomInt, stepRandom } from \"./random.ts\";\n\n/**\n * The shape of the edges of `edgeStep`. The values are the cells of `edgeShape`, and `hubs`.\n * `hubs` waits for the next breaking change to become a value of `LayoutCell.edgeShape`.\n */\nexport type EdgeShape = \"random\" | \"clustered\" | \"hubChain\" | \"hubs\" | \"longRange\" | \"tree\" | \"bundled\";\n\n/** The parameters of `edgeStep`. */\nexport interface EdgeStepParams {\n  readonly edgeDensity: \"sparse\" | \"medium\" | \"dense\";\n  readonly edgeShape: EdgeShape;\n  /** The default is `none`. */\n  readonly groups?: \"none\" | \"flat\" | \"nested\";\n  /** The default is `free`. */\n  readonly ports?: \"free\" | \"sides\" | \"fixed\";\n  /** The order of the hubs of `hubs` and `tree`: the largest box first, or a random order. The default is `area`. */\n  readonly hubBy?: \"area\" | \"random\";\n}\n\n/** The mean count of the edges of each box for each value of `edgeDensity`. */\nexport const EDGE_DENSITY: Readonly<Record<EdgeStepParams[\"edgeDensity\"], number>> = Object.freeze({ sparse: 0.5, medium: 1.5, dense: 4 });\n\n/** The version of `edgeStep`. A change of its output gives a new version. */\nexport const EDGE_STEP_VERSION = 1;\n\nconst CLUSTER = 8;\nconst CHAIN = 32;\nconst INSIDE = 0.85;\nconst FAN_SHARE = 0.6;\nconst FIXED_SHARE = 0.2;\nconst COLLECTIONS = [\"users\", \"orders\", \"items\", \"events\"] as const;\n\nconst round3 = (x: number): number => Math.round(x * 1000) / 1000;\n\n/**\n * This function gives the input with edges, groups and ports from its topology alone: a joint input has no positions before the pack.\n * The random numbers come from the steps `edges` and `ports` of `seed`. The function appends its stamp to `steps`, and removes the old `hash`.\n * The rules of each shape are in `docs/JOINT-CORPUS.md`.\n */\nexport function edgeStep(input: LayoutInput, params: EdgeStepParams, seed: number = input.seed ?? 0): LayoutInput {\n  if ((input.edges?.length ?? 0) > 0) throw new RangeError(\"edgeStep: the input has edges already\");\n  const full: Required<EdgeStepParams> = { groups: \"none\", ports: \"free\", hubBy: \"area\", ...params };\n  const n = input.boxes.length;\n  const r = stepRandom(seed, \"edges\");\n\n  const perm = input.boxes.map((_, i) => i);\n  for (let i = n - 1; i > 0; i--) {\n    const j = randomInt(r, 0, i);\n    [perm[i], perm[j]] = [perm[j]!, perm[i]!];\n  }\n  const clusterOf: number[] = new Array<number>(n);\n  perm.forEach((box, p) => (clusterOf[box] = Math.floor(p / CLUSTER)));\n  const clusters = Math.ceil(n / CLUSTER);\n  const members = (c: number): readonly number[] => perm.slice(c * CLUSTER, (c + 1) * CLUSTER);\n  const collectionOf =\n    full.edgeShape === \"bundled\"\n      ? clusterOf.map((c) => `${COLLECTIONS[c % COLLECTIONS.length]!}-${c}`)\n      : input.boxes.map(() => COLLECTIONS[randomInt(r, 0, COLLECTIONS.length - 1)]!);\n  const area = (i: number): number => input.boxes[i]!.w * input.boxes[i]!.h;\n  const rank = full.hubBy === \"area\" ? input.boxes.map((_, i) => i).sort((a, b) => area(b) - area(a) || a - b) : perm;\n\n  const pairs: [number, number][] = [];\n  const seen = new Set<string>();\n  const add = (u: number, v: number): void => {\n    const key = u < v ? `${u}-${v}` : `${v}-${u}`;\n    if (u === v || seen.has(key)) return;\n    seen.add(key);\n    pairs.push([u, v]);\n  };\n  const anyBox = (): number => randomInt(r, 0, n - 1);\n  const inCluster = (c: number): number => {\n    const m = members(c);\n    return m[randomInt(r, 0, m.length - 1)]!;\n  };\n  const otherCluster = (c: number): number => {\n    const o = randomInt(r, 0, clusters - 2);\n    return o >= c ? o + 1 : o;\n  };\n  const target = Math.min(Math.round(n * EDGE_DENSITY[full.edgeDensity]), (n * (n - 1)) / 2);\n  const fill = (pick: () => [number, number]): void => {\n    for (let tries = 0; pairs.length < target && tries < target * 30; tries++) add(...pick());\n  };\n  const clustered = (): [number, number] => {\n    const u = anyBox();\n    return [u, r() < INSIDE ? inCluster(clusterOf[u]!) : anyBox()];\n  };\n\n  if (n >= 2) {\n    switch (full.edgeShape) {\n      case \"random\":\n        fill(() => [anyBox(), anyBox()]);\n        break;\n      case \"clustered\":\n        fill(clustered);\n        break;\n      case \"longRange\":\n        fill(() => {\n          const u = anyBox();\n          return [u, clusters > 1 ? inCluster(otherCluster(clusterOf[u]!)) : anyBox()];\n        });\n        break;\n      case \"hubs\":\n        fill(() => [anyBox(), rank[Math.floor(n * r() ** 3)]!]);\n        break;\n      case \"tree\":\n        for (let i = 1; i < n; i++) add(rank[randomInt(r, 0, i - 1)]!, rank[i]!);\n        break;\n      case \"hubChain\": {\n        const k = Math.ceil(n / CHAIN);\n        const length = Math.ceil(n / k);\n        const chains = Array.from({ length: k }, (_, c) => perm.slice(c * length, (c + 1) * length));\n        for (const chain of chains) for (let i = 0; i + 1 < chain.length; i++) add(chain[i]!, chain[i + 1]!);\n        const skips = Math.max(0, target - pairs.length);\n        for (let s = 0; s < skips; s++) {\n          const c = k > 1 ? randomInt(r, 0, k - 2) : 0;\n          const from = chains[c]!;\n          const to = chains[k > 1 ? c + 1 : 0]!;\n          const i = randomInt(r, 0, from.length - 1);\n          const j = i + Math.floor(from.length / 8) + randomInt(r, 0, Math.floor(from.length / 2));\n          if (j < to.length) add(from[i]!, to[j]!);\n        }\n        break;\n      }\n      case \"bundled\":\n        for (let rounds = 0; pairs.length < target * FAN_SHARE && clusters > 1 && rounds < target; rounds++) {\n          const u = anyBox();\n          const c = otherCluster(clusterOf[u]!);\n          const fan = randomInt(r, 4, 15);\n          for (let f = 0; f < fan && pairs.length < target; f++) add(u, inCluster(c));\n        }\n        fill(clustered);\n        break;\n    }\n  }\n\n  const rp = stepRandom(seed, \"ports\");\n  const ports: Port[][] = input.boxes.map((b) => [...(b.ports ?? [])]);\n  const portOn = (box: LayoutBox, id: string, side: Side, fixed: boolean): Port => {\n    if (!fixed) return { id, side };\n    const along = round3(rp() * (side === \"top\" || side === \"bottom\" ? box.w : box.h));\n    const at = { top: [along, 0], bottom: [along, box.h], left: [0, along], right: [box.w, along] }[side];\n    return { id, side, x: at[0]!, y: at[1]! };\n  };\n  const out = new Set<number>();\n  if (full.ports === \"fixed\") {\n    input.boxes.forEach((box, i) => {\n      if (rp() >= FIXED_SHARE) return;\n      const side = SIDES[randomInt(rp, 0, 3)]!;\n      ports[i]!.push(portOn(box, \"out\", side, true));\n      out.add(i);\n    });\n  }\n  const edges: LayoutEdge[] = pairs.map(([u, v], k) => {\n    const id = `e${k}`;\n    const s = input.boxes[u]!;\n    const t = input.boxes[v]!;\n    let ends: { sourcePort?: string; targetPort?: string } = {};\n    if (full.ports === \"sides\") {\n      ports[u]!.push(portOn(s, `${id}.s`, SIDES[randomInt(rp, 0, 3)]!, false));\n      ports[v]!.push(portOn(t, `${id}.t`, SIDES[randomInt(rp, 0, 3)]!, false));\n      ends = { sourcePort: `${id}.s`, targetPort: `${id}.t` };\n    } else if (out.has(u)) {\n      ends = { sourcePort: \"out\" };\n    }\n    return { id, source: s.id, target: t.id, ...ends, data: { collection: collectionOf[v]! } };\n  });\n\n  const boxes = input.boxes.map((box, i): LayoutBox => {\n    const c = clusterOf[i]!;\n    const group = full.groups === \"none\" ? undefined : `g${c}`;\n    const path = full.groups === \"nested\" ? `G${Math.floor(c / 4)}/g${c}` : group;\n    return {\n      ...box,\n      ...(group === undefined ? {} : { group, data: { ...box.data, group: path } }),\n      ...(ports[i]!.length === 0 ? {} : { ports: ports[i]! }),\n    };\n  });\n  const stamp: LayoutGenerator = { name: \"edges\", version: EDGE_STEP_VERSION, params: { ...full }, seed };\n  const { hash: _old, ...rest } = input;\n  return { ...rest, boxes, edges, steps: [...(input.steps ?? []), stamp] };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/layout-contract",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "The shared contract of the packing and highways layout engines: the input and record formats, the turn rule, margins, tolerances and hard rules.",
   "keywords": [
     "layout",

package/src/edges.ts

@@ -0,0 +1,184 @@
+import { SIDES, type Side } from "./geometry.ts";
+import type { LayoutBox, LayoutEdge, LayoutGenerator, LayoutInput, Port } from "./input.ts";
+import { randomInt, stepRandom } from "./random.ts";
+
+/**
+ * The shape of the edges of `edgeStep`. The values are the cells of `edgeShape`, and `hubs`.
+ * `hubs` waits for the next breaking change to become a value of `LayoutCell.edgeShape`.
+ */
+export type EdgeShape = "random" | "clustered" | "hubChain" | "hubs" | "longRange" | "tree" | "bundled";
+
+/** The parameters of `edgeStep`. */
+export interface EdgeStepParams {
+  readonly edgeDensity: "sparse" | "medium" | "dense";
+  readonly edgeShape: EdgeShape;
+  /** The default is `none`. */
+  readonly groups?: "none" | "flat" | "nested";
+  /** The default is `free`. */
+  readonly ports?: "free" | "sides" | "fixed";
+  /** The order of the hubs of `hubs` and `tree`: the largest box first, or a random order. The default is `area`. */
+  readonly hubBy?: "area" | "random";
+}
+
+/** The mean count of the edges of each box for each value of `edgeDensity`. */
+export const EDGE_DENSITY: Readonly<Record<EdgeStepParams["edgeDensity"], number>> = Object.freeze({ sparse: 0.5, medium: 1.5, dense: 4 });
+
+/** The version of `edgeStep`. A change of its output gives a new version. */
+export const EDGE_STEP_VERSION = 1;
+
+const CLUSTER = 8;
+const CHAIN = 32;
+const INSIDE = 0.85;
+const FAN_SHARE = 0.6;
+const FIXED_SHARE = 0.2;
+const COLLECTIONS = ["users", "orders", "items", "events"] as const;
+
+const round3 = (x: number): number => Math.round(x * 1000) / 1000;
+
+/**
+ * This function gives the input with edges, groups and ports from its topology alone: a joint input has no positions before the pack.
+ * The random numbers come from the steps `edges` and `ports` of `seed`. The function appends its stamp to `steps`, and removes the old `hash`.
+ * The rules of each shape are in `docs/JOINT-CORPUS.md`.
+ */
+export function edgeStep(input: LayoutInput, params: EdgeStepParams, seed: number = input.seed ?? 0): LayoutInput {
+  if ((input.edges?.length ?? 0) > 0) throw new RangeError("edgeStep: the input has edges already");
+  const full: Required<EdgeStepParams> = { groups: "none", ports: "free", hubBy: "area", ...params };
+  const n = input.boxes.length;
+  const r = stepRandom(seed, "edges");
+
+  const perm = input.boxes.map((_, i) => i);
+  for (let i = n - 1; i > 0; i--) {
+    const j = randomInt(r, 0, i);
+    [perm[i], perm[j]] = [perm[j]!, perm[i]!];
+  }
+  const clusterOf: number[] = new Array<number>(n);
+  perm.forEach((box, p) => (clusterOf[box] = Math.floor(p / CLUSTER)));
+  const clusters = Math.ceil(n / CLUSTER);
+  const members = (c: number): readonly number[] => perm.slice(c * CLUSTER, (c + 1) * CLUSTER);
+  const collectionOf =
+    full.edgeShape === "bundled"
+      ? clusterOf.map((c) => `${COLLECTIONS[c % COLLECTIONS.length]!}-${c}`)
+      : input.boxes.map(() => COLLECTIONS[randomInt(r, 0, COLLECTIONS.length - 1)]!);
+  const area = (i: number): number => input.boxes[i]!.w * input.boxes[i]!.h;
+  const rank = full.hubBy === "area" ? input.boxes.map((_, i) => i).sort((a, b) => area(b) - area(a) || a - b) : perm;
+
+  const pairs: [number, number][] = [];
+  const seen = new Set<string>();
+  const add = (u: number, v: number): void => {
+    const key = u < v ? `${u}-${v}` : `${v}-${u}`;
+    if (u === v || seen.has(key)) return;
+    seen.add(key);
+    pairs.push([u, v]);
+  };
+  const anyBox = (): number => randomInt(r, 0, n - 1);
+  const inCluster = (c: number): number => {
+    const m = members(c);
+    return m[randomInt(r, 0, m.length - 1)]!;
+  };
+  const otherCluster = (c: number): number => {
+    const o = randomInt(r, 0, clusters - 2);
+    return o >= c ? o + 1 : o;
+  };
+  const target = Math.min(Math.round(n * EDGE_DENSITY[full.edgeDensity]), (n * (n - 1)) / 2);
+  const fill = (pick: () => [number, number]): void => {
+    for (let tries = 0; pairs.length < target && tries < target * 30; tries++) add(...pick());
+  };
+  const clustered = (): [number, number] => {
+    const u = anyBox();
+    return [u, r() < INSIDE ? inCluster(clusterOf[u]!) : anyBox()];
+  };
+
+  if (n >= 2) {
+    switch (full.edgeShape) {
+      case "random":
+        fill(() => [anyBox(), anyBox()]);
+        break;
+      case "clustered":
+        fill(clustered);
+        break;
+      case "longRange":
+        fill(() => {
+          const u = anyBox();
+          return [u, clusters > 1 ? inCluster(otherCluster(clusterOf[u]!)) : anyBox()];
+        });
+        break;
+      case "hubs":
+        fill(() => [anyBox(), rank[Math.floor(n * r() ** 3)]!]);
+        break;
+      case "tree":
+        for (let i = 1; i < n; i++) add(rank[randomInt(r, 0, i - 1)]!, rank[i]!);
+        break;
+      case "hubChain": {
+        const k = Math.ceil(n / CHAIN);
+        const length = Math.ceil(n / k);
+        const chains = Array.from({ length: k }, (_, c) => perm.slice(c * length, (c + 1) * length));
+        for (const chain of chains) for (let i = 0; i + 1 < chain.length; i++) add(chain[i]!, chain[i + 1]!);
+        const skips = Math.max(0, target - pairs.length);
+        for (let s = 0; s < skips; s++) {
+          const c = k > 1 ? randomInt(r, 0, k - 2) : 0;
+          const from = chains[c]!;
+          const to = chains[k > 1 ? c + 1 : 0]!;
+          const i = randomInt(r, 0, from.length - 1);
+          const j = i + Math.floor(from.length / 8) + randomInt(r, 0, Math.floor(from.length / 2));
+          if (j < to.length) add(from[i]!, to[j]!);
+        }
+        break;
+      }
+      case "bundled":
+        for (let rounds = 0; pairs.length < target * FAN_SHARE && clusters > 1 && rounds < target; rounds++) {
+          const u = anyBox();
+          const c = otherCluster(clusterOf[u]!);
+          const fan = randomInt(r, 4, 15);
+          for (let f = 0; f < fan && pairs.length < target; f++) add(u, inCluster(c));
+        }
+        fill(clustered);
+        break;
+    }
+  }
+
+  const rp = stepRandom(seed, "ports");
+  const ports: Port[][] = input.boxes.map((b) => [...(b.ports ?? [])]);
+  const portOn = (box: LayoutBox, id: string, side: Side, fixed: boolean): Port => {
+    if (!fixed) return { id, side };
+    const along = round3(rp() * (side === "top" || side === "bottom" ? box.w : box.h));
+    const at = { top: [along, 0], bottom: [along, box.h], left: [0, along], right: [box.w, along] }[side];
+    return { id, side, x: at[0]!, y: at[1]! };
+  };
+  const out = new Set<number>();
+  if (full.ports === "fixed") {
+    input.boxes.forEach((box, i) => {
+      if (rp() >= FIXED_SHARE) return;
+      const side = SIDES[randomInt(rp, 0, 3)]!;
+      ports[i]!.push(portOn(box, "out", side, true));
+      out.add(i);
+    });
+  }
+  const edges: LayoutEdge[] = pairs.map(([u, v], k) => {
+    const id = `e${k}`;
+    const s = input.boxes[u]!;
+    const t = input.boxes[v]!;
+    let ends: { sourcePort?: string; targetPort?: string } = {};
+    if (full.ports === "sides") {
+      ports[u]!.push(portOn(s, `${id}.s`, SIDES[randomInt(rp, 0, 3)]!, false));
+      ports[v]!.push(portOn(t, `${id}.t`, SIDES[randomInt(rp, 0, 3)]!, false));
+      ends = { sourcePort: `${id}.s`, targetPort: `${id}.t` };
+    } else if (out.has(u)) {
+      ends = { sourcePort: "out" };
+    }
+    return { id, source: s.id, target: t.id, ...ends, data: { collection: collectionOf[v]! } };
+  });
+
+  const boxes = input.boxes.map((box, i): LayoutBox => {
+    const c = clusterOf[i]!;
+    const group = full.groups === "none" ? undefined : `g${c}`;
+    const path = full.groups === "nested" ? `G${Math.floor(c / 4)}/g${c}` : group;
+    return {
+      ...box,
+      ...(group === undefined ? {} : { group, data: { ...box.data, group: path } }),
+      ...(ports[i]!.length === 0 ? {} : { ports: ports[i]! }),
+    };
+  });
+  const stamp: LayoutGenerator = { name: "edges", version: EDGE_STEP_VERSION, params: { ...full }, seed };
+  const { hash: _old, ...rest } = input;
+  return { ...rest, boxes, edges, steps: [...(input.steps ?? []), stamp] };
+}

package/src/index.ts

@@ -7,3 +7,5 @@ export * from "./rules.ts";
 export * from "./turn.ts";
 export * from "./measures.ts";
 export * from "./strategy.ts";
+export * from "./random.ts";
+export * from "./edges.ts";

package/src/input.ts

@@ -107,6 +107,8 @@ export interface LayoutInput {
   readonly hash?: string;
   /** The generator of the input. `null` or no value tells that a person made the input. */
   readonly generator?: LayoutGenerator | null;
+  /** The steps that changed the input after its generator, in their order. `edgeStep` adds one. */
+  readonly steps?: readonly LayoutGenerator[];
   readonly cell?: LayoutCell;
   /** The place of the input in a sequence of changes. */
   readonly step?: number;

package/src/random.ts

@@ -0,0 +1,40 @@
+/** This function gives a generator of random numbers in [0, 1). It is `mulberry32`, as in `docs/FORMAT.md` of `packing`. */
+export function mulberry32(seed: number): () => number {
+  let s = seed >>> 0;
+  return () => {
+    s = (s + 0x6d2b79f5) | 0;
+    let t = Math.imul(s ^ (s >>> 15), 1 | s);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** This function gives the FNV-1a hash of 32 bits of the UTF-8 bytes of a string. */
+export function fnv1a32(text: string): number {
+  let h = 0x811c9dc5;
+  for (const b of utf8(text)) h = Math.imul(h ^ b, 0x01000193) >>> 0;
+  return h;
+}
+
+/** The UTF-8 bytes of a string. The package has no runtime dependencies, thus it does not use `TextEncoder`. */
+function utf8(text: string): number[] {
+  const bytes: number[] = [];
+  for (const ch of text) {
+    const c = ch.codePointAt(0)!;
+    if (c < 0x80) bytes.push(c);
+    else if (c < 0x800) bytes.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+    else if (c < 0x10000) bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    else bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+  }
+  return bytes;
+}
+
+/** This function gives the generator of one step of a seeded generator: `mulberry32(fnv1a32("<seed>:<step>"))`. */
+export function stepRandom(seed: number, step: string): () => number {
+  return mulberry32(fnv1a32(`${seed}:${step}`));
+}
+
+/** This function gives a whole number from `lo` to `hi`, both included. */
+export function randomInt(r: () => number, lo: number, hi: number): number {
+  return lo + Math.floor(r() * (hi - lo + 1));
+}