@mark1russell7/rigor-bench 0.1.2 → 0.2.1

package/README.md

@@ -43,6 +43,13 @@ v.comparison;                                     // the cases that gain and dro
 | `limitVerdict(candidate, aa, options)` | The verdict of the claim "the ratio of each case is at most `limit`": `within`, `beyond` or `cannot decide`. |
 | `timeRounds(arms, options)` | The timed rounds of one case in one process: a warm-up, a batch of at least the target time, and the order of `firstArm`. |
 | `verdictPower(options)` | The share of each outcome over seeded benches with a known ratio: the power test of a rule. |
+| `balanceOrders(records)` | The records of each case with a turned order. It removes the extra records of the larger order, with the highest rounds first. |
+| `pooledVerdict(jobs, options)` | The verdict of the merged records of all jobs, with the verdict of each job alone as a guard. |
+| `armVerdicts(run, aaPair, options)` | The verdict of each candidate pair of a run against its A/A pair. |
+| `benchEnv()` | From `/fresh`: the computer of this process, with the CPU model and the runner. |
+| `childLine(stdout)` | From `/fresh`: the last JSON line of a child, with its time `ms`, its `hash` and the reason of a skip. |
+| `pairOrder(pairs, round, caseIndex)` | From `/fresh`: the order of the pairs of one case in one round, and the first arm of each pair. |
+| `freshRun(options)` | From `/fresh`: the records of each pair, with each arm in its own fresh child process. |
 
 ## A claim with a limit
 
