@mark1russell7/service 0.5.10 → 0.5.12

package/build/redis.js

@@ -1,10 +1,8 @@
 import { realClock } from "./clock.js";
 import { heartbeat } from "./heartbeat.js";
 import { i as heartbeatDetection } from "./timing-DGRi3XCI.js";
-import { t as mayReissue } from "./operation-DL5RxFds.js";
 import { backoffDelay } from "./backoff.js";
-import { quantity, valueIn } from "@mark1russell7/quantity";
-import { connect } from "node:net";
+import { A as keepaliveSilent, C as withinBound, D as immediate, E as firstDetector, M as unwatched, O as keepaliveAnswered, S as timeProblems, T as WHAT, _ as operationTable, b as socketEnds, c as clientProblems, d as finiteMs, f as inFlight, g as notSent, h as ms, i as helloDial, j as kernelGiveUp, k as keepaliveReset, l as clientRecorder, m as message, n as closeTimer, o as attachClient, p as localStateCheck, r as transition, s as clientBounds, t as clientKnob, u as dialCheck, v as roundTripCheck, w as MANIFESTATIONS, x as stepChecks, y as sendWithReissue } from "./machine-Czfb6fV4.js";
 //#region src/redis/connection.ts
 /**
 * This factory makes an ioredis client. It loads ioredis only when a client connects, thus a
@@ -15,13 +13,6 @@ const ioredis = async (options) => {
 };
 //#endregion
 //#region src/redis/meets.ts
-const never = {
-	value: "infinite",
-	unit: "s"
-};
-const s = (value) => quantity(Math.round(value * 1e6) / 1e6, "s");
-const seconds = (amount) => amount.value === "infinite" ? Number.POSITIVE_INFINITY : valueIn(amount, "s");
-const plus = (amount, more) => amount.value === "infinite" ? never : s(seconds(amount) + more);
 /**
 * This function gives the manifestations that a Redis client can meet, and the detectors of each, from
 * its knobs. A reset or a FIN arrives on the next segment. A black hole and a host that is gone give
@@ -29,7 +20,6 @@ const plus = (amount, more) => amount.value === "infinite" ? never : s(seconds(a
 * segment. Thus TCP keepalive does not fire on them, and only the client's own timers find them.
 */
 const meetings = (name, knobs, heartbeat) => {
-	const keepalive = plus(knobs.keepalive_idle, 10);
 	const watchdog = (situation) => ({
 		by: "heartbeat_detection_time",
 		within: heartbeat,
@@ -48,27 +38,17 @@ const meetings = (name, knobs, heartbeat) => {
 		situation: "in flight",
 		effect: "the command fails as indeterminate, and the state of the connection does not change"
 	};
-	const giveUp = {
-		by: "retrans_giveup_time",
-		within: knobs.retrans_giveup_time,
-		situation: "in flight",
-		effect: "the kernel gives up the retransmissions and closes the socket"
-	};
-	const silent = (manifestation, what) => ({
+	const giveUp = kernelGiveUp(knobs.retrans_giveup_time);
+	const silent = (manifestation) => ({
 		manifestation,
-		what,
+		what: WHAT[manifestation],
 		detectors: [
 			command,
 			writeoff,
 			watchdog("in flight"),
 			giveUp,
 			watchdog("idle"),
-			{
-				by: "keepalive_idle",
-				within: keepalive,
-				situation: "idle",
-				effect: "TCP keepalive gives up, and the socket closes"
-			}
+			keepaliveSilent(knobs.keepalive_idle)
 		]
 	});
 	const acknowledged = (manifestation, what) => ({
@@ -79,55 +59,30 @@ const meetings = (name, knobs, heartbeat) => {
 			writeoff,
 			watchdog("in flight"),
 			watchdog("idle"),
-			{
-				by: "keepalive_idle",
-				within: never,
-				situation: "idle",
-				effect: "the kernel of the server answers each probe"
-			}
+			keepaliveAnswered()
 		]
 	});
-	const immediate = (situation, effect) => ({
-		by: "the next segment",
-		within: s(0),
-		situation,
-		effect
-	});
 	return [
 		{
 			manifestation: "rst",
-			what: "the server answers each segment with a reset, and refuses each new connection",
+			what: WHAT.rst,
 			detectors: [
 				immediate("in flight", "the command fails, and the client connects again, and each attempt is refused"),
 				watchdog("idle"),
-				{
-					by: "keepalive_idle",
-					within: keepalive.value === "infinite" ? never : knobs.keepalive_idle,
-					situation: "idle",
-					effect: "the first probe gets a reset"
-				}
+				keepaliveReset(knobs.keepalive_idle)
 			]
 		},
 		{
 			manifestation: "fin",
-			what: "the process of the server ends, and its kernel closes the connection",
+			what: WHAT.fin,
 			detectors: [immediate("in flight", "the close arrives, and the command fails"), immediate("idle", "the close arrives")]
 		},
-		silent("blackhole", "the network drops each segment in the two directions"),
-		silent("freeze-host", "the host of the server stops, without a close: the death without a close"),
-		acknowledged("freeze-process", "the process of the server stops, and its kernel stays up"),
+		silent("blackhole"),
+		silent("freeze-host"),
+		acknowledged("freeze-process", WHAT["freeze-process"]),
 		acknowledged("app-stall", "the server stops its replies for a time, for example a long command, and its kernel stays up")
 	];
 };
-/** This function gives the first detector of a manifestation in a situation, or null when no detector has an end (C3). */
-const firstDetector = (meeting, situation) => {
-	return meeting.detectors.filter((detector) => detector.situation === situation && detector.within.value !== "infinite").sort((a, b) => seconds(a.within) - seconds(b.within))[0] ?? null;
-};
-/** This function gives each manifestation and situation that no detector of the client finds: the standing rule, as a query (C3, E9). */
-const unwatched = (meets) => meets.flatMap((meeting) => ["in flight", "idle"].flatMap((situation) => firstDetector(meeting, situation) === null ? [{
-	manifestation: meeting.manifestation,
-	situation
-}] : []));
 //#endregion
 //#region src/redis/operations.ts
 /**
@@ -242,12 +197,6 @@ const commandName = (command, args) => {
 };
 //#endregion
 //#region src/redis/client.ts
-const ms = (amount) => amount.value === "infinite" ? Number.POSITIVE_INFINITY : valueIn(amount, "ms");
-const finite = (amount) => {
-	const value = ms(amount);
-	return Number.isFinite(value) ? value : void 0;
-};
-const message = (error) => error instanceof Error ? error.message : String(error);
 /**
 * This function gives the backoff of the tries to connect: from `retry_base`, doubling to
 * `retry_cap`, each with a jitter up to the base. The client rounds each delay to a whole millisecond.
@@ -267,38 +216,17 @@ const specProblems = (name, spec) => {
 	const { knobs } = spec;
 	if (!Number.isInteger(spec.heartbeatMisses) || spec.heartbeatMisses < 1) problems.push(`${name}'s watchdog closes the connection after ${spec.heartbeatMisses} misses, not a whole number above zero`);
 	if (knobs.max_connection_age.value !== "infinite") problems.push(`${name} cannot replace its connection at an age: max_connection_age must be "infinite"`);
-	for (const [knob, amount] of Object.entries(knobs)) if (amount.value !== "infinite" && !(ms(amount) >= 0)) problems.push(`${name}'s ${knob} is not a time of zero or more`);
+	problems.push(...timeProblems(name, knobs));
 	if (ms(knobs.request_timeout) <= 0) problems.push(`${name}'s request_timeout is not above zero: each command must have a bound`);
 	if (ms(knobs.heartbeat_timeout) <= 0) problems.push(`${name}'s heartbeat_timeout is not above zero`);
 	if (ms(knobs.retry_cap) < ms(knobs.retry_base)) problems.push(`${name}'s retry_cap is below its retry_base`);
 	return problems;
 };
 /** This dial function opens a TCP connection, sends an inline PING, and waits for +PONG. */
-const tcpDial = (host, port, signal) => new Promise((resolve, reject) => {
-	if (signal.aborted) {
-		reject(/* @__PURE__ */ new Error("the dial was aborted"));
-		return;
-	}
-	const socket = connect({
-		host,
-		port
-	});
-	let reply = "";
-	const end = (error) => {
-		signal.removeEventListener("abort", onAbort);
-		socket.destroy();
-		if (error === void 0) resolve();
-		else reject(error);
-	};
-	const onAbort = () => end(/* @__PURE__ */ new Error("the dial was aborted"));
-	signal.addEventListener("abort", onAbort, { once: true });
-	socket.once("connect", () => socket.write("PING\r\n"));
-	socket.on("data", (chunk) => {
-		reply += chunk.toString();
-		if (reply.includes("\r\n")) end(reply.startsWith("+PONG") ? void 0 : /* @__PURE__ */ new Error(`the reply was ${reply.trim()}`));
-	});
-	socket.once("error", (error) => end(error));
-	socket.once("close", () => end(/* @__PURE__ */ new Error("the server closed the dial")));
+const tcpDial = helloDial("PING\r\n", (received) => {
+	const reply = received.toString();
+	if (!reply.includes("\r\n")) return "more";
+	return reply.startsWith("+PONG") ? null : /* @__PURE__ */ new Error(`the reply was ${reply.trim()}`);
 });
 /**
 * This function makes a Redis client. It is a dependency of a service, with ioredis under it:
@@ -309,6 +237,9 @@ const tcpDial = (host, port, signal) => new Promise((resolve, reject) => {
 * - It records the server's id of each connection at `ready` (D1).
 * - A watchdog sends a PING in the band of the connection, and it connects again after the misses
 *   of the declaration. It also starts a client that stopped (principle 19).
+*
+* The outcomes, the second try, the commands in flight, the bounded close and the checks come
+* from the core of the clients. This entry gives what ioredis does in its own way.
 */
 const redisClient = (name, spec, options = {}) => {
 	const problems = specProblems(name, spec);
@@ -319,10 +250,7 @@ const redisClient = (name, spec, options = {}) => {
 	const create = options.create ?? ioredis;
 	const dial = options.dial ?? tcpDial;
 	const turn = options.turn ?? (() => new Promise((resolve) => setImmediate(resolve)));
-	const operations = {
-		...REDIS_OPERATIONS,
-		...spec.operations
-	};
+	const operations = operationTable(REDIS_OPERATIONS, spec.operations);
 	const requestTimeout = ms(knobs.request_timeout);
 	const detection = heartbeatDetection(knobs.heartbeat_interval, knobs.heartbeat_timeout, spec.heartbeatMisses);
 	const backoff = retryBackoff(knobs);
@@ -330,18 +258,10 @@ const redisClient = (name, spec, options = {}) => {
 	let status = "none";
 	let closing = false;
 	const joins = [];
-	const inFlight = /* @__PURE__ */ new Set();
+	const flight = inFlight();
 	const readyWaiters = /* @__PURE__ */ new Set();
 	const listeners = [];
-	const record = (from, to, on, detail) => options.record?.({
-		at: clock.now(),
-		machine: "client",
-		instance: name,
-		from,
-		to,
-		on,
-		...detail === void 0 ? {} : { detail }
-	});
+	const record = clientRecorder(options.record, clock, name);
 	let retrySince = null;
 	const retryStrategy = (times) => {
 		const now = clock.now();
@@ -361,8 +281,8 @@ const redisClient = (name, spec, options = {}) => {
 		lazyConnect: true,
 		connectTimeout: ms(knobs.connect_bound),
 		commandTimeout: requestTimeout,
-		socketTimeout: finite(knobs.driver_writeoff_time),
-		keepAlive: finite(knobs.keepalive_idle) ?? false,
+		socketTimeout: finiteMs(knobs.driver_writeoff_time),
+		keepAlive: finiteMs(knobs.keepalive_idle) ?? false,
 		enableOfflineQueue: false,
 		autoResendUnfulfilledCommands: false,
 		maxRetriesPerRequest: null,
@@ -378,11 +298,7 @@ const redisClient = (name, spec, options = {}) => {
 			error: text,
 			reply: true
 		};
-		if (/isn't writeable|enableOfflineQueue/i.test(text)) return {
-			outcome: "error",
-			error: text,
-			reply: false
-		};
+		if (/isn't writeable|enableOfflineQueue/i.test(text)) return notSent(text);
 		return {
 			outcome: "indeterminate",
 			error: text
@@ -408,10 +324,7 @@ const redisClient = (name, spec, options = {}) => {
 			generation,
 			at,
 			clientId,
-			localAddress: socket?.localAddress ?? null,
-			localPort: socket?.localPort ?? null,
-			remoteAddress: socket?.remoteAddress ?? null,
-			remotePort: socket?.remotePort ?? null
+			...socketEnds(socket)
 		});
 		record("ready", "ready", "join", `generation ${generation}, client id ${clientId ?? "unknown"}`);
 		for (const wake of [...readyWaiters]) wake();
@@ -420,10 +333,7 @@ const redisClient = (name, spec, options = {}) => {
 		const from = status;
 		status = to;
 		record(from, to, `status.${to}`);
-		if (to === "close" || to === "end") for (const settle of [...inFlight]) settle({
-			outcome: "indeterminate",
-			error: `the connection closed with the command in flight (${from})`
-		});
+		if (to === "close" || to === "end") flight.settleAll(`the connection closed with the command in flight (${from})`);
 		if (to === "ready") onReady();
 	};
 	const watch = (c) => {
@@ -464,75 +374,25 @@ const redisClient = (name, spec, options = {}) => {
 	});
 	const attempt = (command, args, signal) => {
 		const c = connection;
-		if (c === null) return Promise.resolve({
-			outcome: "error",
-			error: `${name} has not connected`,
-			reply: false
-		});
-		if (c.status !== "ready") return Promise.resolve({
-			outcome: "error",
-			error: `${name} is ${c.status}, not ready: the command did not leave the client`,
-			reply: false
-		});
-		if (signal?.aborted) return Promise.resolve({
-			outcome: "error",
-			error: "the caller aborted the command before it left the client",
-			reply: false
-		});
-		return new Promise((resolve) => {
-			let settled = false;
-			const settle = (value) => {
-				if (settled) return;
-				settled = true;
-				inFlight.delete(settle);
-				signal?.removeEventListener("abort", aborted);
-				resolve(value);
-			};
-			const aborted = () => settle({
-				outcome: "indeterminate",
-				error: "the caller abandoned the command after it was sent"
-			});
-			inFlight.add(settle);
-			signal?.addEventListener("abort", aborted, { once: true });
+		if (c === null) return Promise.resolve(notSent(`${name} has not connected`));
+		if (c.status !== "ready") return Promise.resolve(notSent(`${name} is ${c.status}, not ready: the command did not leave the client`));
+		if (signal?.aborted) return Promise.resolve(notSent("the caller aborted the command before it left the client"));
+		return flight.track(signal, "the caller abandoned the command after it was sent", (settle) => {
 			c.call(command, ...args).then((value) => settle({
 				outcome: "ok",
 				value
 			}), (error) => settle(failed(error)));
 		});
 	};
-	const send = async (command, args = [], sendOptions = {}) => {
-		const { signal } = sendOptions;
-		const operation = sendOptions.reissue === false ? void 0 : operations[commandName(command, args)];
-		const started = clock.now();
-		const first = await attempt(command, args, signal);
-		if (first.outcome === "ok") return {
-			outcome: "ok",
-			value: first.value,
-			attempts: 1
-		};
-		const again = !(first.outcome === "error" && first.reply) && operation !== void 0 && signal?.aborted !== true && mayReissue(operation, quantity((clock.now() - started) / 1e3, "s"));
-		const left = requestTimeout - (clock.now() - started);
-		if (!again || left <= 0 || !await waitReady(left, signal)) return {
-			...first,
-			attempts: 1
-		};
-		record(status, status, "command.reissue", commandName(command, args));
-		const bound = new AbortController();
-		const end = clock.after(Math.max(0, requestTimeout - (clock.now() - started)), () => bound.abort());
-		const forward = () => bound.abort();
-		signal?.addEventListener("abort", forward, { once: true });
-		const second = await attempt(command, args, bound.signal);
-		end();
-		signal?.removeEventListener("abort", forward);
-		return second.outcome === "ok" ? {
-			outcome: "ok",
-			value: second.value,
-			attempts: 2
-		} : {
-			...second,
-			attempts: 2
-		};
-	};
+	const send = (command, args = [], sendOptions = {}) => sendWithReissue({
+		clock,
+		bound: requestTimeout,
+		operation: operations[commandName(command, args)],
+		options: sendOptions,
+		attempt: (signal) => attempt(command, args, signal),
+		beforeAgain: (left, signal) => waitReady(left, signal),
+		onReissue: () => record(status, status, "command.reissue", commandName(command, args))
+	});
 	let watchdog = null;
 	const startWatchdog = () => heartbeat({
 		interval: ms(knobs.heartbeat_interval),
@@ -577,15 +437,8 @@ const redisClient = (name, spec, options = {}) => {
 			watchdog = null;
 			const c = connection;
 			if (c === null) return;
-			const quit = c.quit().then(() => "quit", () => "quit");
-			let cancel = () => {};
-			const bound = new Promise((resolve) => {
-				cancel = clock.after(ms(knobs.close_bound), () => resolve("bound"));
-			});
 			const startedClose = clock.now();
-			const first = await Promise.race([quit, bound]);
-			cancel();
-			if (first === "bound") record(status, status, "close.bound");
+			if (!await withinBound(clock, ms(knobs.close_bound), c.quit())) record(status, status, "close.bound");
 			if (c.status !== "end") c.disconnect(false);
 			const ended = (within) => c.status === "end" ? Promise.resolve() : new Promise((resolve) => {
 				let stop = () => {};
@@ -605,10 +458,7 @@ const redisClient = (name, spec, options = {}) => {
 			}
 			for (const [event, listener] of listeners) c.off(event, listener);
 			listeners.length = 0;
-			for (const settle of [...inFlight]) settle({
-				outcome: "indeterminate",
-				error: "the client closed with the command in flight"
-			});
+			flight.settleAll("the client closed with the command in flight");
 			status = "end";
 		}
 	};
@@ -631,32 +481,11 @@ const redisClient = (name, spec, options = {}) => {
 		},
 		operations
 	};
-	const checks = (checkOptions) => {
-		const made = [];
-		const declare = (step, ownConnection, run) => {
-			if (!(step in checkOptions.steps)) return;
-			made.push([{
-				name: `${name}.${step}`,
-				dependency: name,
-				step,
-				ownConnection,
-				gates: checkOptions.steps[step] ?? null,
-				poll: checkOptions.poll
-			}, run]);
-		};
-		declare("local-state", true, () => connection?.status === "ready" ? "ok" : "error");
-		declare("round-trip", true, async (signal) => {
-			return (await send("PING", [], {
-				signal,
-				reissue: false
-			})).outcome === "ok" ? "ok" : "error";
-		});
-		declare("dial", false, async (signal) => {
-			await dial(spec.host, spec.port, signal);
-			return "ok";
-		});
-		return made;
-	};
+	const checks = (checkOptions) => stepChecks(name, checkOptions, {
+		"local-state": localStateCheck(() => connection?.status === "ready"),
+		"round-trip": roundTripCheck((sendOptions) => send("PING", [], sendOptions)),
+		dial: dialCheck(dial, spec.host, spec.port)
+	});
 	return {
 		name,
 		declaration,
@@ -668,23 +497,8 @@ const redisClient = (name, spec, options = {}) => {
 		joins,
 		send,
 		checks,
-		attach(svc, checkOptions) {
-			svc.dependency(name, declaration, handle);
-			for (const [check, run] of checks(checkOptions)) svc.check(check, run);
-			return svc;
-		},
-		problems(description) {
-			const found = [];
-			const teardown = description.shutdown.phases.find((phase) => phase.name === "tear down dependencies");
-			if (teardown === void 0) found.push(`${name} needs the phase "tear down dependencies" to close`);
-			else if (ms(knobs.close_bound) >= valueIn(teardown.cap, "ms")) found.push(`${name}'s close_bound of ${ms(knobs.close_bound)} ms does not fit in the cap of "tear down dependencies"`);
-			for (const check of description.checks) {
-				if (check.dependency !== name) continue;
-				const slowest = valueIn(check.poll.timeout, "ms");
-				if (check.step === "round-trip" && requestTimeout > slowest + valueIn(check.poll.interval, "ms") * (1 + check.poll.jitter)) found.push(`${name}'s request_timeout outlives one jittered poll of ${check.name} (B7, O13)`);
-			}
-			return found;
-		}
+		attach: (svc, checkOptions) => attachClient(svc, name, declaration, handle, checks(checkOptions)),
+		problems: (description) => clientProblems(name, description, clientBounds(knobs))
 	};
 };
 //#endregion
@@ -842,19 +656,6 @@ const replyOf = (limiter, reply) => {
 };
 //#endregion
 //#region src/redis/machine.ts
-const t = (id, from, on, to, extra = {}) => ({
-	id,
-	from,
-	on,
-	to,
-	...extra
-});
-const knob = (key) => ({
-	key,
-	scope: "client",
-	unit: "s",
-	default: null
-});
 /** The states where the connection exists or tries to exist, thus where it can close. */
 const LIVE = [
 	"connecting",
@@ -932,10 +733,10 @@ const REDIS_CLIENT_MACHINE = {
 		}
 	},
 	knobs: {
-		connect_bound: knob("connectTimeout"),
-		driver_writeoff_time: knob("socketTimeout"),
-		heartbeat_interval: knob("watchdog.interval"),
-		close_bound: knob("close.bound")
+		connect_bound: clientKnob("connectTimeout"),
+		driver_writeoff_time: clientKnob("socketTimeout"),
+		heartbeat_interval: clientKnob("watchdog.interval"),
+		close_bound: clientKnob("close.bound")
 	},
 	timers: {
 		connect_timeout: {
@@ -968,41 +769,33 @@ const REDIS_CLIENT_MACHINE = {
 			fires: "heartbeat",
 			note: "a PING on the connection of the application"
 		},
-		close: {
-			duration: {
-				knob: "close_bound",
-				unit: "s"
-			},
-			arms: ["close.request"],
-			cancels: ["status.end"],
-			fires: "close.bound"
-		}
+		close: closeTimer()
 	},
 	transitions: [
-		t("connect", [
+		transition("connect", [
 			"none",
 			"reconnecting",
 			"end",
 			"close"
 		], "status.connecting", "connecting"),
-		t("tcp", "connecting", "status.connect", "connect"),
-		t("ready", "connect", "status.ready", "ready"),
-		t("close", [...LIVE], "status.close", "close"),
-		t("retry", "close", "status.reconnecting", "reconnecting"),
-		t("end", [...LIVE, "close"], "status.end", "end"),
-		t("join", "ready", "join", "ready"),
-		t("miss", "ready", "watchdog.miss", "ready"),
-		t("watchdog-reconnect", "ready", "watchdog.reconnect", "ready"),
-		t("revive", "end", "watchdog.revive", "end"),
-		t("window-ended", "close", "retry.window-ended", "close"),
-		...ANY.map((state) => t(`error-${state}`, state, "error", state)),
-		...ANY.map((state) => t(`connect-failed-${state}`, state, "connect.failed", state)),
-		...ANY.map((state) => t(`reissue-${state}`, state, "command.reissue", state)),
-		...ANY.map((state) => t(`close-bound-${state}`, state, "close.bound", state, { timer: "close" })),
-		...ANY.map((state) => t(`close-destroy-${state}`, state, "close.destroy", state))
+		transition("tcp", "connecting", "status.connect", "connect"),
+		transition("ready", "connect", "status.ready", "ready"),
+		transition("close", [...LIVE], "status.close", "close"),
+		transition("retry", "close", "status.reconnecting", "reconnecting"),
+		transition("end", [...LIVE, "close"], "status.end", "end"),
+		transition("join", "ready", "join", "ready"),
+		transition("miss", "ready", "watchdog.miss", "ready"),
+		transition("watchdog-reconnect", "ready", "watchdog.reconnect", "ready"),
+		transition("revive", "end", "watchdog.revive", "end"),
+		transition("window-ended", "close", "retry.window-ended", "close"),
+		...ANY.map((state) => transition(`error-${state}`, state, "error", state)),
+		...ANY.map((state) => transition(`connect-failed-${state}`, state, "connect.failed", state)),
+		...ANY.map((state) => transition(`reissue-${state}`, state, "command.reissue", state)),
+		...ANY.map((state) => transition(`close-bound-${state}`, state, "close.bound", state, { timer: "close" })),
+		...ANY.map((state) => transition(`close-destroy-${state}`, state, "close.destroy", state))
 	]
 };
 //#endregion
-export { LIMITER_SCRIPT, REDIS_CLIENT_MACHINE, REDIS_OPERATIONS, commandName, firstDetector, heartbeatDetection, ioredis, meetings, redisClient, redisLimiterStore, retryBackoff, specProblems, tcpDial, unwatched };
+export { LIMITER_SCRIPT, MANIFESTATIONS, REDIS_CLIENT_MACHINE, REDIS_OPERATIONS, commandName, firstDetector, heartbeatDetection, ioredis, meetings, redisClient, redisLimiterStore, retryBackoff, specProblems, tcpDial, unwatched };
 
 //# sourceMappingURL=redis.js.map