@mark1russell7/harness 0.15.1 → 0.15.3

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as ProxyHop, A as ImageSource, At as Subject, B as LoadStream, C as Hop, Ct as RunTopology, D as HopWrite, Dt as ShippedImage, E as HopSignal, Et as Shipped, F as LineCount, Ft as isHopPlace, G as Outcomes, H as MiddleboxExpectation, I as LineMatch, It as latestEndOf, J as PausePrediction, K as Pair, L as LoadBand, M as Kafka, Mt as Topology, N as KafkaPause, Nt as Toxic, O as HostSysctl, Ot as Stage, P as KernelRecord, Pt as WsProbe, Q as ProbeEvent, R as LoadPlan, S as GroupRole, St as RunStream, T as HopPlace, Tt as SentinelStage, U as MiddleboxForm, V as MiddleboxEvent, W as Observer, X as PortsPrediction, Y as PinnedImage, Z as Prediction, _ as Fault, _t as RunFabric, a as ClientCapability, at as Reconnects, b as GroupPlace, bt as RunPause, c as ClusterClientAt, ct as ReplicaSet, d as CountBand, dt as RequestPrediction, et as ProxyTime, f as Drill, ft as RouterHop, g as FabricManifest, gt as RunDrill, h as Fabric, ht as RunBackup, i as Client, it as QueuePrediction, j as Jitter, jt as Target, k as HttpProbe, kt as StageBand, l as ClusterStage, lt as ReplicaSetStage, m as DriverStep, mt as Run, n as CLIENT_CAPABILITIES, nt as QueueConnection, o as ClientImage, ot as Recovers, p as DriverBand, pt as RttRange, q as PauseBand, r as Cell, rt as QueueEnd, s as Cluster, st as Reference, t as BuildImage, tt as QueueBand, u as ConntrackPrediction, ut as Replies, v as FaultPlace, vt as RunGroup, w as HopEvent, wt as SentinelEvent, x as GroupPrediction, xt as RunRoute, y as Group, yt as RunPart, z as LoadPrediction } from "./cell-biffSiEJ.js";
+import { $ as ProbeEvent, A as HttpProbe, At as StageBand, B as LoadPrediction, C as GroupRole, Ct as RunStream, D as HopSignal, Dt as Shipped, E as HopPlace, Et as SentinelStage, F as KernelRecord, Ft as WsProbe, G as Observer, H as MiddleboxEvent, I as LineCount, It as environmentProblems, J as PauseBand, K as Outcomes, L as LineMatch, Lt as isHopPlace, M as Jitter, Mt as Target, N as Kafka, Nt as Topology, O as HopWrite, Ot as ShippedImage, P as KafkaPause, Pt as Toxic, Q as Prediction, R as LoadBand, Rt as latestEndOf, S as GroupPrediction, St as RunRoute, T as HopEvent, Tt as SentinelEvent, U as MiddleboxExpectation, V as LoadStream, W as MiddleboxForm, X as PinnedImage, Y as PausePrediction, Z as PortsPrediction, _ as FabricManifest, _t as RunDrill, a as ClientCapability, at as QueuePrediction, b as Group, bt as RunPart, c as ClusterClientAt, ct as Reference, d as CountBand, dt as Replies, et as ProxyHop, f as Drill, ft as RequestPrediction, g as Fabric, gt as RunBackup, h as DriverStep, ht as Run, i as Client, it as QueueEnd, j as ImageSource, jt as Subject, k as HostSysctl, kt as Stage, l as ClusterStage, lt as ReplicaSet, m as DriverBand, mt as RttRange, n as CLIENT_CAPABILITIES, nt as QueueBand, o as ClientImage, ot as Reconnects, p as DrillRoom, pt as RouterHop, q as Pair, r as Cell, rt as QueueConnection, s as Cluster, st as Recovers, t as BuildImage, tt as ProxyTime, u as ConntrackPrediction, ut as ReplicaSetStage, v as Fault, vt as RunFabric, w as Hop, wt as RunTopology, x as GroupPlace, xt as RunPause, y as FaultPlace, yt as RunGroup, z as LoadPlan } from "./cell-BmqDPjz3.js";
 import { Quantity } from "@mark1russell7/quantity";
 import { LoadMeasure, Schedule } from "@mark1russell7/rigor-chaos";
 import { StartedTestContainer } from "testcontainers";
