@mark1russell7/harness 0.15.2 → 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 environmentProblems, G as Outcomes, H as MiddleboxExpectation, I as LineMatch, It as isHopPlace, J as PausePrediction, K as Pair, L as LoadBand, Lt as latestEndOf, 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-OwQdpSkd.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;
 /**
@@ -2718,5 +2729,5 @@ export declare const environmentCounts: (cell: Cell, runs: 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, environmentProblems, 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

@@ -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",
@@ -6587,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}`;
@@ -6751,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);
@@ -6822,7 +6917,8 @@ const drillOnce = async (lab, cell, environment, index) => {
 				before,
 				after: hash,
 				restored,
-				second
+				second,
+				room
 			}
 		}
 	};
@@ -9044,6 +9140,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-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, 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