@mark1russell7/harness 0.12.4 → 0.14.0

package/build/index.js

@@ -1,5 +1,6 @@
 import { C as targetImageOf, E as unpinnedBases, S as subjectProblems, T as unlockedManifests, _ as pgClientImage, a as SHIPPED_NAMES, b as routerImage, c as grpcClientImage, d as imageOf, f as imageProblems, g as nodeHttpImage, h as nodeClientImage, i as SHIPPED_CLIENTS, l as harnessImage, m as mongoClientImage, n as PINNED, o as amqpClientImage, p as inContext, r as REPOSITORY, s as goHttpImage, t as CLIENT_NAMES, u as hikariClientImage, v as planOf, w as targetSourceOf, x as subjectClient, y as programOf } from "./image-Lg8LL6C3.js";
 import { quantity, valueIn } from "@mark1russell7/quantity";
+import { median, medianInterval as medianInterval$1, quantileSorted } from "@mark1russell7/rigor-statistics";
 import { createHash } from "node:crypto";
 //#region src/cell.ts
 /** This function tells if a fault place is a hop of a topology. */
@@ -35,6 +36,37 @@ const INJECT = NOISE;
 /** This function gives the δ_abs of a cell: its own, or `NOISE` for a cell that gives none. */
 const noiseOf = (cell) => cell.noise ?? NOISE;
 /**
+* This function gives the pairing window of a run (SYS-25). On a runner of GitHub, the jitter of
+* a program can be longer than the δ_abs of 1 ms. Thus each run measures it before its fault
+* (`Run.jitter`), and its own measurement widens its window. A run without a jitter record is
+* from before SYS-25. It reads as a bound of null, thus its window is δ_abs. The decision of
+* 2026-10-19 keeps the rule of one miss: a pair that a window misses is still a finding.
+*/
+const pairingOf = (cell, run) => {
+	const noise = noiseOf(cell);
+	const bound = run.jitter?.bound ?? null;
+	return {
+		bound,
+		delta: bound !== null && valueIn(bound, "s") > valueIn(noise, "s") ? bound : noise
+	};
+};
+/**
+* This function sums the pairings of the measurements of a cell. It gives the longest bound and
+* the longest window. It also counts the pairings whose window is longer than δ_abs (`noise`). It
+* is null when no measurement has a pairing.
+*/
+const pairingsOf = (runs, noise = NOISE) => {
+	const pairings = runs.flatMap((run) => run.pairing === void 0 ? [] : [run.pairing]);
+	if (pairings.length === 0) return null;
+	const longest = (values) => values.reduce((most, each) => valueIn(each, "s") > valueIn(most, "s") ? each : most);
+	const bounds = pairings.flatMap((pairing) => pairing.bound === null ? [] : [pairing.bound]);
+	return {
+		bound: bounds.length === 0 ? null : longest(bounds),
+		delta: longest(pairings.map((pairing) => pairing.delta)),
+		widened: pairings.filter((pairing) => valueIn(pairing.delta, "s") > valueIn(noise, "s")).length
+	};
+};
+/**
 * This function tells if a timer firing came late enough to void a run. A firing two jiffies or
 * more behind its wheel slot came late because the host stopped a vCPU. With the HZ of the run,
 * the rule is in time: the delay must also reach δ_abs, because each band already includes that
@@ -55,15 +87,18 @@ const STEPS = [
 ];
 const s = (value) => quantity(Math.round(value * 1e6) / 1e6, "s");
 const name = (run) => `env ${run.environment} run ${run.index}`;
-/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
-const quantileOf = (sorted, p) => sorted[Math.min(sorted.length, Math.max(1, Math.ceil(p * sorted.length))) - 1];
+/**
+* This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
+* `quantileSorted` of @mark1russell7/rigor-statistics with the method `"nearest-rank"`.
+*/
+const quantileOf = (sorted, p) => quantileSorted(sorted, p, "nearest-rank");
 /** This function gives the spread of a set of times, or null for none. */
 const spreadOf = (times) => {
 	if (times.length === 0) return null;
 	const sorted = times.map((time) => valueIn(time, "s")).sort((a, b) => a - b);
 	return {
 		count: sorted.length,
-		median: s(middle(sorted)),
+		median: s(median(sorted)),
 		p99: s(quantileOf(sorted, .99)),
 		p999: s(quantileOf(sorted, .999)),
 		max: s(sorted.at(-1))
@@ -104,30 +139,15 @@ const spreadWords = (spread) => {
 	const ms = (time) => Math.round(valueIn(time, "s") * 1e6) / 1e3;
 	return `median ${ms(spread.median)} ms, p99 ${ms(spread.p99)} ms, p99.9 ${ms(spread.p999)} ms, max ${ms(spread.max)} ms of ${spread.count}`;
 };
-/** This function gives P(X ≤ j) for X ~ Binomial(n, 1/2), exactly. */
-const below = (n, j) => {
-	let term = 1;
-	let sum = 0;
-	for (let i = 0; i <= j; i += 1) {
-		sum += term;
-		term = term * (n - i) / (i + 1);
-	}
-	return sum / 2 ** n;
-};
 /**
 * This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
 * largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
-* at 98.8 %.
+* at 98.8 %. It is `medianInterval` of @mark1russell7/rigor-statistics at the level 0.95. An
+* empty list throws a RangeError.
 */
 const medianInterval = (sorted) => {
-	const n = sorted.length;
-	let k = 0;
-	while (k + 1 <= n / 2 && below(n, k) <= .025) k += 1;
-	return k === 0 ? [sorted[0], sorted[n - 1]] : [sorted[k - 1], sorted[n - k]];
-};
-const middle = (sorted) => {
-	const half = Math.floor(sorted.length / 2);
-	return sorted.length % 2 === 1 ? sorted[half] : (sorted[half - 1] + sorted[half]) / 2;
+	const interval = medianInterval$1(sorted, .95);
+	return [interval.low, interval.high];
 };
 /**
 * This function gives the verdict of a cell, from two tests:
@@ -210,7 +230,7 @@ const withRequests = (verdict, counted) => {
 	};
 };
 /** This function gives the median of some counts, or null for none. */
-const medianCount = (values) => values.length === 0 ? null : middle([...values].sort((a, b) => a - b));
+const medianCount = (values) => values.length === 0 ? null : median([...values].sort((a, b) => a - b));
 /** This function sums what the group of a group cell did in its counted runs, and tests each stage that has a band. */
 const groupVerdictOf = (prediction, counted, delta = NOISE) => {
 	const noise = valueIn(delta, "s");
@@ -243,7 +263,7 @@ const groupVerdictOf = (prediction, counted, delta = NOISE) => {
 		return {
 			stage: band.stage,
 			band: interval,
-			median: values.length === 0 ? null : s(middle(values)),
+			median: values.length === 0 ? null : s(median(values)),
 			outside,
 			decision: outside.length === 0 && values.length > 0 ? "holds" : "fails"
 		};
@@ -255,7 +275,7 @@ const groupVerdictOf = (prediction, counted, delta = NOISE) => {
 			const at = run.group?.stages[stage];
 			return at === void 0 ? [] : [valueIn(at, "s")];
 		});
-		medians[stage] = s(middle(values.sort((a, b) => a - b)));
+		medians[stage] = s(median(values.sort((a, b) => a - b)));
 	}
 	const lostCounts = counted.flatMap((run) => run.group?.writes.lost === null || run.group === void 0 ? [] : [run.group.writes.lost.length]);
 	const oldCounts = counted.flatMap((run) => run.group === void 0 ? [] : [run.group.writes.old]);
@@ -283,7 +303,7 @@ const groupVerdictOf = (prediction, counted, delta = NOISE) => {
 		errors: [...errors].map(([error, firsts]) => ({
 			name: error,
 			runs: firsts.length,
-			first: s(middle(firsts.sort((a, b) => a - b)))
+			first: s(median(firsts.sort((a, b) => a - b)))
 		})),
 		...lags.length === 0 ? {} : { lags: spreadOf(lags) }
 	};
@@ -337,7 +357,7 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 				kinds.set(kind, (kinds.get(kind) ?? 0) + 1);
 			}
 			const outcomes = [...kinds].map(([kind, n]) => `${n} ${kind}`).join(", ");
-			const timed = times.length === 0 ? "no time" : `median ${s(middle(times)).value} s from ${prediction.from}, range [${s(times[0]).value}, ${s(times.at(-1)).value}] s`;
+			const timed = times.length === 0 ? "no time" : `median ${s(median(times)).value} s from ${prediction.from}, range [${s(times[0]).value}, ${s(times.at(-1)).value}] s`;
 			const missed = outside.filter((each) => counted.some((run) => name(run) === each.run && run.reconnect !== void 0));
 			const late = missed.length === 0 ? "" : ` ${missed.length} runs had a wait of the reconnect outside its band.`;
 			return {
@@ -345,7 +365,7 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 				decision: "measured",
 				band: null,
 				outside: missed,
-				median: times.length === 0 ? null : s(middle(times)),
+				median: times.length === 0 ? null : s(median(times)),
 				why: `${counted.length} runs measured: ${outcomes}; ${timed}.${late} ${prediction.why}`
 			};
 		}
