@mark1russell7/harness 0.15.0 → 0.15.1

package/build/index.d.ts

@@ -181,6 +181,35 @@ export declare const streamsLoadOf: (events: readonly ProbeEvent[], streams: rea
   readonly pool: RunLoad;
   readonly streams: Readonly<Record<string, RunLoad>>;
 } | null;
+/** This function gives the pool of some measures: it sums the counts and joins the times, in the order of the measures. */
+export declare const poolOf: (measures: readonly RunLoad[]) => RunLoad & {
+  readonly failed: number;
+};
+/**
+ * This time is the tolerance of a closed-loop estimate, in ms. A send later than its expected time
+ * by more than this tolerance is a pause of the client: a driver gap.
+ */
+export declare const CLOSED_TOLERANCE = 5;
+/**
+ * A run estimate is the latency of the open loop that a closed-loop stream hid (SYS-91). The package
+ * rigor-chaos puts back each send that a stall or a pause of the client hid (`closedLoopPlan`).
+ * `hidden` counts those sends, and `driverGaps` counts the pauses of the client. Its times are in ms.
+ */
+type RunEstimate = LoadMeasure & {
+  readonly hidden: number;
+  readonly driverGaps: number;
+  readonly driverGapTotal: number;
+};
+/**
+ * This function gives the estimate of one closed-loop stream from its requests, in the order of their
+ * sends. Each time is a time of a line of the client. The client waits `interval` ms after each reply,
+ * thus the interval is also the pause of the driver. The function gives undefined for no request, and
+ * for a request with no reply before the last request.
+ */
+export declare const estimateOf: (requests: ReadonlyArray<{
+  readonly sent: number;
+  readonly done: number | null;
+}>, end: number, interval: number) => RunEstimate | undefined;
 /** A load spread is a part of the distribution of one measure of an open-loop cell, over its counted runs. */
 interface LoadSpread {
   readonly p50: Quantity;
@@ -224,6 +253,22 @@ export declare const loadVerdict: (prediction: LoadPrediction, runs: ReadonlyArr
   readonly name: string;
   readonly load: RunLoad | undefined;
 }>) => LoadJudgement;
+/**
+ * An estimate verdict sums the closed-loop estimates of a cell over its counted runs. Its latency
+ * is an estimate of the open loop, not a measure of it: a record of an open-loop client stays the
+ * better measure. Each hidden send after a request with no reply counts at its age at the end.
+ */
+interface EstimateVerdict {
+  readonly planned: number;
+  readonly hidden: number;
+  readonly driverGaps: number;
+  readonly driverGapTotal: Quantity;
+  readonly latency: LoadSpread | null;
+  /** This text gives the estimate in words, for the verdict of the cell. */
+  readonly words: string;
+}
+/** This function gives the estimate verdict of the counted runs, or undefined when no run has an estimate. */
+export declare const estimateVerdict: (estimates: ReadonlyArray<RunEstimate | undefined>) => EstimateVerdict | undefined;
 //#endregion
 //#region src/driver.d.ts
 /**
@@ -785,6 +830,8 @@ interface Verdict {
   readonly reordering?: Reordering;
   /** This record is the load of an open-loop cell over its counted runs. */
   readonly load?: LoadVerdict;