@@ -451,6 +451,17 @@ export declare const measurePause: (run: Run, prediction: PausePrediction) => Me
 export declare const SEED_DOCUMENT = 65536;
 /** This count is how far the lost writes can be from the writes after the last backup: the writes in flight at the fault. */
 export declare const LOSS_MARGIN = 2;
+/**
+ * This function gives the most disk that a drill needs, from the disk that it can use. The peak comes
+ * before the fault. Then each member holds the data and its oplog, and the backup host holds the
+ * dump. The seed goes through the oplog, thus each oplog holds the data up to its own size. The
+ * slices are small: the writes of one client in a few seconds.
+ */
+export declare const roomNeeded: (drill: Drill, members: number, disk: Quantity) => Quantity;
+/** This function gives MemAvailable from the text of `/proc/meminfo`. */
+export declare const memAvailableOf: (meminfo: string) => Quantity;
+/** This function gives the reason that a drill has no room on its runner, or null. A record from before SYS-97 has no room, and it is not void for this reason. */
+export declare const roomVoidOf: (room: DrillRoom | undefined) => string | null;
 /** This function gives the time of a drill from the start of the backups to the fault, in seconds. */
 export declare const drillSpan: (drill: Drill) => number;
 /**
@@ -1464,9 +1475,11 @@ export declare const targetImageOf: (target: Target) => Promise<string>;
  * A lab in a guest of QEMU writes E4 (`substrateHere`). The other layers do not have a runner at this
  * time.
  */
-type Layer = "E0" | "E1" | "E2" | "E3" | "E4" | "E5" | "E6";
+export declare const LAYERS: readonly ["E0", "E1", "E2", "E3", "E4", "E5", "E6"];
+type Layer = (typeof LAYERS)[number];
 /** A cloud is where the runner operates. GitHub can schedule a standard Linux job on Azure or on AWS. */
