@znight/messaging 0.0.0-stage → 0.1.1

package/dist/rabbitmq.mjs

@@ -0,0 +1,686 @@
+import { _ as consumerError, a as sleep, c as attemptFromHeaders, g as brokerUnavailableError, o as truncate, r as errorMessage, s as MessagingHeaders } from "./async-CFh_bvex.mjs";
+import { a as toHeaderRecord, i as readHeader, r as durationOption, t as MAX_ERROR_HEADER_LENGTH } from "./shared-BJBpLS8V.mjs";
+import { connect } from "amqplib";
+// src/drivers/rabbitmq.ts
+/** Largest TTL RabbitMQ accepts (2^32 - 1 ms). */
+const MAX_TTL_MS = 4294967295;
+const DEFAULT_IN_PROCESS_DELAY_MS = 5e3;
+const DEFAULT_DELAY_LEVEL_PREFIX = "znight.delays";
+/** Delay levels of delayed publications: level n waits 2^n ms, all of them together `MAX_TTL_MS`. */
+const DELAY_LEVELS = 32;
+/** First word of the routing key of a delayed publication, followed by one bit per level (highest first). */
+const DELAY_ROUTING_WORD = "znight-delay";
+/**
+* Headers never copied to republished messages (retries, dead letters): the ones managed by the broker,
+* and the sender-selected destinations (`CC`, `BCC`), which would route the copy to other queues.
+*/
+const UNCOPIED_HEADERS = /* @__PURE__ */ new Set([
+	"x-delivery-count",
+	"x-death",
+	"x-first-death-exchange",
+	"x-first-death-queue",
+	"x-first-death-reason",
+	"x-last-death-exchange",
+	"x-last-death-queue",
+	"x-last-death-reason",
+	"CC",
+	"BCC"
+]);
+/** Creates a {@link RabbitMQDriver}. */
+function rabbitmq(options) {
+	return new RabbitMQDriver(options);
+}
+/** RabbitMQ {@link MessagingDriver}. See the module documentation. */
+var RabbitMQDriver = class {
+	name = "rabbitmq";
+	capabilities;
+	#options;
+	#queueType;
+	#assertTopology;
+	#subscriptions = /* @__PURE__ */ new Set();
+	/** Retry delay queues already declared, by name. */
+	#delayQueues = /* @__PURE__ */ new Map();
+	/** Publications awaiting their confirmation, by destination and message id (to detect returned messages). */
+	#pending = /* @__PURE__ */ new Map();
+	#abort = new AbortController();
+	#logger = {
+		debug() {},
+		info() {},
+		warn() {},
+		error() {}
+	};
+	#model;
+	#publisher;
+	/** Declaration of the delay levels on the current connection. */
+	#delayLevels;
+	#closing = false;
+	/** Running recovery loop (reconnection and resubscriptions). */
+	#recovering;
+	constructor(options) {
+		if (options === null || typeof options !== "object" || options.url === void 0) throw new TypeError("[znight] rabbitmq(): the \"url\" option is required");
+		if (options.delayLevelPrefix !== void 0 && (typeof options.delayLevelPrefix !== "string" || options.delayLevelPrefix === "")) throw new TypeError("[znight] rabbitmq(): \"delayLevelPrefix\" must be a non-empty string");
+		this.#options = options;
+		this.#queueType = options.queueType ?? "quorum";
+		this.#assertTopology = options.assertTopology ?? true;
+		this.capabilities = Object.freeze({
+			nativeDelay: true,
+			maxNativeDelayMs: MAX_TTL_MS,
+			maxInProcessDelayMs: durationOption(options.maxInProcessDelayMs, DEFAULT_IN_PROCESS_DELAY_MS, "rabbitmq maxInProcessDelayMs"),
+			deliveryCount: this.#queueType === "quorum" ? "native" : "header",
+			maxPublishDelayMs: MAX_TTL_MS
+		});
+	}
+	async connect(context) {
+		this.#logger = context.logger;
+		if (this.#model !== void 0) return;
+		if (this.#closing) throw brokerUnavailableError("RabbitMQ: the driver is closed, create a new one");
+		await this.#open();
+	}
+	async close() {
+		if (this.#closing) return;
+		this.#closing = true;
+		this.#abort.abort();
+		for (const subscription of this.#subscriptions) {
+			subscription.active = false;
+			const channel = subscription.channel;
+			subscription.channel = void 0;
+			if (channel !== void 0) await closeQuietly(channel);
+		}
+		this.#subscriptions.clear();
+		const publisher = this.#publisher;
+		this.#publisher = void 0;
+		if (publisher !== void 0) try {
+			await closeQuietly(await publisher);
+		} catch {}
+		const model = this.#model;
+		this.#model = void 0;
+		if (model !== void 0) try {
+			await model.close();
+		} catch {}
+	}
+	deadLetterName(queue) {
+		return this.#options.deadLetterName?.(queue) ?? `${queue}.dlq`;
+	}
+	async #open() {
+		const socketOptions = {
+			...this.#options.socketOptions,
+			clientProperties: {
+				connection_name: this.#options.connectionName ?? "znight",
+				...this.#options.socketOptions?.clientProperties
+			}
+		};
+		const model = await connect(this.#options.url, socketOptions);
+		model.on("error", (error) => {
+			this.#logger.error("RabbitMQ connection error", { err: error });
+		});
+		model.on("close", (error) => this.#onConnectionClosed(model, error));
+		model.on("blocked", (reason) => {
+			this.#logger.warn(`RabbitMQ connection blocked: ${reason}`);
+		});
+		model.on("unblocked", () => {
+			this.#logger.info("RabbitMQ connection unblocked");
+		});
+		this.#model = model;
+		this.#publisher = void 0;
+		this.#delayQueues.clear();
+		this.#delayLevels = void 0;
+	}
+	#onConnectionClosed(model, error) {
+		if (this.#model !== model) return;
+		this.#model = void 0;
+		this.#publisher = void 0;
+		for (const subscription of this.#subscriptions) {
+			subscription.channel = void 0;
+			subscription.consumerTag = void 0;
+		}
+		if (this.#closing) return;
+		const reconnect = this.#options.reconnect;
+		this.#logger.error(reconnect === false ? "RabbitMQ connection lost" : "RabbitMQ connection lost, reconnecting", error === void 0 ? {} : { err: error });
+		if (reconnect !== false) this.#recover();
+	}
+	/**
+	* Starts the recovery loop unless it is running. The loop re-reads the whole state (connection,
+	* subscriptions without channel) before it ends, so a failure happening while it runs is never lost.
+	*/
+	#recover() {
+		if (this.#closing) return;
+		this.#recovering ??= this.#recoverLoop();
+	}
+	/** Reconnects if needed, then resumes every subscription, with backoff, until everything consumes. */
+	async #recoverLoop() {
+		const reconnect = this.#options.reconnect;
+		const settings = reconnect === false ? {} : reconnect ?? {};
+		const initialDelay = settings.initialDelayMs ?? 100;
+		const maxDelay = settings.maxDelayMs ?? 3e4;
+		let delay = initialDelay;
+		let reconnected = false;
+		try {
+			while (!this.#closing) {
+				try {
+					await sleep(delay, this.#abort.signal);
+				} catch {
+					return;
+				}
+				if (this.#model === void 0) {
+					if (reconnect === false) return;
+					try {
+						await this.#open();
+						reconnected = true;
+					} catch (error) {
+						delay = Math.min(delay * 2, maxDelay);
+						this.#logger.warn(`RabbitMQ reconnection failed, next attempt in ${delay} ms`, { err: error });
+						continue;
+					}
+				}
+				const model = this.#model;
+				for (const subscription of this.#subscriptions) {
+					if (!subscription.active || subscription.channel !== void 0) continue;
+					try {
+						if (subscription.redeclare) await this.#redeclare(subscription);
+						await this.#ensureConsuming(subscription);
+						if (!reconnected) this.#logger.info(`RabbitMQ: consuming "${subscription.queue}" again`);
+					} catch (error) {
+						this.#logger.error(`RabbitMQ: cannot consume "${subscription.queue}" again`, { err: error });
+					}
+				}
+				if (this.#closing) return;
+				if (this.#model !== model) {
+					delay = Math.min(delay * 2, maxDelay);
+					continue;
+				}
+				const waiting = [...this.#subscriptions].filter((subscription) => subscription.active && subscription.channel === void 0);
+				if (waiting.length > 0) {
+					delay = Math.min(delay * 2, maxDelay);
+					this.#logger.warn(`RabbitMQ: ${waiting.map((subscription) => `"${subscription.queue}"`).join(", ")} not consumed yet, next attempt in ${delay} ms`);
+					continue;
+				}
+				if (reconnected) this.#logger.info("RabbitMQ connection restored");
+				return;
+			}
+		} finally {
+			this.#recovering = void 0;
+		}
+	}
+	#connection(action) {
+		const model = this.#model;
+		if (model === void 0) throw brokerUnavailableError(this.#closing ? `RabbitMQ: cannot ${action}, the driver is closed` : `RabbitMQ: cannot ${action}, the connection is not available`);
+		return model;
+	}
+	/** Runs `fn` on a temporary channel (failed declarations close the channel they run on). */
+	async #withChannel(action, fn) {
+		const channel = await this.#connection(action).createChannel();
+		channel.on("error", () => {});
+		try {
+			return await fn(channel);
+		} finally {
+			await closeQuietly(channel);
+		}
+	}
+	async publish(queue, message) {
+		const headers = { ...message.headers };
+		const properties = {
+			messageId: message.id,
+			contentType: message.contentType,
+			timestamp: Math.floor(message.timestamp / 1e3),
+			headers,
+			persistent: this.#options.persistent ?? true,
+			...message.type === void 0 ? {} : { type: message.type }
+		};
+		const content = Buffer.from(message.body);
+		if (message.delayMs > 0) {
+			await this.#publishDelayed(queue, content, properties, message.delayMs);
+			return;
+		}
+		await this.#confirmPublish("", queue, content, properties, queue);
+	}
+	#publisherChannel() {
+		const existing = this.#publisher;
+		if (existing !== void 0) return existing;
+		const opening = this.#connection("publish").createConfirmChannel().then((channel) => {
+			channel.on("error", (error) => {
+				this.#logger.error("RabbitMQ publisher channel error", { err: error });
+			});
+			channel.on("close", () => {
+				if (this.#publisher === opening) this.#publisher = void 0;
+			});
+			channel.on("return", (returned) => {
+				const key = pendingKey(returned.fields.exchange, returned.fields.routingKey, returned.properties.messageId);
+				const pending = this.#pending.get(key)?.find((entry) => !entry.returned);
+				if (pending !== void 0) pending.returned = true;
+			});
+			return channel;
+		});
+		opening.catch(() => {
+			if (this.#publisher === opening) this.#publisher = void 0;
+		});
+		this.#publisher = opening;
+		return opening;
+	}
+	/**
+	* Publishes to `exchange` with `routingKey` and waits for the broker confirmation. `destination`
+	* names the target queue in errors.
+	*/
+	async #confirmPublish(exchange, routingKey, content, properties, destination) {
+		const channel = await this.#publisherChannel();
+		const mandatory = this.#options.mandatory ?? true;
+		const id = properties.messageId;
+		const key = pendingKey(exchange, routingKey, id);
+		const pending = { returned: false };
+		let waiting = this.#pending.get(key);
+		if (waiting === void 0) {
+			waiting = [];
+			this.#pending.set(key, waiting);
+		}
+		waiting.push(pending);
+		try {
+			await new Promise((resolve, reject) => {
+				try {
+					channel.publish(exchange, routingKey, content, {
+						...properties,
+						mandatory
+					}, (error) => {
+						if (error !== null && error !== void 0) reject(error instanceof Error ? error : new Error(String(error)));
+						else resolve();
+					});
+				} catch (error) {
+					reject(error);
+				}
+			});
+		} catch (error) {
+			throw brokerUnavailableError(`RabbitMQ: publishing to "${destination}" was not confirmed: ${errorMessage(error)}`, error);
+		} finally {
+			const index = waiting.indexOf(pending);
+			if (index !== -1) waiting.splice(index, 1);
+			if (waiting.length === 0 && this.#pending.get(key) === waiting) this.#pending.delete(key);
+		}
+		if (pending.returned) throw brokerUnavailableError(exchange === "" ? `RabbitMQ: message ${id} is unroutable, queue "${destination}" does not exist` : `RabbitMQ: message ${id} to "${destination}" is unroutable through the exchange "${exchange}"`);
+	}
+	/**
+	* Publishes through the delay levels: the delay, rounded up to an odd number of milliseconds (so
+	* that every route ends with level 0, whose queue dead-letters to the default exchange), is written
+	* in binary in the routing key; the `CC` header routes the message to `queue` at the end.
+	*/
+	async #publishDelayed(queue, content, properties, delayMs) {
+		const rounded = Math.min(MAX_TTL_MS, Math.ceil(delayMs));
+		const delay = rounded % 2 === 0 ? rounded + 1 : rounded;
+		await this.#declareDelayLevels();
+		let top = 0;
+		while (top < 31 && 2 ** (top + 1) <= delay) top++;
+		try {
+			await this.#confirmPublish(this.#delayLevelName(top), delayRoutingKey(delay), content, {
+				...properties,
+				headers: {
+					...properties.headers,
+					CC: [queue]
+				}
+			}, queue);
+		} catch (error) {
+			this.#delayLevels = void 0;
+			throw error;
+		}
+	}
+	#delayLevelName(level) {
+		return `${this.#options.delayLevelPrefix ?? DEFAULT_DELAY_LEVEL_PREFIX}.${level}`;
+	}
+	/**
+	* Declares (once per connection) the delay levels: for each level n, a topic exchange routing the
+	* messages whose bit n is set to the queue of the level (TTL 2^n ms, dead-lettering to the level
+	* below), and the others straight to the level below.
+	*/
+	async #declareDelayLevels() {
+		let declared = this.#delayLevels;
+		if (declared === void 0) {
+			const levels = this.#withChannel("declare the delay levels", async (channel) => {
+				for (let level = 0; level < DELAY_LEVELS; level++) {
+					const name = this.#delayLevelName(level);
+					const below = level === 0 ? "" : this.#delayLevelName(level - 1);
+					await channel.assertExchange(name, "topic", { durable: true });
+					await channel.assertQueue(name, {
+						durable: true,
+						arguments: this.#delayQueueArguments(2 ** level, below)
+					});
+					await channel.bindQueue(name, name, delayBindingKey(level, "1"));
+					if (level > 0) await channel.bindExchange(below, name, delayBindingKey(level, "0"));
+				}
+			});
+			declared = levels;
+			this.#delayLevels = levels;
+			levels.catch(() => {
+				if (this.#delayLevels === levels) this.#delayLevels = void 0;
+			});
+		}
+		try {
+			await declared;
+		} catch (error) {
+			const message = errorMessage(error);
+			throw consumerError(`RabbitMQ: cannot declare the delay levels "${this.#delayLevelName(0)}" to "${this.#delayLevelName(31)}": ${message}`, message.includes("PRECONDITION_FAILED") ? ["They exist with other arguments (another queueType?): set rabbitmq({ delayLevelPrefix }) to use other names"] : []);
+		}
+	}
+	/** Arguments of a delay queue: TTL, then dead-lettering (at-least-once on quorum queues). */
+	#delayQueueArguments(ttl, exchange, routingKey) {
+		const args = {
+			"x-queue-type": this.#queueType,
+			"x-message-ttl": ttl,
+			"x-dead-letter-exchange": exchange
+		};
+		if (routingKey !== void 0) args["x-dead-letter-routing-key"] = routingKey;
+		if (this.#queueType === "quorum") {
+			args["x-dead-letter-strategy"] = "at-least-once";
+			args["x-overflow"] = "reject-publish";
+		}
+		return args;
+	}
+	/** Declares (once per connection) the retry delay queue of `queue` for `delayMs` and returns its name. */
+	async #delayQueue(queue, delayMs) {
+		const name = this.#options.delayQueueName?.(queue, delayMs) ?? `${queue}.delay.${delayMs}`;
+		let declared = this.#delayQueues.get(name);
+		if (declared === void 0) {
+			const args = this.#delayQueueArguments(delayMs, "", queue);
+			declared = this.#withChannel(`declare the delay queue "${name}"`, async (channel) => {
+				await channel.assertQueue(name, {
+					durable: true,
+					arguments: args
+				});
+			});
+			this.#delayQueues.set(name, declared);
+			declared.catch(() => this.#delayQueues.delete(name));
+		}
+		try {
+			await declared;
+		} catch (error) {
+			throw topologyError(name, error);
+		}
+		return name;
+	}
+	async subscribe(queue, handler, options) {
+		await this.#prepareTopology(queue, options);
+		const subscription = {
+			queue,
+			handler,
+			options,
+			channel: void 0,
+			consumerTag: void 0,
+			active: true,
+			consuming: void 0,
+			redeclare: false
+		};
+		this.#subscriptions.add(subscription);
+		try {
+			await this.#ensureConsuming(subscription);
+		} catch (error) {
+			subscription.active = false;
+			this.#subscriptions.delete(subscription);
+			throw error;
+		}
+		return {
+			cancel: async () => {
+				subscription.active = false;
+				const { channel, consumerTag } = subscription;
+				if (channel !== void 0 && consumerTag !== void 0) {
+					subscription.consumerTag = void 0;
+					try {
+						await channel.cancel(consumerTag);
+					} catch (error) {
+						this.#logger.warn(`RabbitMQ: failed to cancel the consumer of "${queue}"`, { err: error });
+					}
+				}
+			},
+			close: async () => {
+				subscription.active = false;
+				this.#subscriptions.delete(subscription);
+				const channel = subscription.channel;
+				subscription.channel = void 0;
+				if (channel !== void 0) await closeQuietly(channel);
+			}
+		};
+	}
+	async #prepareTopology(queue, options) {
+		const dlq = options.deadLetterQueue;
+		const names = dlq === void 0 ? [queue] : [queue, dlq];
+		if (this.#assertTopology) for (const name of names) try {
+			await this.#declareQueue(name);
+		} catch (error) {
+			throw topologyError(name, error);
+		}
+		else for (const name of names) try {
+			await this.#withChannel(`check the queue "${name}"`, (channel) => channel.checkQueue(name));
+		} catch (error) {
+			throw consumerError(`RabbitMQ: queue "${name}" of consumer ${options.consumer} does not exist (${errorMessage(error)})`, ["Declare it, or set assertTopology: true to let Znight declare it"]);
+		}
+		for (const delay of options.retryDelays) await this.#delayQueue(queue, Math.round(delay));
+	}
+	/**
+	* Declares a consumed or dead-letter queue. Quorum queues get `x-delivery-limit: -1` on RabbitMQ >= 4
+	* (whose default limit of 20 deliveries counts the releases); an existing queue declared without it
+	* cannot be changed by a declaration: it is declared as it is, with a warning.
+	*/
+	async #declareQueue(name) {
+		const args = {
+			"x-queue-type": this.#queueType,
+			...this.#options.queueArguments
+		};
+		const declare = (queueArgs) => this.#withChannel(`declare the queue "${name}"`, async (channel) => {
+			await channel.assertQueue(name, {
+				durable: true,
+				arguments: queueArgs
+			});
+		});
+		if (args["x-queue-type"] === "quorum" && !Object.hasOwn(args, "x-delivery-limit") && this.#serverMajor() >= 4) try {
+			await declare({
+				...args,
+				"x-delivery-limit": -1
+			});
+			return;
+		} catch (error) {
+			if (!errorMessage(error).includes("'x-delivery-limit'")) throw error;
+			this.#logger.warn(`RabbitMQ: queue "${name}" exists without "x-delivery-limit": unless a policy sets "delivery-limit" to -1, RabbitMQ drops (or dead-letters through a queue DLX) a message delivered 20 times, releases included (shutdowns, failed dead-lettering). Apply such a policy, or re-create the queue`);
+		}
+		await declare(args);
+	}
+	/** Major version of the connected RabbitMQ (0 when unknown). */
+	#serverMajor() {
+		const version = this.#model?.connection?.serverProperties?.version;
+		const major = typeof version === "string" ? Number.parseInt(version, 10) : NaN;
+		return Number.isNaN(major) ? 0 : major;
+	}
+	/** After a consumer cancellation, declares its queues again (`assertTopology`) before consuming. */
+	async #redeclare(subscription) {
+		if (this.#assertTopology) {
+			const dlq = subscription.options.deadLetterQueue;
+			for (const name of dlq === void 0 ? [subscription.queue] : [subscription.queue, dlq]) try {
+				await this.#declareQueue(name);
+			} catch (error) {
+				throw topologyError(name, error);
+			}
+		}
+		subscription.redeclare = false;
+	}
+	/** Opens the consumer channel of `subscription` unless it is open or opening. */
+	#ensureConsuming(subscription) {
+		if (!subscription.active || subscription.channel !== void 0) return Promise.resolve();
+		subscription.consuming ??= this.#consume(subscription).finally(() => {
+			subscription.consuming = void 0;
+		});
+		return subscription.consuming;
+	}
+	async #consume(subscription) {
+		const channel = await this.#connection(`consume "${subscription.queue}"`).createChannel();
+		channel.on("error", (error) => {
+			this.#logger.error(`RabbitMQ consumer channel of "${subscription.queue}" failed`, { err: error });
+		});
+		channel.on("close", () => {
+			if (subscription.channel !== channel) return;
+			subscription.channel = void 0;
+			subscription.consumerTag = void 0;
+			if (subscription.active) this.#recover();
+		});
+		try {
+			await channel.prefetch(subscription.options.concurrency);
+			subscription.channel = channel;
+			const { consumerTag } = await channel.consume(subscription.queue, (message) => {
+				if (message === null) {
+					this.#onConsumerCancelled(subscription, channel);
+					return;
+				}
+				this.#deliver(subscription, channel, message);
+			}, { noAck: false });
+			subscription.consumerTag = consumerTag;
+		} catch (error) {
+			subscription.channel = void 0;
+			await closeQuietly(channel);
+			throw brokerUnavailableError(`RabbitMQ: cannot consume "${subscription.queue}": ${errorMessage(error)}`, error);
+		}
+	}
+	/**
+	* The broker cancelled the consumer (`basic.cancel`: queue deleted, node down...). The channel stays
+	* open, so nothing else would notice: close it (its unsettled messages go back to the queue, when it
+	* still exists) and resume the subscription.
+	*/
+	#onConsumerCancelled(subscription, channel) {
+		if (subscription.channel !== channel || !subscription.active) return;
+		this.#logger.error(`RabbitMQ cancelled the consumer of "${subscription.queue}" (queue deleted?), consuming again`);
+		subscription.channel = void 0;
+		subscription.consumerTag = void 0;
+		subscription.redeclare = true;
+		closeQuietly(channel).then(() => void 0, () => void 0);
+		this.#recover();
+	}
+	#deliver(subscription, channel, message) {
+		const { queue } = subscription;
+		const properties = message.properties;
+		const rawHeaders = { ...properties.headers ?? {} };
+		const headers = toHeaderRecord(Object.entries(rawHeaders));
+		const deliveryCount = Number(rawHeaders["x-delivery-count"]);
+		let redeliveries = message.fields.redelivered ? 1 : 0;
+		if (Number.isSafeInteger(deliveryCount) && deliveryCount > 0) redeliveries = deliveryCount;
+		const type = stringProperty(properties.type) ?? readHeader(headers, MessagingHeaders.Type) ?? (this.#options.typeFromRoutingKey === true && message.fields.exchange !== "" ? message.fields.routingKey : void 0);
+		const id = stringProperty(properties.messageId) ?? `${queue}:${message.fields.deliveryTag}`;
+		const timestamp = typeof properties.timestamp === "number" ? properties.timestamp * 1e3 : void 0;
+		let settled = false;
+		const settle = (action) => {
+			if (settled) throw new Error(`[rabbitmq] message ${id} was already settled (${action})`);
+			if (subscription.channel !== channel) throw brokerUnavailableError(`RabbitMQ: cannot ${action} message ${id}, its channel is closed (it will be redelivered)`);
+		};
+		/** Properties of a republished copy: the original ones, with the type that selected the handler. */
+		const copyProperties = (extraHeaders, removeAttempt) => {
+			const copied = {};
+			for (const [name, value] of Object.entries(rawHeaders)) {
+				if (UNCOPIED_HEADERS.has(name) || removeAttempt && name === MessagingHeaders.Attempt) continue;
+				copied[name] = value;
+			}
+			return {
+				...definedProperties(properties),
+				...type === void 0 ? {} : { type },
+				messageId: id,
+				headers: {
+					...copied,
+					...extraHeaders
+				},
+				persistent: this.#options.persistent ?? true
+			};
+		};
+		const delivery = {
+			id,
+			body: message.content,
+			contentType: stringProperty(properties.contentType),
+			headers,
+			type,
+			key: void 0,
+			attempt: attemptFromHeaders(headers) + redeliveries,
+			redelivered: message.fields.redelivered,
+			timestamp,
+			raw: message,
+			ack: async () => {
+				await Promise.resolve();
+				settle("ack");
+				channel.ack(message);
+				settled = true;
+			},
+			release: async () => {
+				await Promise.resolve();
+				settle("release");
+				channel.nack(message, false, true);
+				settled = true;
+			},
+			retry: async (request) => {
+				settle("retry");
+				const target = request.delayMs > 0 ? await this.#delayQueue(queue, Math.round(request.delayMs)) : queue;
+				try {
+					await this.#confirmPublish("", target, message.content, copyProperties({ [MessagingHeaders.Attempt]: String(request.attempt) }, false), target);
+				} catch (error) {
+					if (target !== queue) this.#delayQueues.delete(target);
+					throw error;
+				}
+				settle("retry");
+				channel.ack(message);
+				settled = true;
+			},
+			deadLetter: async (request) => {
+				settle("dead-letter");
+				if (request.queue === void 0) {
+					channel.nack(message, false, false);
+					settled = true;
+					return;
+				}
+				await this.#confirmPublish("", request.queue, message.content, copyProperties({
+					[MessagingHeaders.DeadLetterReason]: request.reason,
+					[MessagingHeaders.Error]: truncate(errorMessage(request.error), MAX_ERROR_HEADER_LENGTH),
+					[MessagingHeaders.OriginalQueue]: queue,
+					[MessagingHeaders.Attempts]: String(request.attempt)
+				}, true), request.queue);
+				settle("dead-letter");
+				channel.ack(message);
+				settled = true;
+			}
+		};
+		subscription.handler(delivery).catch((error) => {
+			this.#logger.error(`RabbitMQ: unexpected failure handling message ${id}`, { err: error });
+		});
+	}
+};
+function stringProperty(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/** Key of the publications awaiting their confirmation (a returned message carries the same fields). */
+function pendingKey(exchange, routingKey, messageId) {
+	return `${exchange}\u0000${routingKey}\u0000${String(messageId)}`;
+}
+/** Routing key of a delayed publication: `znight-delay.<bit 31>.<bit 30>...<bit 0>`. */
+function delayRoutingKey(delayMs) {
+	const words = [DELAY_ROUTING_WORD];
+	for (let level = 31; level >= 0; level--) words.push(Math.floor(delayMs / 2 ** level) % 2 === 1 ? "1" : "0");
+	return words.join(".");
+}
+/** Binding key matching the delayed publications whose bit `level` is `bit` (exact word count). */
+function delayBindingKey(level, bit) {
+	const words = [DELAY_ROUTING_WORD];
+	for (let index = 31; index >= 0; index--) words.push(index === level ? bit : "*");
+	return words.join(".");
+}
+/** AMQP properties of a received message, reusable for a republication. */
+function definedProperties(properties) {
+	const result = {};
+	if (properties.contentType !== void 0) result.contentType = properties.contentType;
+	if (properties.contentEncoding !== void 0) result.contentEncoding = properties.contentEncoding;
+	if (properties.correlationId !== void 0) result.correlationId = properties.correlationId;
+	if (properties.replyTo !== void 0) result.replyTo = properties.replyTo;
+	if (properties.timestamp !== void 0) result.timestamp = properties.timestamp;
+	if (properties.type !== void 0) result.type = properties.type;
+	if (properties.appId !== void 0) result.appId = properties.appId;
+	if (properties.priority !== void 0) result.priority = properties.priority;
+	if (properties.userId !== void 0) result.userId = properties.userId;
+	return result;
+}
+function topologyError(queue, error) {
+	const message = errorMessage(error);
+	const hints = message.includes("PRECONDITION_FAILED") ? ["The queue exists with different arguments: align queueType/queueArguments, or set assertTopology: false"] : [];
+	return consumerError(`RabbitMQ: cannot declare the queue "${queue}": ${message}`, hints);
+}
+async function closeQuietly(channel) {
+	try {
+		await channel.close();
+	} catch {}
+}
+export { RabbitMQDriver, rabbitmq };
+
+//# sourceMappingURL=rabbitmq.mjs.map