@@ -71,6 +78,68 @@ const { records } = timeRounds({ a: () => oldCode(input), b: () => newCode(input
 
 Each arm gives a number. The engine cannot remove the work of a call, because the sum of these numbers uses it.
 
+## The fresh runner
+
+The entry `@mark1russell7/rigor-bench/fresh` starts child processes, so it is for Node only. The root entry stays free of `node:child_process`.
+
+`freshRun` starts each arm of each pair, case and round in a fresh child. The child prints one JSON line, for example `{"ms": 12.5, "hash": "9f3a"}`:
+
+```ts
+import { freshRun } from "@mark1russell7/rigor-bench/fresh";
+
+const run = await freshRun({
+  base: { id: "old", command: ["node", "bench/arm.js", "--entry", "old"] },
+  candidates: [{ id: "new", command: ["node", "bench/arm.js", "--entry", "new"] }],
+  cases: ["board-1", "board-2"],
+  rounds: 5,
+  roundOffset: job * 5,                           // global rounds over the jobs
+  job: String(job),
+});
+
+run.pairs["new"];                                 // the records of the pair (old, new)
+run.pairs["old~aa"];                              // the records of the A/A pair (old, old)
+```
+
+- Each candidate is a pair (base, candidate) with its own base child. The A/A pair is (base, base).
+- `pairOrder` gives the order. Pair `p` starts with `firstArm(round, caseIndex + p)`, and the pair that starts first turns each second round.
+- The arguments of a case come after the command. The default is `--case <id>`.
+- A child that exits with an error, takes too long or prints no JSON line stops the run with an error. The error names the arm, the case, the round and the tail of `stderr`.
+- Only a line with `skipped` skips a case. A skip line does not need a time.
+- A skip in the first round of the job removes the case from each pair, and the run starts no more children for it. A skip after the first round stops the run with an error, because the child is not deterministic.
+- A child that does not stop at the time limit gets SIGTERM, and SIGKILL after 1 second. The signals go to its process group. On Windows, `taskkill /T /F` stops its tree.
+- Two different hashes of one arm on one case stop the run with an error.
+- Each record keeps its job and the computer of its job (`benchEnv`).
+
+A run of many jobs sets `roundOffset` to `job * rounds`. Then the merged records have one record of each case and round. Without it, each job repeats the first orders, and the merge removes more records.
+
+### Why pairs, and not a rotation of all arms
+
+A rotation of N arms turns the order of two arms only when they are N/2 apart in the rotation. For 4 arms, two arms 1 apart come in the order 3:1 over 4 rounds. Thus each pair of `freshRun` has its own two children, and the order of each pair turns each round.
+
+## The pooled verdict
+
+`pooledVerdict` gives the verdict of the records of all jobs together:
+
+```ts
+const v = pooledVerdict(
+  jobs.map((j) => ({ job: j.job, candidate: j.pairs["new"], aa: j.pairs["old~aa"] })),
+  { margin: 0.05 },
+);
+
+v.outcome;                                        // the pooled outcome, or "cannot decide" when a job decides the opposite direction
+v.jobs;                                           // the verdict of each job alone
+v.opposed;                                        // the jobs against the pooled direction
+v.trimmed;                                        // the records that balanceOrders removed
+```
+
+- The function merges the records, and balances the merged records with `balanceOrders`. A caller cannot pool records without a turned order.
+- The verdict of each job uses the same options as the pooled verdict.
+- A job with `cannot decide` or `same` does not change the outcome. Only a job with `faster` against a pooled `slower`, or the reverse, makes the outcome `cannot decide`.
+- A pooled `same` stays `same`, also with a job that gives `slower` or `faster`. Only the opposite direction opposes.
+- Each record with a field `job` has the label of its job, or `pooledVerdict` stops with an error.
+- Two jobs with a record of one case and one round are an error. Set `roundOffset` of each job.
+- `armVerdicts` gives the verdict of each candidate pair of one run against its A/A pair.
+
 ## The noise cap and the pooled band
 
 Two options of `timeVerdict` keep a noisy run from a decision. Both are off by default, so the output stays the same as in 0.1.0.
@@ -80,10 +149,12 @@ The option `noiseCap` caps the A/A spread of the run. The spread is the quantile
 ```ts
 const v = timeVerdict(records, aaRecords, { noiseCap: 0.06 });
 
-v.noise;                                          // { spread, cap, noisy }
+v.noise;                                          // { spread, cap, noisy, aaMedian, biased }
 v.reason;                                         // the spread, the cap and the outcome without the cap
 ```
 
+Since 0.2.0, the noise cap also examines the bias of the A/A arm. An A/A median ratio out of `[exp(-noiseCap), exp(noiseCap)]` gives `cannot decide`. A bias of this size comes from the order or from the arm slots, not from the candidate. With a `spreadLevel` of 0.5 or more, a biased run is also noisy. More than half of its A/A cases are out of the cap. Thus the bias check decides alone only below the level 0.5. The fields `aaMedian` and `biased` keep the facts of the check.
+
 The option `pool` gives a band from the A/A records of earlier quiet runs, with a floor. The caller keeps the pool, for example in a file of the repository:
 
 ```ts
@@ -107,12 +178,14 @@ For a fixed limit, for example 1.10 against a fixed base, use `limitVerdict`.
 
 | Outcome | The rule `difference` (the default) | The rule `band` |
 | --- | --- | --- |
-| `faster` | The whole interval is below 1. | The interval of the median ratio is below the band. |
-| `slower` | The whole interval is above 1. | The interval is above the band. |
-| `same` | The interval is in `[exp(-margin), exp(margin)]`. The default margin is 0.05. | The interval is in the band. |
+| `same` | The interval is in `[exp(-margin), exp(margin)]`. The default margin is 0.05. The rule examines this outcome first. | The interval is in the band. |
+| `faster` | The whole interval is below 1, and it is not in the margin. | The interval of the median ratio is below the band. |
+| `slower` | The whole interval is above 1, and it is not in the margin. | The interval is above the band. |
 | `cannot decide` | The interval holds 1 and crosses the margin. | The interval crosses an end of the band. |
 
-Both rules give `cannot decide` when the A/A arm has fewer than 5 cases, or when the candidate has no cases. With `noiseCap`, both rules also give `cannot decide` when the A/A spread of the run is above the cap.
+Both rules give `cannot decide` when the A/A arm has fewer than 5 cases, or when the candidate has no cases. With `noiseCap`, an A/A spread of the run above the cap also gives `cannot decide`. So does an A/A median ratio of the run out of the cap.
+
+Since 0.2.0, the rule `difference` examines the margin before 1. An interval in the margin is `same`, also when it is wholly below 1. An example is the interval `[0.96, 0.98]` with the margin 0.05: it is `same`, and 0.1.2 gave `faster`. An interval below 1 that crosses `exp(-margin)` is still `faster`. With the margin 0, each outcome stays the same.
 
 ## The power test
 
@@ -131,3 +204,5 @@ Both rules give `cannot decide` when the A/A arm has fewer than 5 cases, or when
 | `difference` | 20 | 0.71 | 0 | 0.04 |
 
 The rule `band` compares an interval with a band of the same noise, so it needs a change of approximately twice that noise. With the kind `case`, it also calls a real speedup `same`. Thus `difference` is the default. Its false rate is near the 5% of a two-sided interval of level 0.95. A change of 7% needs approximately 20 cases for a power of 0.7.
+
+Since 0.2.0, `verdictPower` takes `same` as the true outcome of a ratio in the margin of the rule `difference`. The cells of the table stay, because the ratio 0.93 is out of the margin 0.05.

package/build/fresh.d.ts

@@ -0,0 +1,134 @@
+import { r as PairedTime, t as Arm } from "./paired.js";
+/** The computer of a run. The `cpu` is the model of the first CPU. */
+export interface BenchEnv {
+  readonly cpu: string;
+  readonly cores: number;
+  readonly os: string;
+  readonly arch: string;
+  readonly node: string;
+  /** The name of the runner, from `BENCH_RUNNER` or else `RUNNER_NAME`. An empty value is absent. */
+  readonly runner?: string;
+}
+/** This function gives the computer of this process. The runner comes from `BENCH_RUNNER`, or else from `RUNNER_NAME`. */
+export declare function benchEnv(): BenchEnv;
+/** The JSON line of a child: its time in milliseconds, the hash of its output, and the reason of a skip. */
+export type ChildLine = ChildTime | ChildSkip;
+/** The result line of a child that timed the arm. */
+export interface ChildTime {
+  readonly ms: number;
+  /** The hash of the output of the arm. Two different hashes of one arm on one case are an error. */
+  readonly hash?: string;
+  readonly skipped?: undefined;
+}
+/** The result line of a child that skipped the case. A skip line does not need a time. */
+export interface ChildSkip {
+  /** The reason of the skip. The runner removes the case from each pair. */
+  readonly skipped: string;
+  readonly ms?: number;
+  readonly hash?: string;
+}
+/**
+ * This function reads the last line of `stdout` that starts with `{`. The time `ms` is a finite number above 0.
+ * A skip line has the reason `skipped` and does not need a time. No such line, bad JSON or a bad field is an error.
+ */
+export declare function childLine(stdout: string): ChildLine;
+/** One slot of the order of a round: the index of the pair, and the arm of that pair that starts first. */
+export interface PairSlot {
+  readonly pair: number;
+  readonly first: Arm;
+}
+/**
+ * This function gives the order of the pairs of one case in one round. `round` is the global round.
+ * - Pair `p` starts with `firstArm(round, caseIndex + p)`.
+ * - The pairs rotate by `(Math.floor(round / 2) + caseIndex) % pairs`. Thus the pair that starts first turns each second round.
+ * - For 2 pairs, the order is the order of `timeArmOrder` of the joint bench.
+ */
+export declare function pairOrder(pairs: number, round: number, caseIndex: number): PairSlot[];
+/** One arm of a run: its id and the argv of its child. The first item of `command` is the program. */
+export interface FreshArm {
+  readonly id: string;
+  readonly command: readonly string[];
+}
+/** The limits of one child. */
+export interface StartOptions {
+  /** The longest time of the child in milliseconds. */
+  readonly timeoutMs: number;
+  /** The most bytes of `stdout` or `stderr`. */
+  readonly maxBuffer: number;
+}
+/** The end of one child. */
+export interface ChildExit {
+  readonly stdout: string;
+  readonly stderr: string;
+  /** The exit code, or `null` when a signal stopped the child. */
+  readonly code: number | null;
+  /** The value is `true` when the child took more time than the limit. */
+  readonly timedOut?: boolean;
+  /** The reason of a fault outside the child, for example a program that does not exist or too much output. */
+  readonly error?: string;
+}
+/** The start of one child: it gives the end of the child. The default starts a process with `spawn`, without a shell. */
+export type StartChild = (argv: readonly string[], options: StartOptions) => Promise<ChildExit>;
+/** The options of a fresh run. */
+export interface FreshOptions {
+  /** The base arm. It is arm `a` of each pair. */
+  readonly base: FreshArm;
+  /** The candidate arms. Each candidate is arm `b` of its own pair, and the id of the pair is its id. */
+  readonly candidates: readonly FreshArm[];
+  /** The ids of the cases. */
+  readonly cases: readonly string[];
+  /** The count of the rounds of this job. */
+  readonly rounds: number;
+  /**
+   * The global round of the first round of this job. The default is 0.
+   * A run of many jobs sets it to `job * rounds`, so each round is global over the jobs.
+   * Without it, each job repeats the first orders, and the merge removes more records.
+   */
+  readonly roundOffset?: number;
+  /** The value `true` adds the A/A pair (base, base) with the id `${base.id}~aa`. The default is `true`. */
+  readonly aa?: boolean;
+  /** The arguments of a case after the command of an arm. The default is `["--case", id]`. */
+  readonly args?: (caseId: string) => readonly string[];
+  /** The longest time of one child in milliseconds. The default is 600000 (10 minutes). */
+  readonly timeoutMs?: number;
+  /** The most bytes of the output of one child. The default is 16 MiB. */
+  readonly maxBuffer?: number;
+  /** The label of the job. The default is `"0"`. */
+  readonly job?: string;
+  /** The computer of the run. The default is `benchEnv()`. */
+  readonly env?: BenchEnv;
+  /** The start of a child. The default starts a process. A test gives its own. */
+  readonly start?: StartChild;
+}
+/** One record of a fresh run: a `PairedTime` record with the job and the computer of its job. */
+export interface FreshRecord extends PairedTime {
+  readonly job: string;
+  readonly env: BenchEnv;
+}
+/** A case that an arm skipped. The case is in no pair. */
+export interface FreshSkip {
+  readonly arm: string;
+  readonly case: string;
+  /** The global round of the skip. A skip is in the first round of its job. */
+  readonly round: number;
+  readonly reason: string;
+}
+/** The result of a fresh run. */
+export interface FreshRun {
+  readonly env: BenchEnv;
+  readonly job: string;
+  /** The records of each pair, by the id of the pair. */
+  readonly pairs: Record<string, FreshRecord[]>;
+  readonly skipped: FreshSkip[];
+}
+/**
+ * This function starts each arm of each pair, case and round in a fresh child, and gives the records of each pair.
+ * - Each candidate is a pair (base, candidate) with its own base child. The A/A pair is (base, base).
+ * - In each round and case, the pairs come in the order of `pairOrder`. The first arm of a pair starts first.
+ * - A child that exits with an error, takes too long or prints no JSON line is an error. Only a skip line skips a case.
+ * - A case that an arm skips in the first round of the job leaves each pair, and the runner starts no more children for it.
+ * - A skip after the first round is an error. It shows a child that is not deterministic, and it drops paid data.
+ * - Two different hashes of one arm on one case are an error.
+ */
+export declare function freshRun(options: FreshOptions): Promise<FreshRun>;
+//# sourceMappingURL=fresh.d.ts.map

package/build/fresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fresh.d.ts","names":[],"sources":["../src/fresh.ts"],"mappings":";;iBASiB;WACN;WACA;WACA;WACA;WACA;;WAEA;;;wBAIK,YAAY;;YAQhB,YAAY,YAAY;;iBAGnB;WACN;;WAEA;WACA;;;iBAIM;;WAEN;WACA;WACA;;;;;;wBAOK,UAAU,iBAAiB;;iBAwB1B;WACN;WACA,OAAO;;;;;;;;wBASF,UAAU,eAAe,eAAe,oBAAoB;;iBAY3D;WACN;WACA;;;iBAIM;;WAEN;;WAEA;;;iBAIM;WACN;WACA;;WAEA;;WAEA;;WAEA;;;YAIC,cAAc,yBAAyB,SAAS,iBAAiB,QAAQ;;iBAGpE;;WAEN,MAAM;;WAEN,qBAAqB;;WAErB;;WAEA;;;;;;WAMA;;WAEA;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA,MAAM;;WAEN,QAAQ;;;iBAIF,oBAAoB;WAC1B;WACA,KAAK;;;iBAIC;WACN;WACA;;WAEA;WACA;;;iBAIM;WACN,KAAK;WACL;;WAEA,OAAO,eAAe;WACtB,SAAS;;;;;;;;;;;wBAkBE,SAAS,SAAS,eAAe,QAAQ"}

package/build/fresh.js

@@ -0,0 +1,321 @@
+import { r as firstArm } from "./paired.js";
+import { spawn } from "node:child_process";
+import { arch, cpus, platform } from "node:os";
+// src/fresh.ts
+/**
+* The fresh-process runner of a bench, for Node only. Each arm of each pair, case and round is one fresh child process.
+* The child prints one JSON line with its time. The runner keeps the order of `pairOrder`, and gives `PairedTime` records.
+*/
+/** This function gives the computer of this process. The runner comes from `BENCH_RUNNER`, or else from `RUNNER_NAME`. */
+function benchEnv() {
+	const all = cpus();
+	const env = {
+		cpu: all[0]?.model.trim() || "unknown",
+		cores: all.length,
+		os: platform(),
+		arch: arch(),
+		node: process.version
+	};
+	const runner = process.env["BENCH_RUNNER"] || process.env["RUNNER_NAME"];
+	return runner === void 0 || runner === "" ? env : {
+		...env,
+		runner
+	};
+}
+/**
+* This function reads the last line of `stdout` that starts with `{`. The time `ms` is a finite number above 0.
+* A skip line has the reason `skipped` and does not need a time. No such line, bad JSON or a bad field is an error.
+*/
+function childLine(stdout) {
+	const line = stdout.split("\n").map((l) => l.trim()).findLast((l) => l.startsWith("{"));
+	if (line === void 0) throw new Error("childLine: the output has no line that starts with {.");
+	let value;
+	try {
+		value = JSON.parse(line);
+	} catch {
+		throw new Error(`childLine: the last line that starts with { is not JSON: ${line.slice(0, 200)}`);
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`childLine: the last JSON line is not an object: ${line.slice(0, 200)}`);
+	const { ms, hash, skipped } = value;
+	if (hash !== void 0 && typeof hash !== "string") throw new Error(`childLine: the hash is a string, not ${JSON.stringify(hash)}.`);
+	if (skipped !== void 0) {
+		if (!(typeof skipped === "string" && skipped !== "")) throw new Error(`childLine: the reason of a skip is a string that is not empty, not ${JSON.stringify(skipped)}.`);
+		return {
+			skipped,
+			...typeof ms === "number" ? { ms } : {},
+			...hash === void 0 ? {} : { hash }
+		};
+	}
+	if (!(typeof ms === "number" && Number.isFinite(ms) && ms > 0)) throw new Error(`childLine: the time ms is a finite number above 0, not ${JSON.stringify(ms)}.`);
+	return {
+		ms,
+		...hash === void 0 ? {} : { hash }
+	};
+}
+/**
+* This function gives the order of the pairs of one case in one round. `round` is the global round.
+* - Pair `p` starts with `firstArm(round, caseIndex + p)`.
+* - The pairs rotate by `(Math.floor(round / 2) + caseIndex) % pairs`. Thus the pair that starts first turns each second round.
+* - For 2 pairs, the order is the order of `timeArmOrder` of the joint bench.
+*/
+function pairOrder(pairs, round, caseIndex) {
+	if (!Number.isSafeInteger(pairs) || pairs < 1) throw new RangeError(`pairOrder: the count of the pairs is a whole number of 1 or more, not ${pairs}.`);
+	if (!Number.isSafeInteger(round) || round < 0) throw new RangeError(`pairOrder: the round is a whole number of 0 or more, not ${round}.`);
+	if (!Number.isSafeInteger(caseIndex) || caseIndex < 0) throw new RangeError(`pairOrder: the index of the case is a whole number of 0 or more, not ${caseIndex}.`);
+	const shift = (Math.floor(round / 2) + caseIndex) % pairs;
+	return Array.from({ length: pairs }, (_, i) => {
+		const pair = (shift + i) % pairs;
+		return {
+			pair,
+			first: firstArm(round, caseIndex + pair)
+		};
+	});
+}
+/** The suffix of the id of the A/A pair. */
+const AA_SUFFIX = "~aa";
+/** The longest tail of `stderr` in an error. */
+const TAIL = 2e3;
+/**
+* This function starts each arm of each pair, case and round in a fresh child, and gives the records of each pair.
+* - Each candidate is a pair (base, candidate) with its own base child. The A/A pair is (base, base).
+* - In each round and case, the pairs come in the order of `pairOrder`. The first arm of a pair starts first.
+* - A child that exits with an error, takes too long or prints no JSON line is an error. Only a skip line skips a case.
+* - A case that an arm skips in the first round of the job leaves each pair, and the runner starts no more children for it.
+* - A skip after the first round is an error. It shows a child that is not deterministic, and it drops paid data.
+* - Two different hashes of one arm on one case are an error.
+*/
+async function freshRun(options) {
+	const { base, candidates, cases, rounds } = options;
+	const roundOffset = options.roundOffset ?? 0;
+	const job = options.job ?? "0";
+	const timeoutMs = options.timeoutMs ?? 6e5;
+	const maxBuffer = options.maxBuffer ?? 1 << 24;
+	const args = options.args ?? ((id) => ["--case", id]);
+	const start = options.start ?? startProcess;
+	if (!Number.isSafeInteger(rounds) || rounds < 1) throw new RangeError(`freshRun: the rounds are a whole number of 1 or more, not ${rounds}.`);
+	if (!Number.isSafeInteger(roundOffset) || roundOffset < 0) throw new RangeError(`freshRun: the round offset is a whole number of 0 or more, not ${roundOffset}.`);
+	if (!(timeoutMs > 0) || !(maxBuffer > 0)) throw new RangeError("freshRun: the time limit and the output limit are above 0.");
+	if (cases.length === 0 || new Set(cases).size !== cases.length || cases.some((c) => typeof c !== "string" || c === "")) throw new RangeError("freshRun: the cases are 1 or more different strings that are not empty.");
+	const pairs = candidates.map((c) => ({
+		id: c.id,
+		a: base,
+		b: c
+	}));
+	if (options.aa ?? true) pairs.push({
+		id: `${base.id}${AA_SUFFIX}`,
+		a: base,
+		b: base
+	});
+	if (pairs.length === 0) throw new RangeError("freshRun: the run has no pairs. Give a candidate, or keep the A/A pair.");
+	for (const arm of [base, ...candidates]) {
+		if (typeof arm.id !== "string" || arm.id === "") throw new RangeError("freshRun: the id of an arm is a string that is not empty.");
+		if (arm.command.length === 0 || arm.command.some((s) => typeof s !== "string")) throw new RangeError(`freshRun: the command of the arm ${JSON.stringify(arm.id)} is 1 or more strings.`);
+	}
+	const ids = /* @__PURE__ */ new Set([base.id]);
+	for (const { id } of pairs) {
+		if (ids.has(id)) throw new RangeError(`freshRun: two arms or pairs have the id ${JSON.stringify(id)}.`);
+		ids.add(id);
+	}
+	const env = options.env ?? benchEnv();
+	const out = Object.fromEntries(pairs.map((p) => [p.id, []]));
+	const skipped = [];
+	const gone = /* @__PURE__ */ new Set();
+	const hashes = /* @__PURE__ */ new Map();
+	for (let r = 0; r < rounds; r++) {
+		const round = roundOffset + r;
+		for (let i = 0; i < cases.length; i++) {
+			const id = cases[i];
+			if (gone.has(id)) continue;
+			const records = [];
+			let skip;
+			for (const slot of pairOrder(pairs.length, round, i)) {
+				const pair = pairs[slot.pair];
+				const times = {};
+				for (const arm of [slot.first, slot.first === "a" ? "b" : "a"]) {
+					const who = pair[arm];
+					const where = `the arm ${JSON.stringify(who.id)} (pair ${JSON.stringify(pair.id)}, arm ${arm}) on the case ${JSON.stringify(id)}, round ${round}`;
+					const line = await child(start, [...who.command, ...args(id)], {
+						timeoutMs,
+						maxBuffer
+					}, where);
+					if (line.skipped !== void 0) {
+						if (r > 0) throw new Error(`freshRun: ${where} skipped the case after the first round of the job (${JSON.stringify(line.skipped)}). A child that skips only in a later round is not deterministic.`);
+						skip = {
+							arm: who.id,
+							case: id,
+							round,
+							reason: line.skipped
+						};
+						break;
+					}
+					if (line.hash !== void 0) {
+						const key = `${who.id}\u0000${id}`;
+						const known = hashes.get(key);
+						if (known !== void 0 && known !== line.hash) throw new Error(`freshRun: ${where} gave the hash ${line.hash}, and an earlier child of the arm gave ${known}.`);
+						hashes.set(key, line.hash);
+					}
+					times[arm] = line.ms;
+				}
+				if (skip !== void 0) break;
+				records.push({
+					pair: pair.id,
+					record: {
+						case: id,
+						round,
+						first: slot.first,
+						a: times.a,
+						b: times.b,
+						job,
+						env
+					}
+				});
+			}
+			if (skip !== void 0) {
+				skipped.push(skip);
+				gone.add(id);
+				continue;
+			}
+			for (const { pair, record } of records) out[pair].push(record);
+		}
+	}
+	return {
+		env,
+		job,
+		pairs: out,
+		skipped
+	};
+}
+/** This function starts one child and reads its JSON line. A fault gives an error that names the arm, the case, the round and the tail of `stderr`. */
+async function child(start, argv, limits, where) {
+	let exit;
+	try {
+		exit = await start(argv, limits);
+	} catch (error) {
+		throw new Error(`freshRun: ${where} did not start: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	const fail = (why) => {
+		const tail = exit.stderr.length > TAIL ? `...${exit.stderr.slice(-2e3)}` : exit.stderr;
+		return /* @__PURE__ */ new Error(`freshRun: ${where} ${why}. The tail of stderr: ${tail.trim() === "" ? "(empty)" : tail.trimEnd()}`);
+	};
+	if (exit.error !== void 0) throw fail(`failed: ${exit.error}`);
+	if (exit.timedOut === true) throw fail(`took more than ${limits.timeoutMs} ms`);
+	if (exit.code !== 0) throw fail(exit.code === null ? "stopped on a signal" : `exited with the code ${exit.code}`);
+	try {
+		return childLine(exit.stdout);
+	} catch (error) {
+		throw fail(`printed no good JSON line (${error instanceof Error ? error.message : String(error)})`);
+	}
+}
+/** The wait, in milliseconds, for the pipes of a child after its exit, and for the exit of a child after a stop. */
+const GRACE_MS = 1e3;
+/**
+* This function starts a process with `spawn` and no shell. It stops the process and its tree at the time limit or at the output limit.
+*
+* - The promise settles at the close of the pipes, or a grace time after the exit of the child. A grandchild can keep a pipe open.
+* - A stop sends SIGTERM to the process group, and SIGKILL after the grace time. On Windows, `taskkill /T /F` stops the tree.
+*/
+function startProcess(argv, options) {
+	return new Promise((resolve) => {
+		const [program, ...rest] = argv;
+		const windows = process.platform === "win32";
+		const proc = spawn(program, rest, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true,
+			detached: !windows
+		});
+		const out = [];
+		const err = [];
+		let timedOut = false;
+		let settled = false;
+		let stopping = false;
+		let error;
+		let grace;
+		const signal = (name) => {
+			const pid = proc.pid;
+			if (pid === void 0) return;
+			if (windows) {
+				spawn("taskkill", [
+					"/pid",
+					String(pid),
+					"/T",
+					"/F"
+				], {
+					stdio: "ignore",
+					windowsHide: true
+				}).on("error", () => proc.kill());
+				return;
+			}
+			try {
+				process.kill(-pid, name);
+			} catch {
+				proc.kill(name);
+			}
+		};
+		const finish = (code) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			clearTimeout(grace);
+			proc.stdout.destroy();
+			proc.stderr.destroy();
+			const exit = {
+				stdout: Buffer.concat(out).toString("utf8"),
+				stderr: Buffer.concat(err).toString("utf8"),
+				code,
+				timedOut
+			};
+			resolve(error === void 0 ? exit : {
+				...exit,
+				error
+			});
+		};
+		const stop = () => {
+			if (stopping) return;
+			stopping = true;
+			signal("SIGTERM");
+			clearTimeout(grace);
+			grace = setTimeout(() => {
+				if (!windows) signal("SIGKILL");
+				finish(null);
+			}, GRACE_MS);
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			stop();
+		}, options.timeoutMs);
+		const take = (list) => {
+			let bytes = 0;
+			return (chunk) => {
+				bytes += chunk.length;
+				if (bytes > options.maxBuffer) {
+					error ??= `an output is more than ${options.maxBuffer} bytes`;
+					stop();
+					return;
+				}
+				list.push(chunk);
+			};
+		};
+		proc.stdout.on("data", take(out));
+		proc.stderr.on("data", take(err));
+		proc.on("error", (e) => {
+			error ??= e.message;
+			if (proc.pid === void 0) finish(null);
+		});
+		proc.on("exit", (code) => {
+			clearTimeout(timer);
+			if (stopping) return;
+			grace = setTimeout(() => {
+				if (!windows) signal("SIGKILL");
+				finish(code);
+			}, GRACE_MS);
+		});
+		proc.on("close", (code) => finish(code));
+	});
+}
+export { benchEnv, childLine, freshRun, pairOrder };
+
+//# sourceMappingURL=fresh.js.map

package/build/fresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fresh.js","names":[],"sources":["../src/fresh.ts"],"sourcesContent":["/**\n * The fresh-process runner of a bench, for Node only. Each arm of each pair, case and round is one fresh child process.\n * The child prints one JSON line with its time. The runner keeps the order of `pairOrder`, and gives `PairedTime` records.\n */\nimport { spawn } from \"node:child_process\";\nimport { arch, cpus, platform } from \"node:os\";\nimport { type Arm, type PairedTime, firstArm } from \"./paired.ts\";\n\n/** The computer of a run. The `cpu` is the model of the first CPU. */\nexport interface BenchEnv {\n  readonly cpu: string;\n  readonly cores: number;\n  readonly os: string;\n  readonly arch: string;\n  readonly node: string;\n  /** The name of the runner, from `BENCH_RUNNER` or else `RUNNER_NAME`. An empty value is absent. */\n  readonly runner?: string;\n}\n\n/** This function gives the computer of this process. The runner comes from `BENCH_RUNNER`, or else from `RUNNER_NAME`. */\nexport function benchEnv(): BenchEnv {\n  const all = cpus();\n  const env = { cpu: all[0]?.model.trim() || \"unknown\", cores: all.length, os: platform(), arch: arch(), node: process.version };\n  const runner = process.env[\"BENCH_RUNNER\"] || process.env[\"RUNNER_NAME\"];\n  return runner === undefined || runner === \"\" ? env : { ...env, runner };\n}\n\n/** The JSON line of a child: its time in milliseconds, the hash of its output, and the reason of a skip. */\nexport type ChildLine = ChildTime | ChildSkip;\n\n/** The result line of a child that timed the arm. */\nexport interface ChildTime {\n  readonly ms: number;\n  /** The hash of the output of the arm. Two different hashes of one arm on one case are an error. */\n  readonly hash?: string;\n  readonly skipped?: undefined;\n}\n\n/** The result line of a child that skipped the case. A skip line does not need a time. */\nexport interface ChildSkip {\n  /** The reason of the skip. The runner removes the case from each pair. */\n  readonly skipped: string;\n  readonly ms?: number;\n  readonly hash?: string;\n}\n\n/**\n * This function reads the last line of `stdout` that starts with `{`. The time `ms` is a finite number above 0.\n * A skip line has the reason `skipped` and does not need a time. No such line, bad JSON or a bad field is an error.\n */\nexport function childLine(stdout: string): ChildLine {\n  const line = stdout\n    .split(\"\\n\")\n    .map((l) => l.trim())\n    .findLast((l) => l.startsWith(\"{\"));\n  if (line === undefined) throw new Error(\"childLine: the output has no line that starts with {.\");\n  let value: unknown;\n  try {\n    value = JSON.parse(line);\n  } catch {\n    throw new Error(`childLine: the last line that starts with { is not JSON: ${line.slice(0, 200)}`);\n  }\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) throw new Error(`childLine: the last JSON line is not an object: ${line.slice(0, 200)}`);\n  const { ms, hash, skipped } = value as Record<string, unknown>;\n  if (hash !== undefined && typeof hash !== \"string\") throw new Error(`childLine: the hash is a string, not ${JSON.stringify(hash)}.`);\n  if (skipped !== undefined) {\n    if (!(typeof skipped === \"string\" && skipped !== \"\")) throw new Error(`childLine: the reason of a skip is a string that is not empty, not ${JSON.stringify(skipped)}.`);\n    return { skipped, ...(typeof ms === \"number\" ? { ms } : {}), ...(hash === undefined ? {} : { hash }) };\n  }\n  if (!(typeof ms === \"number\" && Number.isFinite(ms) && ms > 0)) throw new Error(`childLine: the time ms is a finite number above 0, not ${JSON.stringify(ms)}.`);\n  return { ms, ...(hash === undefined ? {} : { hash }) };\n}\n\n/** One slot of the order of a round: the index of the pair, and the arm of that pair that starts first. */\nexport interface PairSlot {\n  readonly pair: number;\n  readonly first: Arm;\n}\n\n/**\n * This function gives the order of the pairs of one case in one round. `round` is the global round.\n * - Pair `p` starts with `firstArm(round, caseIndex + p)`.\n * - The pairs rotate by `(Math.floor(round / 2) + caseIndex) % pairs`. Thus the pair that starts first turns each second round.\n * - For 2 pairs, the order is the order of `timeArmOrder` of the joint bench.\n */\nexport function pairOrder(pairs: number, round: number, caseIndex: number): PairSlot[] {\n  if (!Number.isSafeInteger(pairs) || pairs < 1) throw new RangeError(`pairOrder: the count of the pairs is a whole number of 1 or more, not ${pairs}.`);\n  if (!Number.isSafeInteger(round) || round < 0) throw new RangeError(`pairOrder: the round is a whole number of 0 or more, not ${round}.`);\n  if (!Number.isSafeInteger(caseIndex) || caseIndex < 0) throw new RangeError(`pairOrder: the index of the case is a whole number of 0 or more, not ${caseIndex}.`);\n  const shift = (Math.floor(round / 2) + caseIndex) % pairs;\n  return Array.from({ length: pairs }, (_, i) => {\n    const pair = (shift + i) % pairs;\n    return { pair, first: firstArm(round, caseIndex + pair) };\n  });\n}\n\n/** One arm of a run: its id and the argv of its child. The first item of `command` is the program. */\nexport interface FreshArm {\n  readonly id: string;\n  readonly command: readonly string[];\n}\n\n/** The limits of one child. */\nexport interface StartOptions {\n  /** The longest time of the child in milliseconds. */\n  readonly timeoutMs: number;\n  /** The most bytes of `stdout` or `stderr`. */\n  readonly maxBuffer: number;\n}\n\n/** The end of one child. */\nexport interface ChildExit {\n  readonly stdout: string;\n  readonly stderr: string;\n  /** The exit code, or `null` when a signal stopped the child. */\n  readonly code: number | null;\n  /** The value is `true` when the child took more time than the limit. */\n  readonly timedOut?: boolean;\n  /** The reason of a fault outside the child, for example a program that does not exist or too much output. */\n  readonly error?: string;\n}\n\n/** The start of one child: it gives the end of the child. The default starts a process with `spawn`, without a shell. */\nexport type StartChild = (argv: readonly string[], options: StartOptions) => Promise<ChildExit>;\n\n/** The options of a fresh run. */\nexport interface FreshOptions {\n  /** The base arm. It is arm `a` of each pair. */\n  readonly base: FreshArm;\n  /** The candidate arms. Each candidate is arm `b` of its own pair, and the id of the pair is its id. */\n  readonly candidates: readonly FreshArm[];\n  /** The ids of the cases. */\n  readonly cases: readonly string[];\n  /** The count of the rounds of this job. */\n  readonly rounds: number;\n  /**\n   * The global round of the first round of this job. The default is 0.\n   * A run of many jobs sets it to `job * rounds`, so each round is global over the jobs.\n   * Without it, each job repeats the first orders, and the merge removes more records.\n   */\n  readonly roundOffset?: number;\n  /** The value `true` adds the A/A pair (base, base) with the id `${base.id}~aa`. The default is `true`. */\n  readonly aa?: boolean;\n  /** The arguments of a case after the command of an arm. The default is `[\"--case\", id]`. */\n  readonly args?: (caseId: string) => readonly string[];\n  /** The longest time of one child in milliseconds. The default is 600000 (10 minutes). */\n  readonly timeoutMs?: number;\n  /** The most bytes of the output of one child. The default is 16 MiB. */\n  readonly maxBuffer?: number;\n  /** The label of the job. The default is `\"0\"`. */\n  readonly job?: string;\n  /** The computer of the run. The default is `benchEnv()`. */\n  readonly env?: BenchEnv;\n  /** The start of a child. The default starts a process. A test gives its own. */\n  readonly start?: StartChild;\n}\n\n/** One record of a fresh run: a `PairedTime` record with the job and the computer of its job. */\nexport interface FreshRecord extends PairedTime {\n  readonly job: string;\n  readonly env: BenchEnv;\n}\n\n/** A case that an arm skipped. The case is in no pair. */\nexport interface FreshSkip {\n  readonly arm: string;\n  readonly case: string;\n  /** The global round of the skip. A skip is in the first round of its job. */\n  readonly round: number;\n  readonly reason: string;\n}\n\n/** The result of a fresh run. */\nexport interface FreshRun {\n  readonly env: BenchEnv;\n  readonly job: string;\n  /** The records of each pair, by the id of the pair. */\n  readonly pairs: Record<string, FreshRecord[]>;\n  readonly skipped: FreshSkip[];\n}\n\n/** The suffix of the id of the A/A pair. */\nconst AA_SUFFIX = \"~aa\";\n\n/** The longest tail of `stderr` in an error. */\nconst TAIL = 2000;\n\n/**\n * This function starts each arm of each pair, case and round in a fresh child, and gives the records of each pair.\n * - Each candidate is a pair (base, candidate) with its own base child. The A/A pair is (base, base).\n * - In each round and case, the pairs come in the order of `pairOrder`. The first arm of a pair starts first.\n * - A child that exits with an error, takes too long or prints no JSON line is an error. Only a skip line skips a case.\n * - A case that an arm skips in the first round of the job leaves each pair, and the runner starts no more children for it.\n * - A skip after the first round is an error. It shows a child that is not deterministic, and it drops paid data.\n * - Two different hashes of one arm on one case are an error.\n */\nexport async function freshRun(options: FreshOptions): Promise<FreshRun> {\n  const { base, candidates, cases, rounds } = options;\n  const roundOffset = options.roundOffset ?? 0;\n  const job = options.job ?? \"0\";\n  const timeoutMs = options.timeoutMs ?? 600_000;\n  const maxBuffer = options.maxBuffer ?? 1 << 24;\n  const args = options.args ?? ((id: string) => [\"--case\", id]);\n  const start = options.start ?? startProcess;\n  if (!Number.isSafeInteger(rounds) || rounds < 1) throw new RangeError(`freshRun: the rounds are a whole number of 1 or more, not ${rounds}.`);\n  if (!Number.isSafeInteger(roundOffset) || roundOffset < 0) throw new RangeError(`freshRun: the round offset is a whole number of 0 or more, not ${roundOffset}.`);\n  if (!(timeoutMs > 0) || !(maxBuffer > 0)) throw new RangeError(\"freshRun: the time limit and the output limit are above 0.\");\n  if (cases.length === 0 || new Set(cases).size !== cases.length || cases.some((c) => typeof c !== \"string\" || c === \"\")) {\n    throw new RangeError(\"freshRun: the cases are 1 or more different strings that are not empty.\");\n  }\n  const pairs: { id: string; a: FreshArm; b: FreshArm }[] = candidates.map((c) => ({ id: c.id, a: base, b: c }));\n  if (options.aa ?? true) pairs.push({ id: `${base.id}${AA_SUFFIX}`, a: base, b: base });\n  if (pairs.length === 0) throw new RangeError(\"freshRun: the run has no pairs. Give a candidate, or keep the A/A pair.\");\n  for (const arm of [base, ...candidates]) {\n    if (typeof arm.id !== \"string\" || arm.id === \"\") throw new RangeError(\"freshRun: the id of an arm is a string that is not empty.\");\n    if (arm.command.length === 0 || arm.command.some((s) => typeof s !== \"string\")) throw new RangeError(`freshRun: the command of the arm ${JSON.stringify(arm.id)} is 1 or more strings.`);\n  }\n  const ids = new Set([base.id]);\n  for (const { id } of pairs) {\n    if (ids.has(id)) throw new RangeError(`freshRun: two arms or pairs have the id ${JSON.stringify(id)}.`);\n    ids.add(id);\n  }\n\n  const env = options.env ?? benchEnv();\n  const out: Record<string, FreshRecord[]> = Object.fromEntries(pairs.map((p) => [p.id, []]));\n  const skipped: FreshSkip[] = [];\n  const gone = new Set<string>();\n  const hashes = new Map<string, string>();\n\n  for (let r = 0; r < rounds; r++) {\n    const round = roundOffset + r;\n    for (let i = 0; i < cases.length; i++) {\n      const id = cases[i]!;\n      if (gone.has(id)) continue;\n      const records: { pair: string; record: FreshRecord }[] = [];\n      let skip: FreshSkip | undefined;\n      for (const slot of pairOrder(pairs.length, round, i)) {\n        const pair = pairs[slot.pair]!;\n        const times: Partial<Record<Arm, number>> = {};\n        for (const arm of [slot.first, slot.first === \"a\" ? \"b\" : \"a\"] as const) {\n          const who = pair[arm];\n          const where = `the arm ${JSON.stringify(who.id)} (pair ${JSON.stringify(pair.id)}, arm ${arm}) on the case ${JSON.stringify(id)}, round ${round}`;\n          const line = await child(start, [...who.command, ...args(id)], { timeoutMs, maxBuffer }, where);\n          if (line.skipped !== undefined) {\n            if (r > 0) throw new Error(`freshRun: ${where} skipped the case after the first round of the job (${JSON.stringify(line.skipped)}). A child that skips only in a later round is not deterministic.`);\n            skip = { arm: who.id, case: id, round, reason: line.skipped };\n            break;\n          }\n          if (line.hash !== undefined) {\n            const key = `${who.id}\\u0000${id}`;\n            const known = hashes.get(key);\n            if (known !== undefined && known !== line.hash) throw new Error(`freshRun: ${where} gave the hash ${line.hash}, and an earlier child of the arm gave ${known}.`);\n            hashes.set(key, line.hash);\n          }\n          times[arm] = line.ms;\n        }\n        if (skip !== undefined) break;\n        records.push({ pair: pair.id, record: { case: id, round, first: slot.first, a: times.a!, b: times.b!, job, env } });\n      }\n      if (skip !== undefined) {\n        skipped.push(skip);\n        gone.add(id);\n        continue;\n      }\n      for (const { pair, record } of records) out[pair]!.push(record);\n    }\n  }\n  return { env, job, pairs: out, skipped };\n}\n\n/** This function starts one child and reads its JSON line. A fault gives an error that names the arm, the case, the round and the tail of `stderr`. */\nasync function child(start: StartChild, argv: readonly string[], limits: StartOptions, where: string): Promise<ChildLine> {\n  let exit: ChildExit;\n  try {\n    exit = await start(argv, limits);\n  } catch (error) {\n    throw new Error(`freshRun: ${where} did not start: ${error instanceof Error ? error.message : String(error)}`, { cause: error });\n  }\n  const fail = (why: string): Error => {\n    const tail = exit.stderr.length > TAIL ? `...${exit.stderr.slice(-TAIL)}` : exit.stderr;\n    return new Error(`freshRun: ${where} ${why}. The tail of stderr: ${tail.trim() === \"\" ? \"(empty)\" : tail.trimEnd()}`);\n  };\n  if (exit.error !== undefined) throw fail(`failed: ${exit.error}`);\n  if (exit.timedOut === true) throw fail(`took more than ${limits.timeoutMs} ms`);\n  if (exit.code !== 0) throw fail(exit.code === null ? \"stopped on a signal\" : `exited with the code ${exit.code}`);\n  try {\n    return childLine(exit.stdout);\n  } catch (error) {\n    throw fail(`printed no good JSON line (${error instanceof Error ? error.message : String(error)})`);\n  }\n}\n\n/** The wait, in milliseconds, for the pipes of a child after its exit, and for the exit of a child after a stop. */\nconst GRACE_MS = 1000;\n\n/**\n * This function starts a process with `spawn` and no shell. It stops the process and its tree at the time limit or at the output limit.\n *\n * - The promise settles at the close of the pipes, or a grace time after the exit of the child. A grandchild can keep a pipe open.\n * - A stop sends SIGTERM to the process group, and SIGKILL after the grace time. On Windows, `taskkill /T /F` stops the tree.\n */\nfunction startProcess(argv: readonly string[], options: StartOptions): Promise<ChildExit> {\n  return new Promise((resolve) => {\n    const [program, ...rest] = argv;\n    const windows = process.platform === \"win32\";\n    // On POSIX, the child leads its own process group, so a signal to the group reaches the grandchildren.\n    const proc = spawn(program!, rest, { stdio: [\"ignore\", \"pipe\", \"pipe\"], windowsHide: true, detached: !windows });\n    const out: Buffer[] = [];\n    const err: Buffer[] = [];\n    let timedOut = false;\n    let settled = false;\n    let stopping = false;\n    let error: string | undefined;\n    let grace: ReturnType<typeof setTimeout> | undefined;\n    const signal = (name: NodeJS.Signals): void => {\n      const pid = proc.pid;\n      if (pid === undefined) return;\n      if (windows) {\n        // TerminateProcess stops only the direct child. The flag /T of taskkill also stops its tree.\n        spawn(\"taskkill\", [\"/pid\", String(pid), \"/T\", \"/F\"], { stdio: \"ignore\", windowsHide: true }).on(\"error\", () => proc.kill());\n        return;\n      }\n      try {\n        process.kill(-pid, name);\n      } catch {\n        proc.kill(name);\n      }\n    };\n    const finish = (code: number | null): void => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      clearTimeout(grace);\n      proc.stdout.destroy();\n      proc.stderr.destroy();\n      const exit: ChildExit = { stdout: Buffer.concat(out).toString(\"utf8\"), stderr: Buffer.concat(err).toString(\"utf8\"), code, timedOut };\n      resolve(error === undefined ? exit : { ...exit, error });\n    };\n    const stop = (): void => {\n      if (stopping) return;\n      stopping = true;\n      signal(\"SIGTERM\");\n      clearTimeout(grace);\n      grace = setTimeout(() => {\n        if (!windows) signal(\"SIGKILL\");\n        finish(null);\n      }, GRACE_MS);\n    };\n    const timer = setTimeout(() => {\n      timedOut = true;\n      stop();\n    }, options.timeoutMs);\n    const take = (list: Buffer[]) => {\n      let bytes = 0;\n      return (chunk: Buffer): void => {\n        bytes += chunk.length;\n        if (bytes > options.maxBuffer) {\n          error ??= `an output is more than ${options.maxBuffer} bytes`;\n          stop();\n          return;\n        }\n        list.push(chunk);\n      };\n    };\n    proc.stdout.on(\"data\", take(out));\n    proc.stderr.on(\"data\", take(err));\n    proc.on(\"error\", (e) => {\n      error ??= e.message;\n      // A program that does not start gives no event close.\n      if (proc.pid === undefined) finish(null);\n    });\n    proc.on(\"exit\", (code) => {\n      clearTimeout(timer);\n      if (stopping) return;\n      // A grandchild that holds a pipe keeps the event close away. After the grace time, the runner stops the group.\n      grace = setTimeout(() => {\n        if (!windows) signal(\"SIGKILL\");\n        finish(code);\n      }, GRACE_MS);\n    });\n    proc.on(\"close\", (code) => finish(code));\n  });\n}\n"],"mappings":";;;;;;;;;AAoBA,SAAgB,WAAqB;CACnC,MAAM,MAAM,KAAK;CACjB,MAAM,MAAM;EAAE,KAAK,IAAI,EAAE,EAAE,MAAM,KAAK,KAAK;EAAW,OAAO,IAAI;EAAQ,IAAI,SAAS;EAAG,MAAM,KAAK;EAAG,MAAM,QAAQ;CAAQ;CAC7H,MAAM,SAAS,QAAQ,IAAI,mBAAmB,QAAQ,IAAI;CAC1D,OAAO,WAAW,KAAA,KAAa,WAAW,KAAK,MAAM;EAAE,GAAG;EAAK;CAAO;AACxE;;;;;AAyBA,SAAgB,UAAU,QAA2B;CACnD,MAAM,OAAO,OACV,MAAM,IAAI,CAAC,CACX,KAAK,MAAM,EAAE,KAAK,CAAC,CAAC,CACpB,UAAU,MAAM,EAAE,WAAW,GAAG,CAAC;CACpC,IAAI,SAAS,KAAA,GAAW,MAAM,IAAI,MAAM,uDAAuD;CAC/F,IAAI;CACJ,IAAI;EACF,QAAQ,KAAK,MAAM,IAAI;CACzB,QAAQ;EACN,MAAM,IAAI,MAAM,4DAA4D,KAAK,MAAM,GAAG,GAAG,GAAG;CAClG;CACA,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG,MAAM,IAAI,MAAM,mDAAmD,KAAK,MAAM,GAAG,GAAG,GAAG;CAChK,MAAM,EAAE,IAAI,MAAM,YAAY;CAC9B,IAAI,SAAS,KAAA,KAAa,OAAO,SAAS,UAAU,MAAM,IAAI,MAAM,wCAAwC,KAAK,UAAU,IAAI,EAAE,EAAE;CACnI,IAAI,YAAY,KAAA,GAAW;EACzB,IAAI,EAAE,OAAO,YAAY,YAAY,YAAY,KAAK,MAAM,IAAI,MAAM,sEAAsE,KAAK,UAAU,OAAO,EAAE,EAAE;EACtK,OAAO;GAAE;GAAS,GAAI,OAAO,OAAO,WAAW,EAAE,GAAG,IAAI,CAAC;GAAI,GAAI,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK;EAAG;CACvG;CACA,IAAI,EAAE,OAAO,OAAO,YAAY,OAAO,SAAS,EAAE,KAAK,KAAK,IAAI,MAAM,IAAI,MAAM,0DAA0D,KAAK,UAAU,EAAE,EAAE,EAAE;CAC/J,OAAO;EAAE;EAAI,GAAI,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK;CAAG;AACvD;;;;;;;AAcA,SAAgB,UAAU,OAAe,OAAe,WAA+B;CACrF,IAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG,MAAM,IAAI,WAAW,yEAAyE,MAAM,EAAE;CACrJ,IAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG,MAAM,IAAI,WAAW,4DAA4D,MAAM,EAAE;CACxI,IAAI,CAAC,OAAO,cAAc,SAAS,KAAK,YAAY,GAAG,MAAM,IAAI,WAAW,wEAAwE,UAAU,EAAE;CAChK,MAAM,SAAS,KAAK,MAAM,QAAQ,CAAC,IAAI,aAAa;CACpD,OAAO,MAAM,KAAK,EAAE,QAAQ,MAAM,IAAI,GAAG,MAAM;EAC7C,MAAM,QAAQ,QAAQ,KAAK;EAC3B,OAAO;GAAE;GAAM,OAAO,SAAS,OAAO,YAAY,IAAI;EAAE;CAC1D,CAAC;AACH;;AAwFA,MAAM,YAAY;;AAGlB,MAAM,OAAO;;;;;;;;;;AAWb,eAAsB,SAAS,SAA0C;CACvE,MAAM,EAAE,MAAM,YAAY,OAAO,WAAW;CAC5C,MAAM,cAAc,QAAQ,eAAe;CAC3C,MAAM,MAAM,QAAQ,OAAO;CAC3B,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,YAAY,QAAQ,aAAa,KAAK;CAC5C,MAAM,OAAO,QAAQ,UAAU,OAAe,CAAC,UAAU,EAAE;CAC3D,MAAM,QAAQ,QAAQ,SAAS;CAC/B,IAAI,CAAC,OAAO,cAAc,MAAM,KAAK,SAAS,GAAG,MAAM,IAAI,WAAW,6DAA6D,OAAO,EAAE;CAC5I,IAAI,CAAC,OAAO,cAAc,WAAW,KAAK,cAAc,GAAG,MAAM,IAAI,WAAW,kEAAkE,YAAY,EAAE;CAChK,IAAI,EAAE,YAAY,MAAM,EAAE,YAAY,IAAI,MAAM,IAAI,WAAW,4DAA4D;CAC3H,IAAI,MAAM,WAAW,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,SAAS,MAAM,UAAU,MAAM,MAAM,MAAM,OAAO,MAAM,YAAY,MAAM,EAAE,GACnH,MAAM,IAAI,WAAW,yEAAyE;CAEhG,MAAM,QAAoD,WAAW,KAAK,OAAO;EAAE,IAAI,EAAE;EAAI,GAAG;EAAM,GAAG;CAAE,EAAE;CAC7G,IAAI,QAAQ,MAAM,MAAM,MAAM,KAAK;EAAE,IAAI,GAAG,KAAK,KAAK;EAAa,GAAG;EAAM,GAAG;CAAK,CAAC;CACrF,IAAI,MAAM,WAAW,GAAG,MAAM,IAAI,WAAW,yEAAyE;CACtH,KAAK,MAAM,OAAO,CAAC,MAAM,GAAG,UAAU,GAAG;EACvC,IAAI,OAAO,IAAI,OAAO,YAAY,IAAI,OAAO,IAAI,MAAM,IAAI,WAAW,2DAA2D;EACjI,IAAI,IAAI,QAAQ,WAAW,KAAK,IAAI,QAAQ,MAAM,MAAM,OAAO,MAAM,QAAQ,GAAG,MAAM,IAAI,WAAW,oCAAoC,KAAK,UAAU,IAAI,EAAE,EAAE,uBAAuB;CACzL;CACA,MAAM,sBAAM,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;CAC7B,KAAK,MAAM,EAAE,QAAQ,OAAO;EAC1B,IAAI,IAAI,IAAI,EAAE,GAAG,MAAM,IAAI,WAAW,2CAA2C,KAAK,UAAU,EAAE,EAAE,EAAE;EACtG,IAAI,IAAI,EAAE;CACZ;CAEA,MAAM,MAAM,QAAQ,OAAO,SAAS;CACpC,MAAM,MAAqC,OAAO,YAAY,MAAM,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;CAC1F,MAAM,UAAuB,CAAC;CAC9B,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,yBAAS,IAAI,IAAoB;CAEvC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;EAC/B,MAAM,QAAQ,cAAc;EAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,KAAK,MAAM;GACjB,IAAI,KAAK,IAAI,EAAE,GAAG;GAClB,MAAM,UAAmD,CAAC;GAC1D,IAAI;GACJ,KAAK,MAAM,QAAQ,UAAU,MAAM,QAAQ,OAAO,CAAC,GAAG;IACpD,MAAM,OAAO,MAAM,KAAK;IACxB,MAAM,QAAsC,CAAC;IAC7C,KAAK,MAAM,OAAO,CAAC,KAAK,OAAO,KAAK,UAAU,MAAM,MAAM,GAAG,GAAY;KACvE,MAAM,MAAM,KAAK;KACjB,MAAM,QAAQ,WAAW,KAAK,UAAU,IAAI,EAAE,EAAE,SAAS,KAAK,UAAU,KAAK,EAAE,EAAE,QAAQ,IAAI,gBAAgB,KAAK,UAAU,EAAE,EAAE,UAAU;KAC1I,MAAM,OAAO,MAAM,MAAM,OAAO,CAAC,GAAG,IAAI,SAAS,GAAG,KAAK,EAAE,CAAC,GAAG;MAAE;MAAW;KAAU,GAAG,KAAK;KAC9F,IAAI,KAAK,YAAY,KAAA,GAAW;MAC9B,IAAI,IAAI,GAAG,MAAM,IAAI,MAAM,aAAa,MAAM,sDAAsD,KAAK,UAAU,KAAK,OAAO,EAAE,kEAAkE;MACnM,OAAO;OAAE,KAAK,IAAI;OAAI,MAAM;OAAI;OAAO,QAAQ,KAAK;MAAQ;MAC5D;KACF;KACA,IAAI,KAAK,SAAS,KAAA,GAAW;MAC3B,MAAM,MAAM,GAAG,IAAI,GAAG,QAAQ;MAC9B,MAAM,QAAQ,OAAO,IAAI,GAAG;MAC5B,IAAI,UAAU,KAAA,KAAa,UAAU,KAAK,MAAM,MAAM,IAAI,MAAM,aAAa,MAAM,iBAAiB,KAAK,KAAK,yCAAyC,MAAM,EAAE;MAC/J,OAAO,IAAI,KAAK,KAAK,IAAI;KAC3B;KACA,MAAM,OAAO,KAAK;IACpB;IACA,IAAI,SAAS,KAAA,GAAW;IACxB,QAAQ,KAAK;KAAE,MAAM,KAAK;KAAI,QAAQ;MAAE,MAAM;MAAI;MAAO,OAAO,KAAK;MAAO,GAAG,MAAM;MAAI,GAAG,MAAM;MAAI;MAAK;KAAI;IAAE,CAAC;GACpH;GACA,IAAI,SAAS,KAAA,GAAW;IACtB,QAAQ,KAAK,IAAI;IACjB,KAAK,IAAI,EAAE;IACX;GACF;GACA,KAAK,MAAM,EAAE,MAAM,YAAY,SAAS,IAAI,KAAK,CAAE,KAAK,MAAM;EAChE;CACF;CACA,OAAO;EAAE;EAAK;EAAK,OAAO;EAAK;CAAQ;AACzC;;AAGA,eAAe,MAAM,OAAmB,MAAyB,QAAsB,OAAmC;CACxH,IAAI;CACJ,IAAI;EACF,OAAO,MAAM,MAAM,MAAM,MAAM;CACjC,SAAS,OAAO;EACd,MAAM,IAAI,MAAM,aAAa,MAAM,kBAAkB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,KAAK,EAAE,OAAO,MAAM,CAAC;CACjI;CACA,MAAM,QAAQ,QAAuB;EACnC,MAAM,OAAO,KAAK,OAAO,SAAS,OAAO,MAAM,KAAK,OAAO,MAAM,IAAK,MAAM,KAAK;EACjF,uBAAO,IAAI,MAAM,aAAa,MAAM,GAAG,IAAI,wBAAwB,KAAK,KAAK,MAAM,KAAK,YAAY,KAAK,QAAQ,GAAG;CACtH;CACA,IAAI,KAAK,UAAU,KAAA,GAAW,MAAM,KAAK,WAAW,KAAK,OAAO;CAChE,IAAI,KAAK,aAAa,MAAM,MAAM,KAAK,kBAAkB,OAAO,UAAU,IAAI;CAC9E,IAAI,KAAK,SAAS,GAAG,MAAM,KAAK,KAAK,SAAS,OAAO,wBAAwB,wBAAwB,KAAK,MAAM;CAChH,IAAI;EACF,OAAO,UAAU,KAAK,MAAM;CAC9B,SAAS,OAAO;EACd,MAAM,KAAK,8BAA8B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAAE,EAAE;CACpG;AACF;;AAGA,MAAM,WAAW;;;;;;;AAQjB,SAAS,aAAa,MAAyB,SAA2C;CACxF,OAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,CAAC,SAAS,GAAG,QAAQ;EAC3B,MAAM,UAAU,QAAQ,aAAa;EAErC,MAAM,OAAO,MAAM,SAAU,MAAM;GAAE,OAAO;IAAC;IAAU;IAAQ;GAAM;GAAG,aAAa;GAAM,UAAU,CAAC;EAAQ,CAAC;EAC/G,MAAM,MAAgB,CAAC;EACvB,MAAM,MAAgB,CAAC;EACvB,IAAI,WAAW;EACf,IAAI,UAAU;EACd,IAAI,WAAW;EACf,IAAI;EACJ,IAAI;EACJ,MAAM,UAAU,SAA+B;GAC7C,MAAM,MAAM,KAAK;GACjB,IAAI,QAAQ,KAAA,GAAW;GACvB,IAAI,SAAS;IAEX,MAAM,YAAY;KAAC;KAAQ,OAAO,GAAG;KAAG;KAAM;IAAI,GAAG;KAAE,OAAO;KAAU,aAAa;IAAK,CAAC,CAAC,CAAC,GAAG,eAAe,KAAK,KAAK,CAAC;IAC1H;GACF;GACA,IAAI;IACF,QAAQ,KAAK,CAAC,KAAK,IAAI;GACzB,QAAQ;IACN,KAAK,KAAK,IAAI;GAChB;EACF;EACA,MAAM,UAAU,SAA8B;GAC5C,IAAI,SAAS;GACb,UAAU;GACV,aAAa,KAAK;GAClB,aAAa,KAAK;GAClB,KAAK,OAAO,QAAQ;GACpB,KAAK,OAAO,QAAQ;GACpB,MAAM,OAAkB;IAAE,QAAQ,OAAO,OAAO,GAAG,CAAC,CAAC,SAAS,MAAM;IAAG,QAAQ,OAAO,OAAO,GAAG,CAAC,CAAC,SAAS,MAAM;IAAG;IAAM;GAAS;GACnI,QAAQ,UAAU,KAAA,IAAY,OAAO;IAAE,GAAG;IAAM;GAAM,CAAC;EACzD;EACA,MAAM,aAAmB;GACvB,IAAI,UAAU;GACd,WAAW;GACX,OAAO,SAAS;GAChB,aAAa,KAAK;GAClB,QAAQ,iBAAiB;IACvB,IAAI,CAAC,SAAS,OAAO,SAAS;IAC9B,OAAO,IAAI;GACb,GAAG,QAAQ;EACb;EACA,MAAM,QAAQ,iBAAiB;GAC7B,WAAW;GACX,KAAK;EACP,GAAG,QAAQ,SAAS;EACpB,MAAM,QAAQ,SAAmB;GAC/B,IAAI,QAAQ;GACZ,QAAQ,UAAwB;IAC9B,SAAS,MAAM;IACf,IAAI,QAAQ,QAAQ,WAAW;KAC7B,UAAU,0BAA0B,QAAQ,UAAU;KACtD,KAAK;KACL;IACF;IACA,KAAK,KAAK,KAAK;GACjB;EACF;EACA,KAAK,OAAO,GAAG,QAAQ,KAAK,GAAG,CAAC;EAChC,KAAK,OAAO,GAAG,QAAQ,KAAK,GAAG,CAAC;EAChC,KAAK,GAAG,UAAU,MAAM;GACtB,UAAU,EAAE;GAEZ,IAAI,KAAK,QAAQ,KAAA,GAAW,OAAO,IAAI;EACzC,CAAC;EACD,KAAK,GAAG,SAAS,SAAS;GACxB,aAAa,KAAK;GAClB,IAAI,UAAU;GAEd,QAAQ,iBAAiB;IACvB,IAAI,CAAC,SAAS,OAAO,SAAS;IAC9B,OAAO,IAAI;GACb,GAAG,QAAQ;EACb,CAAC;EACD,KAAK,GAAG,UAAU,SAAS,OAAO,IAAI,CAAC;CACzC,CAAC;AACH"}