-type Cloud = "azure" | "aws" | "unknown";
+export declare const CLOUDS: readonly ["azure", "aws", "unknown"];
+type Cloud = (typeof CLOUDS)[number];
 /** A host is what a process reads about its own machine. */
 interface Host {
   /** This text is the kernel release. */
@@ -2699,6 +2712,12 @@ export declare const QUIET_MS = 250;
 export declare const LINGER_MS = 1e3;
 /** This function divides a count of runs across environments, as equally as possible. */
 export declare const spread: (runs: number, environments: number) => number[];
+/**
+ * This function gives the count of runs of each new environment of a cell, for `runs` more runs. A
+ * pair cell has an environment for each run, because its run promotes the standby. Other cells
+ * go across their environments, and at least one for each environment at the same time.
+ */
+export declare const environmentCounts: (cell: Cell, runs: number) => number[];
 /**
  * This function does the runs of a cell. They go across new environments, and each environment records
  * its manifest. Then the verdict judges the runs. A median across the edge of the band extends
@@ -2710,5 +2729,5 @@ export declare const spread: (runs: number, environments: number) => number[];
  */
 export declare const runCell: (cell: Cell, say?: (line: string) => void) => Promise<CellResult>;
 //#endregion
-export { type Agent, type BuildImage, type BuildRecord, CLIENT_CAPABILITIES, type CallReading, type Cell, type CellResult, type Client, type ClientCapability, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ConntrackPrediction, type ConntrackReading, type ContextFile, type CountBand, type Crossings, type Cut, type Decision, type Drill, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type EstimateVerdict, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HostSetting, type HostSysctl, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type Kafka, type KafkaLab, type KafkaMember, type KafkaPause, type KernelRecord, type Lab, type Layer, type LeafViews, type LineCount, type LineMatch, type LoadBand, type LoadJudgement, type LoadPlan, type LoadPrediction, type LoadSpread, type LoadStream, type LoadVerdict, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Outcomes, type Pair, type PairSets, type Pairing, type PartitionView, type PauseBand, type PauseCommit, type PausePrediction, type PauseReading, type Pinnable, type PinnedImage, type PortsPrediction, type PortsReading, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type QueueBand, type QueueConnection, type QueueConnectionReading, type QueueEnd, type QueuePrediction, type QueueReading, type ReconnectReading, type ReconnectVerdict, type Reconnects, type RecordCode, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunEstimate, type RunFabric, type RunGroup, type RunLoad, type RunPart, type RunPause, type RunRoute, type RunStream, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type Sibling, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type StallReading, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, isHopPlace, latestEndOf };
+export { type Agent, type BuildImage, type BuildRecord, CLIENT_CAPABILITIES, type CallReading, type Cell, type CellResult, type Client, type ClientCapability, type ClientImage, type ClockPair, type Cloud, type Cluster, type ClusterClientAt, type ClusterLab, type ClusterStage, type ConntrackPrediction, type ConntrackReading, type ContextFile, type CountBand, type Crossings, type Cut, type Decision, type Drill, type DrillRoom, type DriverBand, type DriverSocket, type DriverStep, type DriverStepTime, type ErrorOnTheWay, type EstimateVerdict, type Fabric, type FabricLab, type FabricManifest, type FabricParts, type Fault, type FaultPlace, type FaultSide, type Group, type GroupClient, type GroupLab, type GroupMeasured, type GroupNetworkFault, type GroupPlace, type GroupPrediction, type GroupReading, type GroupRole, type GroupVerdict, type GroupView, type Hop, type HopEvent, type HopPlace, type HopSignal, type HopWrite, type Host, type HostSetting, type HostSysctl, type HttpProbe, type ImagePlan, type ImageSource, type Interval, type Jitter, type Kafka, type KafkaLab, type KafkaMember, type KafkaPause, type KernelRecord, type Lab, type Layer, type LeafViews, type LineCount, type LineMatch, type LoadBand, type LoadJudgement, type LoadPlan, type LoadPrediction, type LoadSpread, type LoadStream, type LoadVerdict, type Manifest, type ManifestHop, type Measured, type MemberLine, type MiddleboxEvent, type MiddleboxExpectation, type MiddleboxForm, type NetworkFault, type NodeLine, type Observer, type OplogRead, type OplogTime, type Outcome, type Outcomes, type Pair, type PairSets, type Pairing, type PartitionView, type PauseBand, type PauseCommit, type PausePrediction, type PauseReading, type Pinnable, type PinnedImage, type PortsPrediction, type PortsReading, type Prediction, type Probe, type ProbeEvent, type ProgramEvent, type ProxyHop, type ProxyTime, type QueueBand, type QueueConnection, type QueueConnectionReading, type QueueEnd, type QueuePrediction, type QueueReading, type ReconnectReading, type ReconnectVerdict, type Reconnects, type RecordCode, type Recovers, type RecoveryMeasured, type Reference, type Reordering, type ReplicaSet, type ReplicaSetLab, type ReplicaSetStage, type Replies, type RequestPrediction, type RequestReading, type RouteLine, type RouterHop, type RttRange, type Run, type RunBackup, type RunDrill, type RunEstimate, type RunFabric, type RunGroup, type RunLoad, type RunPart, type RunPause, type RunRoute, type RunStream, type RunTopology, type SentinelEvent, type SentinelStage, type Shipped, type ShippedImage, type Sibling, type SocketPlace, type Spread, type Stage, type StageBand, type StageVerdict, type StallReading, type Stamp, type Status, type StatusRow, type Subject, type Substrate, type SubstrateSource, type Target, type Topology, type Toxic, type Verdict, type WallStamp, type Writes, type WsProbe, environmentProblems, isHopPlace, latestEndOf };
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -1,4 +1,4 @@
-import { A as unlockedManifests, B as isHopPlace, C as programOf, D as subjectProblems, E as subjectClient, F as jarVersions, H as requestFirst, I as locksOf, L as npmVersions, M as LOCK_NAMES, N as cargoVersions, O as targetImageOf, P as goVersions, R as versionsOf, S as planOf, T as shippedSource, V as latestEndOf, _ as kafkaClientImage, a as SHIPPED_NAMES, b as nodeHttpImage, c as buildRecordOf, d as harnessImage, f as harnessVersion, g as inContext, h as imageProblems, i as SHIPPED_CLIENTS, j as unpinnedBases, k as targetSourceOf, l as goHttpImage, m as imageOf, n as PINNED, o as amqpClientImage, p as hikariClientImage, r as REPOSITORY, s as basesOf, t as CLIENT_NAMES, u as grpcClientImage, v as mongoClientImage, w as routerImage, x as pgClientImage, y as nodeClientImage, z as CLIENT_CAPABILITIES } from "./image-BxVTFZ1o.js";
+import { A as unlockedManifests, B as environmentProblems, C as programOf, D as subjectProblems, E as subjectClient, F as jarVersions, H as latestEndOf, I as locksOf, L as npmVersions, M as LOCK_NAMES, N as cargoVersions, O as targetImageOf, P as goVersions, R as versionsOf, S as planOf, T as shippedSource, U as requestFirst, V as isHopPlace, _ as kafkaClientImage, a as SHIPPED_NAMES, b as nodeHttpImage, c as buildRecordOf, d as harnessImage, f as harnessVersion, g as inContext, h as imageProblems, i as SHIPPED_CLIENTS, j as unpinnedBases, k as targetSourceOf, l as goHttpImage, m as imageOf, n as PINNED, o as amqpClientImage, p as hikariClientImage, r as REPOSITORY, s as basesOf, t as CLIENT_NAMES, u as grpcClientImage, v as mongoClientImage, w as routerImage, x as pgClientImage, y as nodeClientImage, z as CLIENT_CAPABILITIES } from "./image-B8yh_FF7.js";
 import { quantity, valueIn } from "@mark1russell7/quantity";
 import { median, medianInterval as medianInterval$1, quantile, quantileSorted } from "@mark1russell7/rigor-statistics";
 import { rungVerdict } from "@mark1russell7/rigor-bench";
@@ -2050,6 +2050,36 @@ const SEED_DOCUMENT = 65536;
 const LOSS_MARGIN = 2;
 /** This time is how long a script waits for a server to stop, in tenths of a second. */
 const STOP_TENTHS = 600;
+/** These are the bounds of the oplog that mongod makes at its first start with no `--oplogSize`. It is 5% of the free disk, from 990 MB to 50 GB. */
+const OPLOG_SHARE = .05;
+const OPLOG_FLOOR = 1038090240;
+const OPLOG_CEILING = 53687091200;
+/**
+* This function gives the most disk that a drill needs, from the disk that it can use. The peak comes
+* before the fault. Then each member holds the data and its oplog, and the backup host holds the
+* dump. The seed goes through the oplog, thus each oplog holds the data up to its own size. The
+* slices are small: the writes of one client in a few seconds.
+*/
+const roomNeeded = (drill, members, disk) => {
+	const data = drill.tenants * valueIn(drill.perTenant, "B");
+	const oplog = Math.min(OPLOG_CEILING, Math.max(OPLOG_FLOOR, OPLOG_SHARE * valueIn(disk, "B")));
+	return {
+		value: Math.ceil((members + 1) * data + members * Math.min(data, oplog)),
+		unit: "B"
+	};
+};
+/** This function gives MemAvailable from the text of `/proc/meminfo`. */
+const memAvailableOf = (meminfo) => {
+	const found = /^MemAvailable:\s+(\d+) kB$/m.exec(meminfo);
+	if (found === null) throw new Error("/proc/meminfo has no line MemAvailable");
+	return {
+		value: Number(found[1]) * 1024,
+		unit: "B"
+	};
+};
+const gigabytes = (size) => `${(valueIn(size, "B") / 1e9).toFixed(1)} GB`;
+/** This function gives the reason that a drill has no room on its runner, or null. A record from before SYS-97 has no room, and it is not void for this reason. */
+const roomVoidOf = (room) => room === void 0 || valueIn(room.disk, "B") >= valueIn(room.need, "B") ? null : `the runner has ${gigabytes(room.disk)} of disk for the drill, and the drill needs ${gigabytes(room.need)}: the data on each member, the dump and the oplogs`;
 /** This function gives the time of a drill from the start of the backups to the fault, in seconds. */
 const drillSpan = (drill) => drill.slices * valueIn(drill.sliceEvery, "s") + valueIn(drill.age, "s");
 /**
@@ -2516,6 +2546,12 @@ const measureGroup = (cell, run) => {
 		noticed: null,
 		finding: null
 	};
+	const room = cell.drill === void 0 ? null : roomVoidOf(run.group?.drill?.room);
+	if (room !== null) return {
+		...silent,
+		void: room,
+		group: empty
+	};
 	if (ready === void 0) return {
 		...silent,
 		void: "the client never became ready",
@@ -3732,6 +3768,27 @@ const openFabric = async (parts) => {
 };
 //#endregion
 //#region src/substrate.ts
+/**
+* A layer is a rung of the laboratory (`docs/S7.md`). E1 is containers on one kernel, and E2 is a
+* cluster of containers on one kernel. A lab with `Topology.fabric` writes E3: routers in containers.
+* A lab in a guest of QEMU writes E4 (`substrateHere`). The other layers do not have a runner at this
+* time.
+*/
+const LAYERS = [
+	"E0",
+	"E1",
+	"E2",
+	"E3",
+	"E4",
+	"E5",
+	"E6"
+];
+/** A cloud is where the runner operates. GitHub can schedule a standard Linux job on Azure or on AWS. */
+const CLOUDS = [
+	"azure",
+	"aws",
+	"unknown"
+];
 /** GitHub announced Linux jobs on AWS on this date. Each earlier hosted job ran on Azure. */
 const AWS_FROM = "2026-10-28";
 /** This function gives the cloud of a DMI vendor. A kernel name does not tell: one image can start on each cloud. */
@@ -6566,6 +6623,35 @@ const sizeOf = async (lab, path) => {
 		unit: "B"
 	};
 };