@@ -362,13 +382,13 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 			reordering.fast,
 			reordering.seen
 		].some((count) => (count ?? 0) > 0) ? ` Reordering: ${reorderingWords(reordering)}.` : "";
-		const why = samples.length === 0 ? `${counted.length} runs measured, with no reply: ${prediction.why}` : `${counted.length} runs, ${samples.length} replies: median ${s(middle(samples)).value} s, p99 ${s(quantileOf(samples, .99)).value} s, slowest ${s(samples.at(-1)).value} s, ${retransmissions} retransmissions, ${ended.length} connections ended.${reordered} ${prediction.why}`;
+		const why = samples.length === 0 ? `${counted.length} runs measured, with no reply: ${prediction.why}` : `${counted.length} runs, ${samples.length} replies: median ${s(median(samples)).value} s, p99 ${s(quantileOf(samples, .99)).value} s, slowest ${s(samples.at(-1)).value} s, ${retransmissions} retransmissions, ${ended.length} connections ended.${reordered} ${prediction.why}`;
 		return {
 			...empty,
 			decision: "measured",
 			band: null,
 			outside: [],
-			median: samples.length === 0 ? null : s(middle(samples)),
+			median: samples.length === 0 ? null : s(median(samples)),
 			...reordering === void 0 ? {} : { reordering },
 			why
 		};
