@mark1russell7/service 0.5.12 → 0.5.13

package/build/rabbitmq.js

@@ -0,0 +1,748 @@
+import { realClock } from "./clock.js";
+import { A as retrySchedule, B as zeroProblems, C as notSent, D as readyWait, F as timeProblems, G as immediate, H as NEVER, I as trackWithTimer, J as keepaliveSilent, K as keepaliveAnswered, L as wholeProblems, M as sendWithReissue, N as socketEnds, O as retryBackoff, P as stepChecks, R as withinBound, S as ms, U as WHAT, V as MANIFESTATIONS, W as firstDetector, X as unwatched, Y as kernelGiveUp, _ as inFlight, a as helloDial, b as message, c as ageProblems, d as clientProblems, f as clientRecorder, h as finiteMs, j as roundTripCheck, k as retryProblems, l as attachClient, m as dialCheck, n as closeTimer, q as keepaliveReset, r as transition, s as STARTING_POLL, t as clientKnob, u as clientBounds, w as operationTable, y as localStateCheck, z as wrapperTimerProblems } from "./machine-BhTRu3u9.js";
+import { quantity } from "@mark1russell7/quantity";
+//#region src/rabbitmq/connection.ts
+/**
+* This factory opens a connection of amqplib. It loads amqplib only when a client connects, thus a
+* service that does not use RabbitMQ does not need it. The specifier is a value, thus the package
+* needs no types of amqplib. The built-in recovery of amqplib stays off, because the wrapper connects again by itself.
+*/
+const nodeAmqp = async ({ url, socketOptions }) => {
+	const loaded = await import("amqplib");
+	const connect = loaded.connect ?? loaded.default?.connect;
+	if (connect === void 0) throw new Error("amqplib gives no connect function");
+	return connect(url, socketOptions);
+};
+//#endregion
+//#region src/rabbitmq/meets.ts
+/**
+* This function gives the manifestations that a RabbitMQ client can meet, and the detectors of each,
+* from its knobs. The cells of R3 measured them on amqplib 2.2.0 against RabbitMQ 4.3.6:
+* - The heartbeat ends a silent connection 2 to 3 heartbeats after the last data. The cells measured
+*   180.009 s at 60 s, and 45.009 s at 15 s (O17). It finds a silent broker in flight and idle.
+* - A stopped broker resets each client at once, because each socket of RabbitMQ has linger 0.
+* - At `tcp_retries2 = 7`, the kernel gave up at 53.016 s.
+* - A broker with a resource alarm blocks each connection that publishes, and it still sends its heartbeats.
+*/
+const rabbitMeetings = (name, knobs) => {
+	const beat = finiteMs(knobs.heartbeat_interval);
+	const detection = beat === void 0 ? NEVER : quantity(3 * beat / 1e3, "s");
+	const heartbeat = (situation) => ({
+		by: "heartbeat_detection_time",
+		within: detection,
+		situation,
+		effect: `the heartbeat of amqplib ends the connection, each call in flight fails as indeterminate, and ${name} connects again`
+	});
+	const call = {
+		by: "request_timeout",
+		within: knobs.request_timeout,
+		situation: "in flight",
+		effect: "the timer of the wrapper ends the call as indeterminate, and the connection stays"
+	};
+	const giveUp = kernelGiveUp(knobs.retrans_giveup_time, "each call in flight fails as indeterminate");
+	const silent = (manifestation) => ({
+		manifestation,
+		what: WHAT[manifestation],
+		detectors: [
+			call,
+			heartbeat("in flight"),
+			giveUp,
+			heartbeat("idle"),
+			keepaliveSilent(knobs.keepalive_idle)
+		]
+	});
+	return [
+		{
+			manifestation: "rst",
+			what: WHAT.rst,
+			detectors: [
+				immediate("in flight", "the call fails with ECONNRESET as indeterminate, and the client connects again"),
+				{
+					by: "heartbeat_interval",
+					within: beat === void 0 ? NEVER : knobs.heartbeat_interval,
+					situation: "idle",
+					effect: "the next heartbeat frame of the client gets a reset, and the client connects again"
+				},
+				keepaliveReset(knobs.keepalive_idle)
+			]
+		},
+		{
+			manifestation: "fin",
+			what: WHAT.fin,
+			detectors: [immediate("in flight", "the broker closes its socket with linger 0, thus a reset arrives, and the call fails as indeterminate"), immediate("idle", "the reset of the broker arrives, and the client connects again")]
+		},
+		silent("blackhole"),
+		silent("freeze-host"),
+		{
+			manifestation: "freeze-process",
+			what: WHAT["freeze-process"],
+			detectors: [
+				call,
+				heartbeat("in flight"),
+				heartbeat("idle"),
+				keepaliveAnswered()
+			]
+		},
+		{
+			manifestation: "app-stall",
+			what: "the broker stops its confirms and its replies for a time, and still sends its heartbeats: a resource alarm, or a quorum queue with no leader",
+			detectors: [
+				call,
+				{
+					by: "connection.blocked",
+					within: quantity(0, "s"),
+					situation: "idle",
+					effect: "a resource alarm blocks a connection that publishes at once. The client then refuses each call as not sent, until the unblock"
+				},
+				{
+					...heartbeat("idle"),
+					within: NEVER,
+					effect: "the broker still sends its heartbeats"
+				},
+				keepaliveAnswered()
+			]
+		}
+	];
+};
+//#endregion
+//#region src/rabbitmq/client.ts
+/** This function gives the problems of a spec: the knobs that the client cannot use. */
+const specProblems = (name, spec) => {
+	const { knobs } = spec;
+	return [
+		...timeProblems(name, knobs),
+		...zeroProblems(name, "amqplib", knobs, {
+			bounded: ["connect_bound"],
+			open: ["heartbeat_interval", "keepalive_idle"]
+		}),
+		...wholeProblems(name, knobs, {
+			millis: ["connect_bound"],
+			seconds: ["heartbeat_interval", "keepalive_idle"]
+		}),
+		...retryProblems(name, knobs),
+		...wrapperTimerProblems(name, knobs, { request_timeout: "a call" }),
+		...ageProblems(name, knobs, "the client does not replace its connection at an age")
+	];
+};
+/** This function gives the node of a try: `host`, then each seed, in sequence. */
+const nodeOf = (spec, index) => {
+	const nodes = [{
+		host: spec.host,
+		port: spec.port
+	}, ...spec.seeds ?? []];
+	return nodes[index % nodes.length];
+};
+/**
+* This function gives the arguments of `connect` for one node of a spec. Each timer of amqplib
+* comes from the declaration. The heartbeat goes in the URL, and "infinite" is 0, no heartbeat.
+*/
+const rabbitOptions = (name, spec, index = 0) => {
+	const { knobs } = spec;
+	const node = nodeOf(spec, index);
+	const user = spec.username === void 0 ? "" : `${encodeURIComponent(spec.username)}:${encodeURIComponent(spec.password ?? "")}@`;
+	const heartbeat = finiteMs(knobs.heartbeat_interval);
+	const keepalive = finiteMs(knobs.keepalive_idle);
+	return {
+		url: `amqp://${user}${node.host}:${node.port}/${encodeURIComponent(spec.vhost ?? "/")}?heartbeat=${heartbeat === void 0 ? 0 : heartbeat / 1e3}`,
+		socketOptions: {
+			timeout: ms(knobs.connect_bound),
+			noDelay: true,
+			keepAlive: keepalive !== void 0,
+			...keepalive === void 0 ? {} : { keepAliveDelay: keepalive },
+			clientProperties: { connection_name: name }
+		}
+	};
+};
+/** The bytes of the protocol header of AMQP 0-9-1. A broker answers it with `connection.start`, before the authentication. */
+const AMQP_HEADER = Uint8Array.of(65, 77, 81, 80, 0, 0, 9, 1);
+/**
+* This judge reads the answer to the protocol header. A broker that takes the version sends a method
+* frame on channel 0: `connection.start`, class 10 and method 10. A broker that refuses the version
+* sends its own protocol header, and closes the socket.
+*/
+const startJudge = (received) => {
+	if (received.length < 4) return "more";
+	if (received.toString("latin1", 0, 4) === "AMQP") return /* @__PURE__ */ new Error(`the broker refused the version: it answered ${received.toString("hex")}`);
+	if (received.length < 11) return "more";
+	const type = received[0];
+	const channel = received.readUInt16BE(1);
+	const classId = received.readUInt16BE(7);
+	const methodId = received.readUInt16BE(9);
+	if (type !== 1 || channel !== 0) return /* @__PURE__ */ new Error(`the answer to the header is a frame of type ${type} on channel ${channel}, not a method on channel 0`);
+	return classId === 10 && methodId === 10 ? null : /* @__PURE__ */ new Error(`the answer to the header is the method ${classId}.${methodId}, not connection.start (10.10)`);
+};
+/** This dial function opens a TCP connection, sends the protocol header, and waits for `connection.start`. It needs no password. */
+const amqpDial = helloDial(AMQP_HEADER, startJudge);
+/**
+* This function gives the outcome of a failure of amqplib. The library names few classes of error.
+* Thus the wrapper reads the fields:
+* - A throw before the write (`IllegalOperationError`: the channel is closed or closing) is certain: the call did not leave the client.
+* - A reply code of the broker, from the close of the channel, is certain. The broker refused the call, or a call before it.
+* - A nack, and an end of the channel before the reply or the confirm, are not certain.
+*/
+const failureOutcome = (error) => {
+	const text = message(error);
+	const { name, code } = typeof error === "object" && error !== null ? error : {};
+	if (name === "IllegalOperationError") return notSent(text);
+	if (typeof code === "number") return {
+		outcome: "error",
+		error: `${code} ${text}`,
+		reply: true
+	};
+	if (text === "message nacked") return {
+		outcome: "indeterminate",
+		error: "the broker nacked the message: a queue of the route can hold it, or not"
+	};
+	return {
+		outcome: "indeterminate",
+		error: text
+	};
+};
+/** This function gives the count of deliveries of a message, 1 at the first. A quorum queue counts in `x-delivery-count`. */
+const deliveryCount = (message) => {
+	const count = message.properties.headers?.["x-delivery-count"];
+	if (typeof count === "number" && Number.isInteger(count) && count >= 0) return count + 1;
+	return message.fields.redelivered ? 2 : 1;
+};
+/** The exchange of each broker: the round-trip check declares it in passive mode, which changes nothing. */
+const CHECK_EXCHANGE = "amq.direct";
+/**
+* This function makes a RabbitMQ client, a dependency of a service over amqplib 2.
+* - It has one connection and one confirm channel, as one generation. The end of either one ends
+*   the generation. The client then connects again by itself, to the next node, after a backoff.
+* - It sets each timer of amqplib from the declaration. The built-in recovery of amqplib stays off.
+* - Its call is a confirmed publish, or an RPC with a reply. Each call has a timer of the wrapper, because amqplib has none.
+* - It tells the outcome of a call in three values, and it settles each call in flight at the end of its generation (C8, C10).
+* - It records the node and the name of each connection at the open of its channel (D1).
+*
+* These parts come from the core of the clients: the outcomes, the second try, the wait for a ready client and the backoff.
+* The calls in flight, the bounded close and the checks also come from the core. This entry gives what amqplib does in its own way.
+*/
+const rabbitClient = (name, spec, options = {}) => {
+	const problems = specProblems(name, spec);
+	if (problems.length > 0) throw new Error(problems.join("; "));
+	const { knobs } = spec;
+	const clock = options.clock ?? realClock;
+	const random = options.random ?? Math.random;
+	const create = options.create ?? nodeAmqp;
+	const dial = options.dial ?? amqpDial;
+	const operations = operationTable({}, spec.operations);
+	const requestTimeout = ms(knobs.request_timeout);
+	const backoff = retryBackoff(knobs);
+	let status = "none";
+	let connection = null;
+	let channel = null;
+	let generation = 0;
+	let token = 0;
+	let next = 0;
+	const retries = retrySchedule(clock, backoff, random);
+	const joins = [];
+	const flight = inFlight();
+	const readied = readyWait(clock, () => status === "ready");
+	const emit = clientRecorder(options.record, clock, name);
+	const record = (on, to = status, detail) => {
+		const from = status;
+		status = to;
+		emit(from, to, on, detail);
+	};
+	const closing = () => status === "closing" || status === "end";
+	/** This function closes a connection that the client does not use, in `close_bound`, then destroys its socket. */
+	const retire = (c) => {
+		withinBound(clock, ms(knobs.close_bound), Promise.resolve().then(() => c.close())).then((ended) => {
+			if (!ended) c.connection.stream?.destroy?.();
+		});
+	};
+	/** This function waits for the backoff of the next try, then opens a new generation on the next node. */
+	const scheduleRetry = () => retries.schedule(() => {
+		if (closing()) return;
+		record("retry.connect", "connecting", `try ${retries.tries}, ${nodeOf(spec, next).host}:${nodeOf(spec, next).port}`);
+		open();
+	});
+	/** This function ends the generation that is open. The calls in flight learn it after the rejections of amqplib, which can hold a reply code. */
+	const lose = (on, detail) => {
+		const c = connection;
+		connection = null;
+		channel = null;
+		if (closing() || c === null) return;
+		record(on, "failing", detail);
+		clock.after(0, () => flight.settleAll(`the generation ended with the call in flight (${detail})`));
+		if (on === "channel.end") retire(c);
+		scheduleRetry();
+	};
+	/** This function listens to a connection from its creation. The error listener stays: in Node, an error with no listener throws. */
+	const watch = (c) => {
+		c.on("error", (error) => {
+			if (c === connection) record("connection.error", status, message(error));
+		});
+		c.on("close", (error) => {
+			if (c === connection) lose("connection.end", error === void 0 ? "the connection closed" : message(error));
+		});
+		c.on("blocked", (reason) => {
+			if (c === connection && status === "ready") record("connection.blocked", "blocked", String(reason));
+		});
+		c.on("unblocked", () => {
+			if (c !== connection || status !== "blocked") return;
+			record("connection.unblocked", "ready");
+			readied.wake();
+		});
+	};
+	const join = (c, ch, address) => {
+		connection = c;
+		channel = ch;
+		retries.reset();
+		const ends = socketEnds(c.connection.stream);
+		generation = joins.length + 1;
+		const connectionName = ends.localAddress === null ? null : `${ends.localAddress}:${ends.localPort ?? "?"} -> ${ends.remoteAddress ?? "?"}:${ends.remotePort ?? "?"}`;
+		joins.push({
+			generation,
+			at: clock.now(),
+			address,
+			connectionName,
+			...ends
+		});
+		ch.on("error", (error) => {
+			if (ch === channel) record("channel.error", status, message(error));
+		});
+		ch.on("close", () => {
+			queueMicrotask(() => {
+				if (ch === channel) lose("channel.end", "the channel closed");
+			});
+		});
+		record("join", "ready", `generation ${generation}, ${address}`);
+		readied.wake();
+	};
+	/**
+	* This function opens one generation: a connection, then its confirm channel, in `connect_bound`.
+	* A failure goes to `failing`, and the backoff starts. A connection that arrives after its bound
+	* or after the close is closed at once. The promise resolves when this try ends.
+	*/
+	const open = () => {
+		const mine = token += 1;
+		const index = next;
+		next += 1;
+		const node = nodeOf(spec, index);
+		const address = `${node.host}:${node.port}`;
+		let opened = null;
+		let finish = () => {};
+		const ended = new Promise((resolve) => finish = resolve);
+		const stale = () => mine !== token || closing();
+		const fail = (detail) => {
+			bound();
+			finish();
+			if (stale()) return;
+			token += 1;
+			if (opened !== null) retire(opened);
+			record("connect.failed", "failing", `${address}: ${detail}`);
+			scheduleRetry();
+		};
+		const bound = clock.after(ms(knobs.connect_bound), () => fail("no open connection and channel in connect_bound"));
+		(async () => {
+			const c = await create(rabbitOptions(name, spec, index));
+			opened = c;
+			watch(c);
+			if (stale()) {
+				retire(c);
+				return;
+			}
+			const ch = await c.createConfirmChannel();
+			if (stale()) {
+				retire(c);
+				return;
+			}
+			bound();
+			join(c, ch, address);
+			finish();
+		})().catch((error) => fail(message(error)));
+		return ended;
+	};
+	/** This function gives the channel for a call, or the reason that the call does not leave the client. */
+	const usable = (signal) => {
+		if (status === "none") return notSent(`${name} has not connected`);
+		if (status !== "ready" || channel === null) return notSent(`${name} is ${status}, not ready: the call did not leave the client`);
+		if (signal?.aborted) return notSent("the caller aborted the call before it left the client");
+		return channel;
+	};
+	/** This function makes one try of a publish: the write, then the confirm, in `request_timeout`. */
+	const publishAttempt = (sent, signal) => {
+		const ch = usable(signal);
+		if ("outcome" in ch) return Promise.resolve(ch);
+		const content = typeof sent.content === "string" ? Buffer.from(sent.content, "utf8") : sent.content;
+		return trackWithTimer(flight, clock, requestTimeout, signal, "the caller abandoned the publish after it was written", "no confirm in request_timeout: the broker can have the message", (settle) => {
+			try {
+				ch.publish(sent.exchange, sent.routingKey, content, sent.properties ?? {}, (error) => settle(error === null ? {
+					outcome: "ok",
+					value: void 0
+				} : failureOutcome(error)));
+			} catch (error) {
+				settle(failureOutcome(error));
+			}
+		});
+	};
+	/**
+	* This function makes one try of an RPC on the channel, in `request_timeout`. A reply that comes
+	* after the call settled goes to `late`, thus a message that nobody receives goes back to its queue.
+	*/
+	const rpcAttempt = (signal, what, run, value, late) => {
+		const ch = usable(signal);
+		if ("outcome" in ch) return Promise.resolve(ch);
+		let finished = false;
+		return trackWithTimer(flight, clock, requestTimeout, signal, `the caller abandoned ${what} after it was sent`, `no reply to ${what} in request_timeout`, (settle) => {
+			Promise.resolve().then(() => run(ch)).then((reply) => {
+				if (finished) late?.(reply, ch);
+				else settle({
+					outcome: "ok",
+					value: value(reply)
+				});
+			}, (error) => settle(failureOutcome(error)));
+		}, () => {
+			finished = true;
+		});
+	};
+	const publish = (operation, sent, sendOptions = {}) => sendWithReissue({
+		clock,
+		bound: requestTimeout,
+		operation: operations[operation],
+		options: sendOptions,
+		attempt: (signal) => publishAttempt(sent, signal),
+		beforeAgain: (left, signal) => readied.wait(left, signal),
+		onReissue: () => record("command.reissue", status, operation)
+	});
+	const get = (operation, queue, sendOptions = {}) => {
+		const at = () => generation;
+		return sendWithReissue({
+			clock,
+			bound: requestTimeout,
+			operation: operations[operation],
+			options: sendOptions,
+			attempt: (signal) => {
+				const held = at();
+				return rpcAttempt(signal, "basic.get", (ch) => ch.get(queue, { noAck: false }), (reply) => reply === false ? null : {
+					message: reply,
+					generation: held,
+					delivery: deliveryCount(reply)
+				}, (reply, ch) => {
+					if (reply === false) return;
+					try {
+						ch.nack(reply, false, true);
+					} catch {}
+				});
+			},
+			beforeAgain: (left, signal) => readied.wait(left, signal),
+			onReissue: () => record("command.reissue", status, operation)
+		});
+	};
+	/** This function gives the channel that holds a delivery. A delivery of an ended generation is back on its queue already (at least once). */
+	const holder = (job) => {
+		const ch = channel;
+		if (ch === null || job.generation !== generation) throw new Error(`${name}: the channel of generation ${job.generation} ended, thus the broker put the message back on its queue`);
+		return ch;
+	};
+	const jobs = (operation, queue) => ({
+		source: async (signal) => {
+			const taken = await get(operation, queue, { signal });
+			if (taken.outcome === "ok") return taken.value;
+			throw new Error(`${name} could not take a message from ${queue}: ${taken.error}`);
+		},
+		settle: {
+			ack: (job) => holder(job).ack(job.message),
+			requeue: (job) => holder(job).nack(job.message, false, true),
+			reject: (job) => holder(job).nack(job.message, false, false),
+			delivery: (job) => job.delivery
+		}
+	});
+	const handle = {
+		async connect(signal) {
+			if (signal.aborted) throw new Error(`${name}: the service stopped before the connect`);
+			record("status.connecting", "connecting");
+			await open();
+		},
+		async close() {
+			if (status === "none" || closing()) return;
+			record("close.request", "closing");
+			retries.cancel();
+			token += 1;
+			const c = connection;
+			if (c !== null) {
+				if (!await withinBound(clock, ms(knobs.close_bound), Promise.resolve().then(() => c.close()))) {
+					record("close.bound", "closing");
+					record("close.destroy", "closing");
+					c.connection.stream?.destroy?.();
+				}
+			}
+			connection = null;
+			channel = null;
+			flight.settleAll("the client closed with the call in flight");
+			record("status.end", "end");
+		}
+	};
+	const heartbeat = finiteMs(knobs.heartbeat_interval);
+	const declaration = {
+		system: spec.system,
+		knobs: {
+			connect_bound: knobs.connect_bound,
+			request_timeout: knobs.request_timeout,
+			heartbeat_interval: knobs.heartbeat_interval,
+			heartbeat_detection_time: heartbeat === void 0 ? knobs.heartbeat_interval : quantity(3 * heartbeat / 1e3, "s"),
+			retry_base: knobs.retry_base,
+			retry_cap: knobs.retry_cap,
+			keepalive_idle: knobs.keepalive_idle,
+			idle_refresh_interval: heartbeat === void 0 ? knobs.keepalive_idle : quantity(heartbeat / 2e3, "s"),
+			max_connection_age: knobs.max_connection_age,
+			close_bound: knobs.close_bound,
+			retrans_giveup_time: knobs.retrans_giveup_time
+		},
+		operations
+	};
+	const checks = (checkOptions) => stepChecks(name, checkOptions, {
+		"local-state": localStateCheck(() => status === "ready"),
+		"round-trip": roundTripCheck((sendOptions) => sendWithReissue({
+			clock,
+			bound: requestTimeout,
+			operation: void 0,
+			options: sendOptions,
+			attempt: (signal) => rpcAttempt(signal, "a passive exchange.declare", (ch) => ch.checkExchange(CHECK_EXCHANGE), () => void 0),
+			onReissue: () => {}
+		})),
+		dial: dialCheck(dial, spec.host, spec.port)
+	});
+	return {
+		name,
+		declaration,
+		handle,
+		meets: rabbitMeetings(name, knobs),
+		get status() {
+			return status;
+		},
+		joins,
+		publish,
+		get,
+		jobs,
+		checks,
+		attach: (svc, checkOptions) => attachClient(svc, name, declaration, handle, checks(checkOptions)),
+		problems: (description) => clientProblems(name, description, clientBounds(knobs))
+	};
+};
+//#endregion
+//#region src/rabbitmq/machine.ts
+/** The states where a generation is open, and the states where the client can close. */
+const OPEN = ["ready", "blocked"];
+const SERVING = [
+	"connecting",
+	...OPEN,
+	"failing"
+];
+const LIVE = [...SERVING, "closing"];
+/**
+* The RabbitMQ client of the service as a `mark1russell7.machine/1` document. It is one generation
+* at a time: one connection of amqplib and its confirm channel. The machines `amqplib` and
+* `rabbitmq-connection` of `@mark1russell7/machines` give the connection and its heartbeat. The states:
+* - `ready`: the channel is open, and the client sends each call.
+* - `blocked`: a resource alarm of the broker blocked the connection. Each call is not sent until the unblock.
+* - `failing`: no generation is open. The client tries the next node after its backoff.
+*
+* The end of the channel or of the connection ends the generation. A test records the transitions
+* of the client and replays them against this document.
+*/
+const RABBIT_CLIENT_MACHINE = {
+	format: "mark1russell7.machine/1",
+	id: "service.machine.rabbitmq-client",
+	title: "The RabbitMQ client of the service, over amqplib 2",
+	layer: "driver",
+	version: "0.1.0",
+	sources: [{
+		ref: "packages/service/src/rabbitmq (the client implements this document)",
+		rung: "implemented"
+	}],
+	states: {
+		none: {
+			initial: true,
+			note: "the client exists, and its first connection does not"
+		},
+		connecting: { note: "a connection, its handshake, and the open of its confirm channel, in connect_bound" },
+		ready: { note: "the channel is open. A black hole stays hidden until the heartbeat or a timer of a call ends it" },
+		blocked: { note: "a resource alarm blocked the connection: the broker does not read its socket" },
+		failing: { note: "no generation is open. The client tries the next node after its backoff" },
+		closing: { note: "connection.close, in close_bound, then a destroy of the socket" },
+		end: {
+			final: true,
+			note: "the service closed the client"
+		}
+	},
+	events: {
+		"status.connecting": { kind: "local" },
+		join: {
+			kind: "rx",
+			note: "the confirm channel is open: a new generation (D1)"
+		},
+		"connect.failed": {
+			kind: "local",
+			note: "the connection or its channel failed, or did not open in connect_bound"
+		},
+		"retry.connect": {
+			kind: "timer",
+			note: "the backoff ended: a try on the next node"
+		},
+		"connection.error": {
+			kind: "rx",
+			note: "an error event of the connection. Its close follows"
+		},
+		"connection.end": {
+			kind: "rx",
+			note: "the connection closed: a reset, a FIN, the heartbeat, or a close of the broker"
+		},
+		"channel.error": {
+			kind: "rx",
+			note: "the broker closed the channel with a reply code"
+		},
+		"channel.end": {
+			kind: "rx",
+			note: "the channel closed on a connection that stays: the client closes that connection too"
+		},
+		"connection.blocked": {
+			kind: "rx",
+			note: "connection.blocked of the broker: a resource alarm"
+		},
+		"connection.unblocked": { kind: "rx" },
+		"command.reissue": { kind: "local" },
+		"close.request": { kind: "local" },
+		"close.bound": {
+			kind: "timer",
+			note: "connection.close got no close-ok in close_bound"
+		},
+		"close.destroy": {
+			kind: "local",
+			note: "the bound destroys a socket that a silent broker does not close"
+		},
+		"status.end": { kind: "local" }
+	},
+	knobs: {
+		connect_bound: clientKnob("socketOptions.timeout"),
+		heartbeat_interval: clientKnob("heartbeat"),
+		retry_base: clientKnob("retry.base"),
+		retry_cap: clientKnob("retry.cap"),
+		close_bound: clientKnob("close.bound")
+	},
+	timers: {
+		connect_timeout: {
+			duration: {
+				knob: "connect_bound",
+				unit: "s"
+			},
+			arms: ["enter:connecting"],
+			cancels: ["join", "connect.failed"],
+			fires: "connect.failed",
+			note: "the bound of the wrapper on the connection and its channel. amqplib bounds the connect and the handshake with the same time"
+		},
+		heartbeat: {
+			duration: {
+				expr: "3 * heartbeat_interval",
+				unit: "s"
+			},
+			arms: ["join"],
+			cancels: ["connection.end", "close.request"],
+			fires: "connection.end",
+			note: "the heartbeat of amqplib ends a silent connection 2 to 3 heartbeats after the last data. Each frame that arrives starts it again"
+		},
+		retry: {
+			duration: {
+				expr: "min(retry_cap, retry_base * pow(2, fired)) + retry_base",
+				unit: "s"
+			},
+			arms: [
+				"connect.failed",
+				"connection.end",
+				"channel.end"
+			],
+			cancels: ["close.request"],
+			fires: "retry.connect",
+			backoff: { resets: ["join"] },
+			note: "the most delay: the backoff doubles from retry_base to retry_cap, with a jitter up to retry_base"
+		},
+		close: closeTimer()
+	},
+	transitions: [
+		transition("connect", "none", "status.connecting", "connecting"),
+		transition("join", "connecting", "join", "ready"),
+		transition("connect-failed", "connecting", "connect.failed", "failing", { timer: "connect_timeout" }),
+		transition("retry", "failing", "retry.connect", "connecting", { timer: "retry" }),
+		transition("connection-end", [...OPEN], "connection.end", "failing", { timer: "heartbeat" }),
+		transition("channel-end", [...OPEN], "channel.end", "failing"),
+		transition("blocked", "ready", "connection.blocked", "blocked"),
+		transition("unblocked", "blocked", "connection.unblocked", "ready"),
+		...OPEN.map((state) => transition(`connection-error-${state}`, state, "connection.error", state)),
+		...OPEN.map((state) => transition(`channel-error-${state}`, state, "channel.error", state)),
+		...LIVE.map((state) => transition(`reissue-${state}`, state, "command.reissue", state)),
+		transition("close", [...SERVING], "close.request", "closing"),
+		transition("close-bound", "closing", "close.bound", "closing", { timer: "close" }),
+		transition("close-destroy", "closing", "close.destroy", "closing"),
+		transition("end", "closing", "status.end", "end")
+	]
+};
+//#endregion
+//#region src/rabbitmq/starting.ts
+/**
+* This poll is the poll of the checks that `RABBIT_STARTING_KNOBS` fits. It is `STARTING_POLL` of
+* the core: each 5 s with a jitter of 20 %, and a timeout of 4 s (B6, O12). The poll does not depend on the driver.
+*/
+const RABBIT_STARTING_POLL = STARTING_POLL;
+/**
+* These knobs are a declaration to start from, from what the cells of R3 measured on amqplib 2.2.0
+* against RabbitMQ 4.3.6. The runtime has no defaults: a service gives these knobs, or its own.
+* Each value holds the borders that the cells measured:
+* - `connect_bound` 5 s: the connect timeout of DP44. The timer stops when the connection opens.
+*   Thus it does not change a fault with a call in flight. At its defaults, amqplib has no connect timeout.
+* - `request_timeout` 9.5 s: in the slowest poll of 10 s (O13). After a loss of the leader of a quorum
+*   queue, the first confirm came at 6.61 s, 6.68 s and 8.05 s (T11). A later confirm is indeterminate, not lost.
+* - `heartbeat_interval` 15 s: the heartbeat ended a silent connection 45.009 s after the last data,
+*   before the kernel gave up at 53.016 s (O17). The frames each 7.5 s keep a flow through a router
+*   that forgets it at 30 s (O03). At the 60 s of the broker, the heartbeat came at 180.009 s.
+* - `retry_base` 1 s: the cells connected to the next node 1 s after the end of a connection.
+* - `retry_cap` 8 s: no cell measured it. With its jitter of 1 s, the most delay is 9 s, in the slowest poll of 10 s.
+* - `keepalive_idle` "infinite": amqplib sets no keepalive, and the heartbeat refreshes an idle flow.
+*   Linux sends no keepalive probe while data is in flight.
+* - `max_connection_age` "infinite": the client does not replace its connection at an age.
+* - `close_bound` 2 s: behind a black hole, `connection.close` waits for its close-ok with no bound.
+* - `retrans_giveup_time` 924.6 s: the give-up of Linux at `tcp_retries2 = 15`.
+*/
+const RABBIT_STARTING_KNOBS = {
+	connect_bound: {
+		value: 5,
+		unit: "s"
+	},
+	request_timeout: {
+		value: 9.5,
+		unit: "s"
+	},
+	heartbeat_interval: {
+		value: 15,
+		unit: "s"
+	},
+	retry_base: {
+		value: 1,
+		unit: "s"
+	},
+	retry_cap: {
+		value: 8,
+		unit: "s"
+	},
+	keepalive_idle: {
+		value: "infinite",
+		unit: "s"
+	},
+	max_connection_age: {
+		value: "infinite",
+		unit: "s"
+	},
+	close_bound: {
+		value: 2,
+		unit: "s"
+	},
+	retrans_giveup_time: {
+		value: 924.6,
+		unit: "s"
+	}
+};
+//#endregion
+export { AMQP_HEADER, MANIFESTATIONS, RABBIT_CLIENT_MACHINE, RABBIT_STARTING_KNOBS, RABBIT_STARTING_POLL, STARTING_POLL, amqpDial, deliveryCount, failureOutcome, firstDetector, nodeAmqp, rabbitClient, rabbitMeetings, rabbitOptions, readyWait, retryBackoff, retryProblems, specProblems, startJudge, unwatched };
+
+//# sourceMappingURL=rabbitmq.js.map