+/**
+* This function reads the room of the runner before the seed. Each container writes to the same disk
+* of the runner, thus the free disk of the backup host is the free disk of the lab. The seed first
+* removes the data of the run before, thus the files of the members count as room too.
+*/
+const roomOf = async (lab, drill) => {
+	const [free] = (await lab.vault([
+		"df",
+		"-B1",
+		"--output=avail",
+		VAULT
+	])).trim().split("\n").slice(-1);
+	let held = 0;
+	for (const name of lab.set.members) held += Number((await lab.exec(name, [
+		"du",
+		"-sb",
+		"/data/db"
+	])).split(/\s+/)[0]);
+	const disk = {
+		value: Number(free) + held,
+		unit: "B"
+	};
+	if (!Number.isFinite(disk.value)) throw new Error(`no free disk in the output of df: ${free}`);
+	return {
+		disk,
+		memory: memAvailableOf(await lab.vault(["cat", "/proc/meminfo"])),
+		need: roomNeeded(drill, lab.set.members.length, disk)
+	};
+};
 /** This function takes the dump with its oplog, and each slice of the oplog at its interval. It gives each backup in sequence. */
 const backupsOf = async (lab, drill, primary, writer) => {
 	const host = `${lab.members[primary].ip}:${lab.set.port}`;
@@ -6730,10 +6816,40 @@ const drillOnce = async (lab, cell, environment, index) => {
 		"-c",
 		`rm -rf ${VAULT} && mkdir -p ${VAULT}`
 	]);