+  /** This record is the estimate of the open loop of a closed-loop stream over its counted runs (SYS-91). */
+  readonly estimate?: EstimateVerdict;
   /** This record is the time of the proxy of a calibration cell, in each direction. */
   readonly proxy?: {
     readonly hop: string;
@@ -974,6 +1021,8 @@ interface Measured {
   readonly samples?: readonly Quantity[];
   /** This measure is the run of an open-loop cell against its schedule (`Run.schedule`), with its failed replies. Its times are in ms. */
   readonly load?: RunLoad;
+  /** This estimate is the open loop that a closed-loop stream of the client of the harness hid (SYS-91). Its times are in ms. */
+  readonly estimate?: RunEstimate;
   /** This count is the number of keepalive probes that the kernel sent. */
   readonly probes: number;
   /** This count is the number of segments that the kernel sent again. */
@@ -2661,5 +2710,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 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 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 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 };
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -2,7 +2,7 @@ import { A as unlockedManifests, B as isHopPlace, C as programOf, D as subjectPr
 import { quantity, valueIn } from "@mark1russell7/quantity";
 import { median, medianInterval as medianInterval$1, quantile, quantileSorted } from "@mark1russell7/rigor-statistics";
 import { rungVerdict } from "@mark1russell7/rigor-bench";
-import { measureLoad, schedule, scheduleHeld } from "@mark1russell7/rigor-chaos";
+import { closedLoopPlan, measureLoad, schedule, scheduleHeld } from "@mark1russell7/rigor-chaos";
 import { createHash, randomBytes } from "node:crypto";
 import { execFile } from "node:child_process";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
@@ -99,21 +99,56 @@ const streamsLoadOf = (events, streams) => {
 	const start = events.find((event) => event.ev === "scheduled")?.t;
 	if (start === void 0) return null;
 	const each = streams.map((stream) => [stream.key, measureOf(events, start, stream.schedule, stream.key)]);
-	const measures = each.map(([, measure]) => measure);
+	return {
+		pool: poolOf(each.map(([, measure]) => measure)),
+		streams: Object.fromEntries(each)
+	};
+};
+/** This function gives the pool of some measures: it sums the counts and joins the times, in the order of the measures. */
+const poolOf = (measures) => {
 	const sum = (count) => measures.reduce((total, measure) => total + count(measure), 0);
 	const join = (times) => measures.flatMap(times);
 	return {
-		pool: {
-			planned: sum((measure) => measure.planned),
-			unsent: sum((measure) => measure.unsent),
-			unfinished: sum((measure) => measure.unfinished),
-			failed: sum((measure) => measure.failed ?? 0),
-			latency: join((measure) => measure.latency),
-			service: join((measure) => measure.service),
-			lag: join((measure) => measure.lag),
-			censored: join((measure) => measure.censored)
-		},
-		streams: Object.fromEntries(each)
+		planned: sum((measure) => measure.planned),
+		unsent: sum((measure) => measure.unsent),
+		unfinished: sum((measure) => measure.unfinished),
+		failed: sum((measure) => measure.failed ?? 0),
+		latency: join((measure) => measure.latency),
+		service: join((measure) => measure.service),
+		lag: join((measure) => measure.lag),
+		censored: join((measure) => measure.censored)
+	};
+};
+/**
+* This time is the tolerance of a closed-loop estimate, in ms. A send later than its expected time
+* by more than this tolerance is a pause of the client: a driver gap.
+*/
+const CLOSED_TOLERANCE = 5;
+/**
+* This function gives the estimate of one closed-loop stream from its requests, in the order of their
+* sends. Each time is a time of a line of the client. The client waits `interval` ms after each reply,
+* thus the interval is also the pause of the driver. The function gives undefined for no request, and
+* for a request with no reply before the last request.
+*/
+const estimateOf = (requests, end, interval) => {
+	const start = requests[0]?.sent;
+	if (start === void 0 || requests.slice(0, -1).some((request) => request.done === null)) return void 0;
+	const loop = requests.map((request) => ({
+		sent: fromStart(start, request.sent),
+		done: request.done === null ? null : fromStart(start, request.done)
+	}));
+	const stop = Math.max(fromStart(start, end), ...loop.map((request) => request.done ?? request.sent), interval);
+	const run = closedLoopPlan(loop, {
+		interval,
+		end: stop,
+		tolerance: 5,
+		pause: interval
+	});
+	return {
+		...measureLoad(run.plan, run.completions, stop),
+		hidden: run.hidden,
+		driverGaps: run.driverGaps,
+		driverGapTotal: run.driverGapTotal
 	};
 };
 /** This function gives the spread of a list of times in ms, or null for no time. */
@@ -246,6 +281,28 @@ const loadVerdict = (prediction, runs) => {
 		}
 	};
 };
