@mark1russell7/harness 0.10.0 → 0.11.1

package/README.md

@@ -107,10 +107,11 @@ A fault names a member by its role at the start of a run: `primary`, or `replica
   - or by itself, a gap after its first reply (`gap`), for the keep-alive race.
 - **The lines of an HTTP client.** It writes the lines of the TCP client, with the number `i` of the request on each line of a request. It also writes the connection of each try of a request (`request`, then `retry`), with its local address and a flag for a reused connection. Each connection gets a `conn` line, and each end of a connection a line (`eof`, `conn-error`, `closed`). The end of the second request is a `done` line.
 - **A target with a script.** A target can take files before it starts (`Target.files`), for example the script of a Node server on the stock Node image. A target that writes JSON lines (`Target.lines`) gives them to each run (`Run.server`). The manifest holds the sha256 of each file and the first line of the target.
-- **The WebSocket client** (`Cell.client` is `procedures-ws`) is the `WebSocketTransport` of `@procedures/client` 0.3.0. The cell gives each of its settings (`probe.ws`): the class of its sockets, the heartbeat, the reconnect, and the times of a call.
+- **The WebSocket client** (`Cell.client` is `procedures-ws`) is the `WebSocketTransport` of `@procedures/client` 0.7.0. The cell gives each of its settings (`probe.ws`): the class of its sockets, the heartbeat, the reconnect, and the times of a call.
   - Its first request is `harness.echo`. In flight, its request into the fault is `harness.echo`, or `harness.hold` for a held reply.
   - It writes the lines of the TCP client. It also writes a line for each act of the program: `ping`, `drop`, `reconnecting` and `dial`.
-  - The class of its sockets is the global `WebSocket` of Node, or the `WebSocket` of the `ws` package (the option `webSocket`). The transport gets a subclass of that class. The subclass writes a line, then gives the work to its class. Thus the transport, undici and ws operate as they do without it.
+  - The class of its sockets is the global `WebSocket` of Node, with the transport of the root entry. Or it is the `WebSocket` of the `ws` package, with the transport of the Node entry `@procedures/client/node`.
+  - The transport gets a subclass of that class. The subclass writes a line, then gives the work to its class. Thus the transport, undici and ws operate as they do without it.
   - The subclass has `terminate()` only when its class has it, because the transport drops a socket with `terminate()` when it exists.
 - **A target from an image of the harness** (`Target.harness`). The target operates an image of the harness in place of its stock image. The procedures server is a script in the image of the WebSocket client (`server-ws.mjs`). Thus the client and the server use one release of the package. `Target.image` is the stock base of that image, and the manifest names both.
 - **An agent** (`lab.agent(image, command, { pid })`) is a container in the network namespace of the target. With `pid`, it also shares the process namespace of the target, thus it can signal the server process. Its JSON lines and its `exec` stay available to the caller.
@@ -133,7 +134,7 @@ The harness builds six images. The tag of each image comes from the content of a
   - The events of the driver are `sdam` lines (the heartbeats and the changes of each server), `cmap` lines (the pools) and `command` lines (each try of an operation).
   - Each operation is a `sent` line, then an `ack` line or a `fail` line. An `ack` line has the server that accepted it. A `fail` line has the name and the labels of its error.
   - The same image holds `stepdown-mongo.mjs`, the sender of `replSetStepDown`.
-- **The procedures image** (`image/procedures`) holds `@procedures/client` 0.3.0 and `ws` 8.22.0 on Node 24.21.0, whose WebSocket is undici 7.29.1. The digest of the image and an npm lockfile pin them. It holds the WebSocket client (`client-ws.mjs`) and the script of the procedures server (`server-ws.mjs`). Each takes each of its settings as a flag, and it has no default.
+- **The procedures image** (`image/procedures`) holds `@procedures/client` 0.7.0 and `ws` 8.22.0 on Node 24.21.0, whose WebSocket is undici 7.29.1. The digest of the image and an npm lockfile pin them. It holds the WebSocket client (`client-ws.mjs`) and the script of the procedures server (`server-ws.mjs`). Each takes each of its settings as a flag, and it has no default. The lockfile holds one copy of `ws`, and the client stops when `@procedures/client/node` resolves another one.
 - **The router image** (`image/router`) is a digest-pinned Alpine with conntrack-tools, nftables, iproute2 and Python. `mbx.sh` sets the form of the router in one nftables table, `ctwatch.py` writes the conntrack events, and `resetter.py` sends the resets of the `reset-both` form. Each run records its packages in the manifest.
 
 The build does the `cargo test` of the two crates. Thus the record decoder passes its tests before an image exists. Each amount that the native programs print is a quantity in a canonical unit. For example, an RTO is in `jiffy`, a round trip in `us`, and a segment in `B`.
@@ -202,7 +203,11 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
   - A drop counts when it comes before each report of the kernel. A report of the kernel that comes first is the detection, and the drop after it is not.
   - The second view is the stamps of the program: from its `ping` line to its `drop` line. The steps are the later pings, each from the reference.
   - The lines of a client name the socket by its local address (`local`), and the lines of a server by its peer (`peer`). For the server, the lines are the lines of the target. A line whose address is null is about a try that did not open.
+  - The harness reads the peer of a server from the records of its socket. Behind a router, that peer is the address of the router, not the address of the client.
+  - A first ping without an answer can come late, for example at a beat of a server whose phase no document gives. Then the prediction gives its latest time after the reply (`startsBy`), and the run waits that much longer.
   - A prediction can say how the program drops (`drop`). A close frame (`frame`) is a write, and the socket stays ESTABLISHED after it. A close (`close`) closes the socket in δ_abs: a FIN or an abort. Another drop is a finding. A FIN of the peer that answers a close frame is no close by the program. The run gives the time from the `drop` line to the close by the program (`left`).
+  - The client process ends at the end of each run, and its kernel then closes each socket that is still open. A prediction can say that the program is that client process (`exits`). Then a close in δ_abs of that end is no close by the program: `left` stays null, and `exited` gives the time.
+  - The end of the process is the first change out of ESTABLISHED of another socket of the client after its last `dial` line (`exitOf`). The program dropped none of these sockets.
   - A heartbeat is a timer of the program. The retransmit timer of its ping fires in the same interval. Thus a run whose retransmit timer was two jiffies or more behind its wheel slot is void: the VM stopped a vCPU.
 - **The reconnect** (`reconnectOf`). A prediction with `reconnects` also reads what the client did after the detection.
   - Each wait goes from a `reconnecting` line, where the program starts its timer, to its next `dial` line, where it makes the socket. A wait outside its band, widened by δ_abs, is a finding. A try that did not come is a finding too.
@@ -263,7 +268,7 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
 - **An HTTP client** (`Verdict.requests`). The verdict counts each outcome of the second request over the counted runs. A measurement-only cell also gives them in its reason.
 - **The reconnect** (`Verdict.reconnect`). A wait outside its band is a finding of its run, thus the cell fails. The verdict gives the spread of each wait, of the first SYN, of the first ESTABLISHED and of the work before each connect(2). Its reason says the medians.
 - **A call in flight** (`Verdict.calls`). The verdict counts each outcome of the call in flight of a WebSocket client, and its reason says them.
-- **The socket after a drop** (`Verdict.left`). The verdict gives the spread of the time from a drop to the close of its socket by the program. It also counts the runs where the program did not close it.
+- **The socket after a drop** (`Verdict.left`). The verdict gives the spread of the time from a drop to the close of its socket by the program. It also counts the runs where the program did not close it. For the runs where the socket stayed open until the end of the client process, it gives the spread of that end (`exited`).
 
 The distribution test needs a simulator, which does not exist at this time.
 

package/build/index.d.ts

@@ -456,6 +456,12 @@ type Prediction = {
   readonly low: Quantity;
   /** This time is the closed form, plus the most that the timer can fire late, plus each proxy time. */
   readonly high: Quantity;
+  /**
+   * This time is the latest reference of the band after the reply of the client. It is for a
+   * reference that can come late, for example the first ping without an answer of a server
+   * heartbeat. The run then waits that much longer for the detection.
+   */
+  readonly startsBy?: Quantity;
   readonly rtt?: RttRange;
   readonly through?: readonly ProxyTime[];
   readonly group?: GroupPrediction;
@@ -468,6 +474,12 @@ type Prediction = {
    * ESTABLISHED at once (`close`).
    */
   readonly drop?: "frame" | "close";
+  /**
+   * This flag tells that the program of the observer is the client process, which ends at the
+   * end of the run. Its kernel then closes each socket that is still open. A close of the
+   * socket at that end is not a close by the program, thus `left` stays null for it (`exited`).
+   */
+  readonly exits?: true;
 } | {
   readonly detects: false;
   readonly window: Quantity;
@@ -792,6 +804,13 @@ interface HopPlace {
 type FaultPlace = "target" | "client" | HopPlace | GroupPlace;
 /** This function tells if a fault place is a hop of a topology. */
 export declare const isHopPlace: (place: FaultPlace | undefined) => place is HopPlace;
+/**
+ * This function gives the latest end of a band in seconds, from the reply of the client. It is
+ * the high bound, after the latest reference of the band (`startsBy`).
+ */
+export declare const latestEndOf: (prediction: Extract<Prediction, {
+  readonly detects: true;
+}>) => number;
 /** A middlebox event is one line of the router: a change of a conntrack entry, or a reset that it sent. `t` is CLOCK_MONOTONIC in nanoseconds. */
 interface MiddleboxEvent {
   readonly ev: string;
@@ -923,12 +942,29 @@ export declare const programLines: (cell: Cell, run: Run) => readonly ProbeEvent
  * the peer (CLOSE_WAIT) is not such a close. It is null when the socket did not close itself.
  */
 export declare const leftAfter: (socket: readonly KernelRecord[], line: ProbeEvent) => Quantity | null;
+/**
+ * This function gives the end of the client process in a run, as the kernel stamps it. The process
+ * ends after its last try, and its kernel then closes each socket that is still open, at one
+ * instant. Thus the end is the first change out of ESTABLISHED of another socket of the client
+ * after its last `dial` line. The program dropped none of these sockets. It is undefined when the
+ * record has no such change, for example when the last try did not open.
+ */
+export declare const exitOf: (run: Run, cookie: number | undefined) => number | undefined;
+/**
+ * This function separates a close of the socket by the program from the end of the client process.
+ * `left` is the time from the drop line to the close, and `exit` is the end of the process. A close
+ * in δ_abs of that end is the end, not the program: `left` becomes null, and `exited` keeps the time.
+ */
+export declare const closeOrExit: (line: ProbeEvent, left: Quantity | null, exit: number | undefined, delta?: Quantity) => {
+  readonly left: Quantity | null;
+  readonly exited?: Quantity;
+};
 /**
  * This function tells how a drop differs from the way that its prediction gives, or gives null.
  * A close closes the socket in δ_abs. 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.
  */
-export declare const dropFinding: (expected: "frame" | "close", drop: ProgramEvent, left: Quantity | null, delta?: Quantity) => string | null;
+export declare const dropFinding: (expected: "frame" | "close", drop: ProgramEvent, left: Quantity | null, delta?: Quantity, exited?: Quantity) => string | null;
 /** This function gives each ping of the program on the connection of the run, with the kernel's stamp of its write. */
 export declare const pingsOf: (lines: readonly ProbeEvent[], socket: readonly KernelRecord[], local: unknown, delta?: Quantity) => ProgramEvent[];
 /**
@@ -1239,9 +1275,15 @@ interface Measured {
   /**
    * This time is from the drop line of the program to the close of its socket by its own side: a
    * FIN or an abort. A prediction that says how the program drops (`drop`) gets it. It is null
-   * when the socket did not close itself in the run.
+   * when the socket did not close itself in the run. A prediction can say that the client process
+   * ends with the run (`exits`). Then a close at that end is no close by the program, and `left` is null.
    */
   readonly left?: Quantity | null;
+  /**
+   * This time is from the drop line of the program to the end of the client process. A socket gets
+   * it when it stayed open until that end. The kernel closed it then, not the program (`exits`).
+   */
+  readonly exited?: Quantity;
   /** This text is the reason that the run cannot count, or null. A void run is not a pass and not a finding. */
   readonly void: string | null;
   /** This text tells what in the run disagrees with the prediction, other than its timing, or null. */
@@ -1421,10 +1463,13 @@ interface Verdict {
   /**
    * This record is the time from a drop of the program to the close of its socket by its own side,
    * over the counted runs. It also counts the runs where the socket did not close itself.
+   * `exited` is the spread of the end of the client process, for the runs where the socket stayed
+   * open until that end (`Measured.exited`).
    */
   readonly left?: {
     readonly spread: Spread | null;
     readonly stayed: number;
+    readonly exited?: Spread | null;
   };
   readonly why: string;
 }

package/build/index.js

@@ -8,6 +8,11 @@ import { fileURLToPath } from "node:url";
 //#region src/cell.ts
 /** This function tells if a fault place is a hop of a topology. */
 const isHopPlace = (place) => typeof place === "object" && "hop" in place;
+/**
+* This function gives the latest end of a band in seconds, from the reply of the client. It is
+* the high bound, after the latest reference of the band (`startsBy`).
+*/
+const latestEndOf = (prediction) => valueIn(prediction.high, "s") + (prediction.startsBy === void 0 ? 0 : valueIn(prediction.startsBy, "s"));
 //#endregion
 //#region src/verdict.ts
 /** This function gives the words of the outcome of a second request: its connection, a retry, and its end. */
@@ -166,12 +171,15 @@ const withProgram = (verdict, counted) => {
 	const outcomes = {};
 	for (const call of calls) outcomes[call.outcome] = (outcomes[call.outcome] ?? 0) + 1;
 	const gone = lefts.flatMap((each) => each === null ? [] : [each]);
+	const ends = counted.flatMap((run) => run.exited === void 0 ? [] : [run.exited]);
 	const left = lefts.length === 0 ? void 0 : {
 		spread: spreadOf(gone),
-		stayed: lefts.length - gone.length
+		stayed: lefts.length - gone.length,
+		...ends.length === 0 ? {} : { exited: spreadOf(ends) }
 	};
+	const ended = ends.length === 0 ? "" : `: in ${ends.length} the socket stayed open until the client process ended, median ${ms(spreadOf(ends))} after the drop line`;
 	const said = [
-		...left === void 0 ? [] : [`After the drop, the program closed its socket in ${gone.length} runs, median ${ms(left.spread)} after its drop line${left.stayed === 0 ? "" : `, and it did not close it in ${left.stayed}`}.`],
+		...left === void 0 ? [] : [`After the drop, the program closed its socket in ${gone.length} runs, median ${ms(left.spread)} after its drop line${left.stayed === 0 ? "" : `, and it did not close it in ${left.stayed}${ended}`}.`],
 		...reconnect === void 0 ? [] : [`Reconnect: the waits before each try, median ${reconnect.waits.map(ms).join(", ")}; the first SYN median ${ms(reconnect.syn)} and ESTABLISHED median ${ms(reconnect.established)} after the detection.`],
 		...calls.length === 0 ? [] : [`Calls in flight: ${Object.entries(outcomes).map(([outcome, n]) => `${n} ${outcome}`).join("; ")}.`]
 	];
@@ -500,15 +508,41 @@ const leftAfter = (socket, line) => {
 	return left === void 0 ? null : between$3(line.t, left.mono);
 };
 /**
+* This function gives the end of the client process in a run, as the kernel stamps it. The process
+* ends after its last try, and its kernel then closes each socket that is still open, at one
+* instant. Thus the end is the first change out of ESTABLISHED of another socket of the client
+* after its last `dial` line. The program dropped none of these sockets. It is undefined when the
+* record has no such change, for example when the last try did not open.
+*/
+const exitOf = (run, cookie) => {
+	const last = run.events.filter((line) => line.ev === "dial").at(-1);
+	if (last === void 0) return void 0;
+	const dropped = new Set(run.events.filter((line) => line.ev === "drop").map((line) => line["local"]));
+	return run.kernel.find((record) => record.netns === run.netns && record.cookie !== cookie && record.ev === "state" && oldState$2(record) === 1 && (newState$2(record) === 4 || newState$2(record) === 7) && record.mono >= last.t && !dropped.has(record.src))?.mono;
+};
+/**
+* This function separates a close of the socket by the program from the end of the client process.
+* `left` is the time from the drop line to the close, and `exit` is the end of the process. A close
+* in δ_abs of that end is the end, not the program: `left` becomes null, and `exited` keeps the time.
+*/
+const closeOrExit = (line, left, exit, delta = NOISE) => {
+	if (left === null || exit === void 0) return { left };
+	const at = line.t + valueIn(left, "s") * 1e9;
+	return Math.abs(at - exit) <= valueIn(delta, "s") * 1e9 ? {
+		left: null,
+		exited: left
+	} : { left };
+};
+/**
 * This function tells how a drop differs from the way that its prediction gives, or gives null.
 * A close closes the socket in δ_abs. 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) => {
+const dropFinding = (expected, drop, left, delta = NOISE, exited) => {
 	const noise = valueIn(delta, "s");
 	const soon = left !== null && valueIn(left, "s") <= noise;
 	if (expected === "close") {
-		if (left === null) return "the program did not close its socket after the drop, where a close is at once";
+		if (left === null) return `the program did not close its socket after the drop, where a close is at once${exited === void 0 ? "" : ": it stayed open until the client process ended"}`;
 		return soon ? null : `the program closed its socket ${left.value} s after the drop, not at once`;
 	}
 	if (drop.record !== "write") return "the drop wrote no close frame on its socket";
@@ -1623,8 +1657,9 @@ const measureSocket = (cell, run) => {
 	const closeWait = socket.find((record) => record.ev === "state" && newState(record) === 8);
 	const own = cell.prediction.detects === true && cell.prediction.errno === "CLOSED" || cell.prediction.detects === null && cell.prediction.ends === "own-close" ? socket.find((record) => record.ev === "state" && oldState(record) === 1 && newState(record) === 4) : void 0;
 	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, local, noiseOf(cell));
+	const first = dropOf(lines, socket, named, noiseOf(cell));
 	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 ? {
@@ -1637,7 +1672,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, local, noiseOf(cell));
+	const pings = pingsOf(lines, socket, named, noiseOf(cell));
 	const before = run.fault?.t1 ?? ready.t;
 	const referenceAt = (from) => {
 		if (from === "request-sent") return request.t;
@@ -1822,8 +1857,12 @@ const measureSocket = (cell, run) => {
 	const words = outcome.kind === "error" ? outcome.errno : outcome.kind === "closed" ? "its own close" : outcome.kind === "dropped" ? "a drop by its own program" : "end of file";
 	const reconnect = prediction.reconnects === void 0 ? void 0 : reconnectOf(run, ended, cookie, drop?.line.t ?? ended);
 	const late = reconnect === void 0 || prediction.reconnects === void 0 ? null : reconnectFinding(prediction.reconnects, reconnect, noiseOf(cell));
-	const left = prediction.drop === void 0 || drop === void 0 ? void 0 : leftAfter(socket, drop.line);
-	const how = prediction.drop === void 0 || drop === void 0 || left === void 0 ? null : dropFinding(prediction.drop, drop, left, noiseOf(cell));
+	const closed = prediction.drop === void 0 || drop === void 0 ? void 0 : leftAfter(socket, drop.line);
+	const { left, exited } = closed === void 0 || drop === void 0 || prediction.exits !== true ? {
+		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 found = [
 		matches ? null : `it ended with ${words}, not ${prediction.errno}`,
 		late,
@@ -1851,6 +1890,7 @@ const measureSocket = (cell, run) => {
 		steps,
 		...reconnect === void 0 ? {} : { reconnect },
 		...left === void 0 ? {} : { left },
+		...exited === void 0 ? {} : { exited },
 		...cell.probe.ws !== void 0 && inflight ? { call: callOf(events, request, ended) } : {},
 		void: voided,
 		finding
@@ -1913,7 +1953,7 @@ const MONGO = {
 	dockerfile: "harness/image/mongo/Dockerfile",
 	from: ["harness/image/mongo"]
 };
-/** This image holds `@procedures/client` 0.3.0 on Node 24.21.0: its WebSocket client as a client of the harness, and the script of its server. */
+/** This image holds `@procedures/client` 0.7.0 on Node 24.21.0: its WebSocket client as a client of the harness, and the script of its server. */
 const PROCEDURES = {
 	name: "loom-harness-procedures",
 	dockerfile: "harness/image/procedures/Dockerfile",
@@ -4151,7 +4191,7 @@ const droppedSoFar = (records) => {
 /** This function gives the argv of the client for a cell, with a deadline far after all that it waits for. */
 const probeArgs = (cell, lab) => {
 	const { prediction, probe } = cell;
-	const longest = (prediction.detects === true && prediction.driver !== void 0 ? longestOf(cell) : prediction.detects ? valueIn(prediction.high, "s") : valueIn(prediction.window, "s")) + (cell.idleBefore === void 0 ? 0 : valueIn(cell.idleBefore, "s"));
+	const longest = (prediction.detects === true && prediction.driver !== void 0 ? longestOf(cell) : prediction.detects ? latestEndOf(prediction) : valueIn(prediction.window, "s")) + (cell.idleBefore === void 0 ? 0 : valueIn(cell.idleBefore, "s"));
 	const args = [
 		lab.targetIp,
 		String(lab.targetPort),
@@ -4521,7 +4561,7 @@ const once = async (lab, cell, environment, index, dry = false) => {
 						"deadline"
 					], window).catch(() => void 0);
 				} else if (prediction.detects) {
-					const within = valueIn(prediction.high, "s") * 2e3 + 1e4;
+					const within = latestEndOf(prediction) * 2e3 + 1e4;
 					if (cell.observer !== void 0 && cell.observer !== "client") await observerError(cell, partial, within, () => lab.server.slice(serverFrom).some((line) => line.ev === "drop"));
 					else if (http && cell.probe.mode !== "idle") await probe.until(HTTP_DONE, within).catch(() => void 0);
 					else await probe.until([
@@ -4723,6 +4763,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { CONVERGE_MS, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, NOISE, PUMP, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, callOf, clockOffsetOf, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, harnessImage, hzOf, infoOf, initiateScript, isHopPlace, judge, lagsOf, leftAfter, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, nodeClientImage, nodeHttpImage, noiseOf, onMonotonic, openGroupLab, openLab, openReplicaSetLab, peersOf, pingsOf, proceduresImage, programLines, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subscriptionsOf, targetImageOf, templated, toxicBody, verdictOf, viewOf, writesOf };
+export { CONVERGE_MS, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, NOISE, PUMP, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, callOf, clockOffsetOf, closeOrExit, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, harnessImage, hzOf, infoOf, initiateScript, isHopPlace, judge, lagsOf, latestEndOf, leftAfter, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, nodeClientImage, nodeHttpImage, noiseOf, onMonotonic, openGroupLab, openLab, openReplicaSetLab, peersOf, pingsOf, proceduresImage, programLines, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subscriptionsOf, targetImageOf, templated, toxicBody, verdictOf, viewOf, writesOf };
 
 //# sourceMappingURL=index.js.map