+	const tool = (await lab.vault(["mongodump", "--version"])).split("\n")[0].trim();
+	const room = await roomOf(lab, drill);
+	if (roomVoidOf(room) !== null) return {
+		environment,
+		index,
+		events: [],
+		fault: null,
+		kernel: [],
+		netns: lab.netns.client,
+		targetNetns: lab.members[primary].netns,
+		lost: 0,
+		group: {
+			members: lab.members,
+			sentinels: {},
+			primary,
+			at: primary,
+			timeline: [],
+			after: primary,
+			holds: null,
+			drill: {
+				tool,
+				seed: "generated",
+				backups: [],
+				before: "",
+				after: null,
+				restored: null,
+				second: null,
+				room
+			}
+		}
+	};
 	const seeded = await lab.script(primary, seedScript(drill, set.members.length));
 	if (!seeded.includes("\"ok\":true")) throw new Error(`the seed failed: ${seeded}`);
 	const before = hashOf(await lab.script(primary, HASH_SCRIPT));
-	const tool = (await lab.vault(["mongodump", "--version"])).split("\n")[0].trim();
 	const from = lab.kernel.length;
 	const logFrom = lab.log.length;
 	const lostBefore = droppedSoFar$3(lab.kernel);
@@ -6801,7 +6917,8 @@ const drillOnce = async (lab, cell, environment, index) => {
 				before,
 				after: hash,
 				restored,
-				second
+				second,
+				room
 			}
 		}
 	};