+/** This function gives the estimate verdict of the counted runs, or undefined when no run has an estimate. */
+const estimateVerdict = (estimates) => {
+	const runs = estimates.filter((estimate) => estimate !== void 0);
+	if (runs.length === 0) return void 0;
+	const pool = poolOf(runs);
+	const total = (count) => runs.reduce((sum, estimate) => sum + count(estimate), 0);
+	const hidden = total((estimate) => estimate.hidden);
+	const driverGaps = total((estimate) => estimate.driverGaps);
+	const driverGapTotal = total((estimate) => estimate.driverGapTotal);
+	const latency = spreadOf$1([...pool.latency, ...pool.censored]);
+	const seconds = (time) => (valueIn(time, "ms") / 1e3).toFixed(3);
+	const spread = latency === null ? "no latency" : `median ${seconds(latency.p50)} s, p99 ${seconds(latency.p99)} s, slowest ${seconds(latency.max)} s`;
+	const gaps = driverGaps === 0 ? "no pause of the client" : `${driverGaps} pauses of the client, ${Math.round(driverGapTotal)} ms in all`;
+	return {
+		planned: pool.planned,
+		hidden,
+		driverGaps,
+		driverGapTotal: quantity(driverGapTotal, "ms"),
+		latency,
+		words: `The estimate of the open loop puts back ${hidden} hidden sends, with ${gaps}: ${spread}.`
+	};
+};
 //#endregion
 //#region src/verdict.ts
 /** This function gives the words of the outcome of a second request: its connection, a retry, and its end. */
@@ -687,7 +744,9 @@ 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(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}`;
+		const estimate = estimateVerdict(counted.map((run) => run.estimate));
+		const estimated = estimate === void 0 ? "" : ` ${estimate.words}`;
+		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}${estimated} ${prediction.why}`;
 		return {
 			...empty,
 			decision: "measured",
@@ -696,6 +755,7 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 			median: samples.length === 0 ? null : s(median(samples)),
 			...samples.length === 0 ? {} : { slowest: s(samples.at(-1)) },
 			...reordering === void 0 ? {} : { reordering },
+			...estimate === void 0 ? {} : { estimate },
 			why
 		};
 	}
@@ -3019,11 +3079,18 @@ const measureSocket = (cell, run) => {
 		};
 		const sends = load === void 0 ? events.filter((event) => event.ev === "sent").slice(1) : [];
 		const answers = events.some((event) => event.ev === "replied") ? "replied" : "data";
-		const samples = sends.flatMap((send, n) => {
+		const requests = sends.map((send, n) => {
 			const next = sends[n + 1]?.t ?? Infinity;
-			const reply = events.find((event) => event.ev === answers && event.t > send.t && event.t < next);
-			return reply === void 0 ? [] : [between(send.t, reply.t)];
+			return {
+				send,
+				reply: events.find((event) => event.ev === answers && event.t > send.t && event.t < next)
+			};
 		});
+		const samples = requests.flatMap(({ send, reply }) => reply === void 0 ? [] : [between(send.t, reply.t)]);
+		const estimate = cell.probe.mode === "stream" && cell.probe.driver === void 0 && cell.probe.interval !== void 0 ? estimateOf(requests.map(({ send, reply }) => ({
+			sent: send.t,
+			done: reply?.t ?? null
+		})), events.reduce((latest, event) => Math.max(latest, event.t), 0), valueIn(cell.probe.interval, "ms")) : void 0;
 		const from = prediction.from === void 0 ? void 0 : referenceAt(prediction.from);
 		const until = ended ?? after.at(-1)?.t;
 		const peerRecords = peerCookie === void 0 ? [] : kernel.filter((record) => record.netns === peerNetns && record.cookie === peerCookie);
@@ -3056,6 +3123,7 @@ const measureSocket = (cell, run) => {
 			steps: retransmitted.filter((record) => record.mono > request.t).map((record) => between(request.t, record.mono)),
 			samples,
 			...load === void 0 ? {} : { load },
+			...estimate === void 0 ? {} : { estimate },
 			reordering: reorderingOf(socket.filter((record) => record.mono > request.t), peerRecords.filter((record) => record.mono > request.t)),
 			...crossings,
 			void: voided
@@ -8935,6 +9003,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { AWS_FROM, CLIENT_CAPABILITIES, CLIENT_NAMES, 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, 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, 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, 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 };
 
 //# sourceMappingURL=index.js.map