@@ -411,7 +431,7 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 		why: "no run measured its time"
 	};
 	const [from, to] = medianInterval(values);
-	const median = s(middle(values));
+	const median$1 = s(median(values));
 	const interval = {
 		low: s(from),
 		high: s(to)
@@ -424,13 +444,13 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 	const disjoint = to < wide.low || from > wide.high;
 	const off = new Set(outside.map((each) => each.run)).size;
 	const counts = `${counted.length - off} of ${counted.length} runs inside [${band.low.value}, ${band.high.value}] s`;
-	const centre = `median ${median.value} s, its interval [${interval.low.value}, ${interval.high.value}] s`;
+	const centre = `median ${median$1.value} s, its interval [${interval.low.value}, ${interval.high.value}] s`;
 	const result = {
 		counted: counted.length,
 		voided,
 		band,
 		outside,
-		median,
+		median: median$1,
 		medianInterval: interval
 	};
 	if (outside.length > 0 || disjoint) return {
@@ -483,12 +503,12 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 *   These are the runs 39390222333 and 39903020657 of the client repository.
 *
 * The bound is 1.5 ms: the maximum and a margin of 0.48 ms. The pairing of a drop with its act
-* uses it, or δ_abs when δ_abs is longer. The band of a drop adds it to its high bound (the WS
-* catalog of the cells). Read the records again after a change to the subject, to Node or to
+* uses it, or the pairing window of the run when that window is longer. The band of a drop adds
+* it to its high bound (the WS catalog of the cells). Read the records again after a change to the subject, to Node or to
 * the runners.
 */
 const DROP_HANDLING = quantity(1.5, "ms");
-/** This function gives the window of the act of a drop after its line, in seconds: `DROP_HANDLING`, or δ_abs when δ_abs is longer. */
+/** This function gives the window of the act of a drop, in seconds: `DROP_HANDLING`, or the pairing window (`delta`) when it is longer. */
 const dropWindow = (delta) => Math.max(valueIn(DROP_HANDLING, "s"), valueIn(delta, "s"));
 /** This function gives the interval between two instants on the one clock, in seconds to the microsecond. */
 const between$3 = (from, to) => quantity(Math.round((to - from) / 1e3) / 1e6, "s");
@@ -563,9 +583,9 @@ const closeOrExit = (line, left, exit, delta = NOISE) => {
 };
 /**
 * This function tells how a drop differs from the way that its prediction gives, or gives null.
-* A close closes the socket at once: in the handling time of the program (`DROP_HANDLING`), or in
-* δ_abs (`delta`) when δ_abs is longer. A close frame is a write, and the program does not close
-* the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
+* A close closes the socket at once, in the handling time of the program (`DROP_HANDLING`). If
+* the pairing window of the run (`delta`) is longer, that window is the limit. A close frame is a
+* write, and the program does not close the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
 */
 const dropFinding = (expected, drop, left, delta = NOISE, exited) => {
 	const noise = dropWindow(delta);
@@ -578,7 +598,25 @@ const dropFinding = (expected, drop, left, delta = NOISE, exited) => {
 	return soon ? "the program closed its socket at the drop, where a close frame leaves it open" : null;
 };
 const isWrite = (record) => record.ev === "tx";
-/** This function gives each ping of the program on the connection of the run, with the kernel's stamp of its write. */
+/**
+* This function measures the jitter of a program from its acts before `until`, the start of the
+* fault. An act is a `write` line or a `ping` line on the connection. Its delay goes from the line
+* to the first write of data on the socket after it, before the next act and before `until`. An
+* act with no such write does not count. The bound is the longest delay, to the microsecond.
+*/
+const jitterOfLines = (lines, socket, local, until) => {
+	const acts = lines.filter((line) => (line.ev === "write" || line.ev === "ping") && line.t < until && onConnection(line, local));
+	const delays = acts.flatMap((line, at) => {
+		const next = Math.min(acts[at + 1]?.t ?? until, until);
+		const write = socket.find((record) => isWrite(record) && (record.seg?.len.value ?? 0) > 0 && record.mono >= line.t && record.mono < next);
+		return write === void 0 ? [] : [write.mono - line.t];
+	});
+	return {
+		acts: delays.length,
+		bound: delays.length === 0 ? null : quantity(Math.round(Math.max(...delays) / 1e3) / 1e3, "ms")
+	};
+};
+/** This function gives each ping of the program on the connection, with the kernel's stamp of its write in the pairing window (`delta`). */
 const pingsOf = (lines, socket, local, delta = NOISE) => lines.filter((line) => line.ev === "ping" && onConnection(line, local)).map((line) => eventOf(socket, line, isWrite, delta));
 /**
 * This function gives the first ping that got no answer: no segment with data reached the socket
@@ -589,7 +627,7 @@ const firstUnanswered = (pings, socket, until = Number.POSITIVE_INFINITY) => pin
 * This function gives the first drop of the connection by its program. The kernel stamps it as the
 * write of a close frame. Or it stamps the change of the socket out of ESTABLISHED: a close or an
 * abort. That stamp comes in the handling time of the program after the drop line
-* (`DROP_HANDLING`), or in δ_abs (`delta`) when δ_abs is longer.
+* (`DROP_HANDLING`). If the pairing window of the run (`delta`) is longer, that window is the limit.
 */
 const dropOf = (lines, socket, local, delta = NOISE) => {
 	const line = lines.find((each) => each.ev === "drop" && onConnection(each, local));
@@ -1680,7 +1718,11 @@ const crossingsOf = (run, hop, toClient, toTarget) => {
 *   than the one that the prediction gives is a finding.
 */
 const measure = (cell, run) => {
-	const read = measureSocket(cell, run);
+	const socketRead = measureSocket(cell, run);
+	const read = run.jitter === void 0 ? socketRead : {
+		...socketRead,
+		pairing: pairingOf(cell, run)
+	};
 	const expected = cell.prediction.request;
 	if (cell.probe.http === void 0 && expected === void 0) return read;
 	const request = requestOf(run.events);
@@ -1696,6 +1738,24 @@ const measure = (cell, run) => {
 		finding
 	};
 };
+/**
+* This function measures the jitter of the program of the observer in a run, from its records
+* (`Jitter`). The acts count up to the start of the fault, or up to the reply of the client when
+* the fault has no stamp. A run with no lines of a program, or no socket of the observer, has no act.
+*/
+const jitterOf = (cell, run) => {
+	const lines = programLines(cell, run);
+	const ready = run.events.find((event) => event.ev === "ready");
+	const place = lines.length === 0 || ready === void 0 ? void 0 : socketOf(cell, run);
+	if (ready === void 0 || place === void 0) return {
+		acts: 0,
+		bound: null
+	};
+	const socket = run.kernel.filter((record) => record.netns === place.netns && record.cookie === place.cookie);
+	const local = run.events.find((event) => event.ev === "connected")?.["local"];
+	const named = cell.observer === "server" ? socket.find((record) => record.dst !== void 0)?.dst ?? local : local;
+	return jitterOfLines(lines, socket, named, run.fault?.t0 ?? ready.t);
+};
 /** This function tells how a request reading differs from its prediction, or gives null. */
 const requestFinding = (expected, read) => {
 	if (read === null) return `the second request never went out, where it should meet: ${requestWords(expected)}`;
@@ -1847,7 +1907,8 @@ const measureSocket = (cell, run) => {
 	const lines = programLines(cell, run);
 	const named = server ? socket.find((record) => record.dst !== void 0)?.dst ?? local : local;
 	const kernelEnded = reported?.mono ?? closeWait?.mono ?? own?.mono ?? seen?.t;
-	const first = dropOf(lines, socket, named, noiseOf(cell));
+	const paired = pairingOf(cell, run).delta;
+	const first = dropOf(lines, socket, named, paired);
 	const drop = first !== void 0 && (kernelEnded === void 0 || first.at <= kernelEnded) ? first : void 0;
 	const dropped = drop !== void 0;
 	const outcome = dropped ? { kind: "dropped" } : reported !== void 0 ? {
@@ -1860,7 +1921,7 @@ const measureSocket = (cell, run) => {
 	const ended = drop?.at ?? kernelEnded;
 	const noticed = reported !== void 0 && seen !== void 0 && !dropped ? between(reported.mono, seen.t) : null;
 	const { prediction } = cell;
-	const pings = pingsOf(lines, socket, named, noiseOf(cell));
+	const pings = pingsOf(lines, socket, named, paired);
 	const before = run.fault?.t1 ?? ready.t;
 	const referenceAt = (from) => {
 		if (from === "request-sent") return request.t;
@@ -2052,7 +2113,7 @@ const measureSocket = (cell, run) => {
 		left: closed,
 		exited: void 0
 	} : closeOrExit(drop.line, closed, exitOf(run, cookie), noiseOf(cell));
-	const how = prediction.drop === void 0 || drop === void 0 || left === void 0 ? null : dropFinding(prediction.drop, drop, left, noiseOf(cell), exited);
+	const how = prediction.drop === void 0 || drop === void 0 || left === void 0 ? null : dropFinding(prediction.drop, drop, left, paired, exited);
 	const found = [
 		matches ? null : `it ended with ${words}, not ${prediction.errno}`,
 		late,
@@ -5581,14 +5642,18 @@ const inEnvironment = async (cell, environment, count, say) => {
 		if (latency !== null) await lab.netem(latency, "target");
 		await lab.warm();
 		const manifest = await lab.manifest(await lab.sysctl(cell.sysctls), settings, targetSysctls);
+		const timed = (run) => ({
+			...run,
+			jitter: jitterOf(cell, run)
+		});
 		const warmup = {
-			...await once(lab, cell, environment, -1, endsEnvironment(cell)),
+			...timed(await once(lab, cell, environment, -1, endsEnvironment(cell))),
 			warmup: true
 		};
 		say(line(cell, warmup, measure(cell, warmup)));
 		const runs = [];
 		for (let index = 0; index < count; index += 1) {
-			const run = await once(lab, cell, environment, index);
+			const run = timed(await once(lab, cell, environment, index));
 			runs.push(run);
 			say(line(cell, run, measure(cell, run)));
 		}
@@ -5740,6 +5805,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { CLIENT_NAMES, CLUSTER_STAGES, CONVERGE_MS, DROP_HANDLING, GIVES_AWAY, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, callOf, clockOffsetOf, closeOrExit, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isHopPlace, judge, lagsOf, latestEndOf, leftAfter, logNameOf, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicOf, nodeClientImage, nodeCommand, nodeHttpImage, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, onMonotonic, openClusterLab, openGroupLab, openLab, openReplicaSetLab, peersOf, pgClientImage, pingsOf, plainOf, planOf, programLines, programOf, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subjectClient, subjectProblems, subscriptionsOf, targetImageOf, targetSourceOf, templated, toolJsonOf, toxicBody, unlockedManifests, unpinnedBases, verdictOf, viewOf, writesOf };
+export { CLIENT_NAMES, CLUSTER_STAGES, CONVERGE_MS, DROP_HANDLING, GIVES_AWAY, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, callOf, clockOffsetOf, closeOrExit, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isHopPlace, jitterOf, jitterOfLines, judge, lagsOf, latestEndOf, leftAfter, logNameOf, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicOf, nodeClientImage, nodeCommand, nodeHttpImage, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, onMonotonic, openClusterLab, openGroupLab, openLab, openReplicaSetLab, pairingOf, pairingsOf, peersOf, pgClientImage, pingsOf, plainOf, planOf, programLines, programOf, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subjectClient, subjectProblems, subscriptionsOf, targetImageOf, targetSourceOf, templated, toolJsonOf, toxicBody, unlockedManifests, unpinnedBases, verdictOf, viewOf, writesOf };
 
 //# sourceMappingURL=index.js.map