@@ -7561,6 +7678,19 @@ const clusterOnce = async (lab, cell, environment, index) => {
 * not in the namespace that the prober watches. The record of a run is the lines of the client and
 * the whole partition, read to its high watermark after the group converged.
 */
+/**
+* This function gives the record of the Kafka client for a manifest: its image, its source and its
+* build record. The pins check refuses a record of a built client without its build record.
+*/
+const kafkaClientRecord = (image) => {
+	const source = shippedSource("kafka");
+	return {
+		kind: "image",
+		image,
+		source,
+		...buildOf(source)
+	};
+};
 /** This path is the class path of the Kafka image: the JVM expands the star itself. */
 const CLASS_PATH = "/opt/harness/kafka/classes:/opt/harness/kafka/lib/*";
 /** This option is the heap of the client and of the admin. It has no source: the two hold a producer or a read of one partition. */
@@ -7960,12 +8090,10 @@ const openKafkaLab = async (kafka) => {
 							"apk",
 							"info",
 							"-v"
-						])).split("\n").sort()
-					},
-					client: {
-						kind: "image",
-						image: clientImage
+						])).split("\n").sort(),
+						...harnessRecord()
 					},
+					client: kafkaClientRecord(clientImage),
 					netns: {
 						client: clientNetns,
 						target: members[kafka.brokers[0]].netns
@@ -8731,6 +8859,12 @@ const once = async (lab, cell, environment, index, dry = false) => {
 /** This function divides a count of runs across environments, as equally as possible. */
 const spread = (runs, environments) => Array.from({ length: environments }, (_, at) => Math.floor(runs / environments) + (at < runs % environments ? 1 : 0)).filter((count) => count > 0);
 /**
+* This function gives the count of runs of each new environment of a cell, for `runs` more runs. A
+* pair cell has an environment for each run, because its run promotes the standby. Other cells
+* go across their environments, and at least one for each environment at the same time.
+*/
+const environmentCounts = (cell, runs) => spread(runs, cell.pair !== void 0 ? runs : Math.max(cell.environments, Math.max(1, cell.concurrency ?? 1)));
+/**
 * This function tells if the fault of a cell ends its environment. A server that stopped cannot serve
 * the next run. Also, a cell can say that its fault changes the environment (`fresh`).
 */
@@ -8867,6 +9001,7 @@ const inReplicaSetEnvironment = async (cell, environment, count, say) => {
 * run. The run promotes the standby, thus a pair cell has an environment for each run.
 */
 const inPairEnvironment = async (cell, environment, count, say) => {
+	if (count !== 1) throw new Error(`${cell.name}: a pair environment has one run, not ${count}: the run promotes the standby`);
 	const lab = await openLab(cell.target, cell.client ?? cell.probe.driver?.name ?? "tcp", cell.topology);
 	try {
 		await lab.warm();
@@ -8959,6 +9094,8 @@ const inKafkaEnvironment = async (cell, environment, count, say) => {
 * Each environment does a warm-up first, and the result keeps it apart from the counted runs.
 */
 const runCell = async (cell, say = () => {}) => {
+	const problems = environmentProblems(cell);
+	if (problems.length > 0) throw new Error(problems.join(", "));
 	const started = (/* @__PURE__ */ new Date()).toISOString();
 	const manifests = [];
 	const runs = [];
@@ -8967,7 +9104,7 @@ const runCell = async (cell, say = () => {}) => {
 	let target = cell.runs;
 	let next = 0;
 	for (;;) {
-		const counts = spread(target - runs.length, Math.max(cell.environments, concurrency));
+		const counts = environmentCounts(cell, target - runs.length);
 		for (let at = 0; at < counts.length; at += concurrency) {
 			const batch = counts.slice(at, at + concurrency).map((count) => ({
 				count,
@@ -9003,6 +9140,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { AWS_FROM, CLIENT_CAPABILITIES, CLIENT_NAMES, CLOSED_TOLERANCE, CLUSTER_STAGES, CONVERGE_MS, DAEMONS, DEBUG, DIRTY, DROP_HANDLING, FABRIC_CLIENT, FABRIC_DEVICE, FABRIC_TARGET, FRR_IMAGE, GIVES_AWAY, HASH_SCRIPT, INJECT, INSERT, KAFKA_TAIL_MS, KEPT, LINGER_MS, LISTING, LOAD_FORMAT, LOAD_PATH, LOCK_NAMES, LOSS_MARGIN, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, RESTART, ROUTERS, SCHEDULE_PATH, SEED_DOCUMENT, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STANDBY_READY, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, basesOf, bootstrapOf, brokerEnv, buildOf, buildRecordOf, callOf, cancelsOf, cargoVersions, clockOffsetOf, closeOrExit, cloudOf, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, commitProblems, comparable, controllerEnv, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, drillOnce, drillSpan, dropFinding, dropOf, endpointAfter, envOf, errorsOf, estimateOf, estimateVerdict, exitOf, fieldOf, fieldsOf, firstUnanswered, frrConf, goHttpImage, goVersions, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, harnessRecord, harnessVersion, hashOf, highestHeld, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isFenceLine, isHopPlace, jarVersions, jitterOf, jitterOfLines, judge, kafkaArgs, kafkaClientImage, kafkaCutOf, kafkaOnce, kafkaPauseOnce, kafkaViewOf, lagsOf, laterMove, latestEndOf, leafLacks, leftAfter, loadOf, loadPlanOf, loadVerdict, locksOf, logNameOf, logTimeOf, manifestProblems, matches, measure, measureConntrack, measureDriver, measureGroup, measurePause, measurePorts, measureQueue, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicAt, monotonicOf, namesGroup, nodeClientImage, nodeCommand, nodeHttpImage, nodeIdOf, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, npmVersions, numbersOf, onMonotonic, openClusterLab, openFabric, openGroupLab, openKafkaLab, openLab, openReplicaSetLab, openStandby, pairArgs, pairOnce, pairingOf, pairingsOf, pauseReady, peersOf, pgClientImage, pingsOf, plainOf, planOf, poolOf, programLines, programOf, quantileOf, readCpu, readHost, readOplog, reconnectFinding, reconnectOf, recordProblems, recoveryFindings, recoveryOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, routeLine, routerImage, routesOf, runCell, seedScript, sentinelConfig, sessionsOf, shippedClientRecord, shippedSource, sliceQuery, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, standaloneCommand, standbyCommand, statusViewOf, stealShare, stopScript, streamsLoadOf, subjectClient, subjectProblems, subscriptionsOf, substrateHere, substrateKey, substrateOf, substrateOn, targetImageOf, targetSourceOf, templated, toolJsonOf, topicOf, topologyOf, toxicBody, unlockedManifests, unpinnedBases, unpoolable, verdictOf, versionsOf, viewOf, writesOf };
+export { AWS_FROM, CLIENT_CAPABILITIES, CLIENT_NAMES, CLOSED_TOLERANCE, CLOUDS, CLUSTER_STAGES, CONVERGE_MS, DAEMONS, DEBUG, DIRTY, DROP_HANDLING, FABRIC_CLIENT, FABRIC_DEVICE, FABRIC_TARGET, FRR_IMAGE, GIVES_AWAY, HASH_SCRIPT, INJECT, INSERT, KAFKA_TAIL_MS, KEPT, LAYERS, LINGER_MS, LISTING, LOAD_FORMAT, LOAD_PATH, LOCK_NAMES, LOSS_MARGIN, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, RESTART, ROUTERS, SCHEDULE_PATH, SEED_DOCUMENT, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STANDBY_READY, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, basesOf, bootstrapOf, brokerEnv, buildOf, buildRecordOf, callOf, cancelsOf, cargoVersions, clockOffsetOf, closeOrExit, cloudOf, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, commitProblems, comparable, controllerEnv, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, drillOnce, drillSpan, dropFinding, dropOf, endpointAfter, envOf, environmentCounts, environmentProblems, errorsOf, estimateOf, estimateVerdict, exitOf, fieldOf, fieldsOf, firstUnanswered, frrConf, goHttpImage, goVersions, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, harnessRecord, harnessVersion, hashOf, highestHeld, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isFenceLine, isHopPlace, jarVersions, jitterOf, jitterOfLines, judge, kafkaArgs, kafkaClientImage, kafkaCutOf, kafkaOnce, kafkaPauseOnce, kafkaViewOf, lagsOf, laterMove, latestEndOf, leafLacks, leftAfter, loadOf, loadPlanOf, loadVerdict, locksOf, logNameOf, logTimeOf, manifestProblems, matches, measure, measureConntrack, measureDriver, measureGroup, measurePause, measurePorts, measureQueue, medianInterval, memAvailableOf, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicAt, monotonicOf, namesGroup, nodeClientImage, nodeCommand, nodeHttpImage, nodeIdOf, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, npmVersions, numbersOf, onMonotonic, openClusterLab, openFabric, openGroupLab, openKafkaLab, openLab, openReplicaSetLab, openStandby, pairArgs, pairOnce, pairingOf, pairingsOf, pauseReady, peersOf, pgClientImage, pingsOf, plainOf, planOf, poolOf, programLines, programOf, quantileOf, readCpu, readHost, readOplog, reconnectFinding, reconnectOf, recordProblems, recoveryFindings, recoveryOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, roomNeeded, roomVoidOf, routeLine, routerImage, routesOf, runCell, seedScript, sentinelConfig, sessionsOf, shippedClientRecord, shippedSource, sliceQuery, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, standaloneCommand, standbyCommand, statusViewOf, stealShare, stopScript, streamsLoadOf, subjectClient, subjectProblems, subscriptionsOf, substrateHere, substrateKey, substrateOf, substrateOn, targetImageOf, targetSourceOf, templated, toolJsonOf, topicOf, topologyOf, toxicBody, unlockedManifests, unpinnedBases, unpoolable, verdictOf, versionsOf, viewOf, writesOf };
 
 //# sourceMappingURL=index.js.map