@relaybus/rabbitmq 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,33 +1,140 @@
-import { RelayBusError, NonRetryableError, assertEventType, ConfigurationError, toErrorInfo, createRetryPolicy, toMilliseconds, computeRetryDelay, isRetryableError } from '@relaybus/core';
+import { RelayBusError, NonRetryableError, assertEventType, ConfigurationError, systemClock, toErrorInfo, computeRetryDelay, isRetryableError, createRetryPolicy } from '@relaybus/core';
+import { createCloudEventReaders, DecodedEventReader, mediaTypeOf, isJsonObject, observeRejection, createJsonEnvelopeFormat, SubscribingTransport, writeStructuredCloudEvent, schedule, NonEmptyText, PositiveInteger, Milliseconds } from '@relaybus/core/internal';
+export { fromHeader, fromPayloadField } from '@relaybus/core/internal';
 
 // src/errors.ts
 var RabbitMqUnavailableError = class extends RelayBusError {
+  name = "RabbitMqUnavailableError";
+  code = "RELAYBUS_RABBITMQ_UNAVAILABLE";
 };
 var RabbitMqPublishRejectedError = class extends RelayBusError {
+  name = "RabbitMqPublishRejectedError";
+  code = "RELAYBUS_RABBITMQ_PUBLISH_REJECTED";
 };
 var UnroutableMessageError = class extends RelayBusError {
+  name = "UnroutableMessageError";
+  code = "RELAYBUS_RABBITMQ_UNROUTABLE_MESSAGE";
 };
 var MalformedMessageError = class extends RelayBusError {
+  name = "MalformedMessageError";
+  code = "RELAYBUS_RABBITMQ_MALFORMED_MESSAGE";
 };
 var UnserializablePayloadError = class extends NonRetryableError {
   name = "UnserializablePayloadError";
+  code = "RELAYBUS_RABBITMQ_UNSERIALIZABLE_PAYLOAD";
 };
 var AmqpLimitExceededError = class extends NonRetryableError {
   name = "AmqpLimitExceededError";
+  code = "RELAYBUS_RABBITMQ_AMQP_LIMIT_EXCEEDED";
 };
-
-// src/abortable-sleep.ts
+var RabbitMqUnencodableEventError = class extends NonRetryableError {
+  name = "RabbitMqUnencodableEventError";
+  code = "RELAYBUS_RABBITMQ_UNENCODABLE_EVENT";
+};
+var NACK_MESSAGE = "message nacked";
+var ConfirmedPublishing = class {
+  #transportName;
+  #publishTimeoutMs;
+  constructor(transportName, publishTimeoutMs) {
+    this.#transportName = transportName;
+    this.#publishTimeoutMs = publishTimeoutMs;
+  }
+  async publish(publisher, input) {
+    const { exchange, routingKey, content, options, mandatory } = input;
+    const eventId = options.messageId ?? "unknown";
+    if (publisher === void 0) {
+      throw new RabbitMqUnavailableError(
+        `[RabbitMqTransport](publish) Not connected to the broker | transport=${this.#transportName} destination=${routingKey}`
+      );
+    }
+    const returnKey = unroutableKey(options.messageId, routingKey);
+    const target = { eventId, destination: routingKey };
+    await new Promise((resolve, reject) => {
+      const cancelTimeout = this.#startTimeout(target, reject);
+      const pending = { ...target, publisher, returnKey, cancelTimeout, resolve, reject };
+      try {
+        publisher.channel.publish(
+          exchange,
+          routingKey,
+          content,
+          { ...options, mandatory },
+          (error) => this.#confirmed(pending, error)
+        );
+      } catch (error) {
+        cancelTimeout();
+        reject(this.#toPublishError(error, target));
+      }
+    });
+  }
+  #startTimeout({ eventId, destination }, reject) {
+    return schedule(systemClock, {
+      run: () => {
+        reject(
+          new RabbitMqUnavailableError(
+            `[RabbitMqTransport](publish) No broker confirm within ${this.#publishTimeoutMs}ms | transport=${this.#transportName} eventId=${eventId} destination=${destination}`
+          )
+        );
+      },
+      delayMs: this.#publishTimeoutMs
+    });
+  }
+  /** The broker's confirm (or nack) of one message arrived. */
+  #confirmed(pending, error) {
+    pending.cancelTimeout();
+    const returned = takeUnroutable(pending.publisher.unroutable, pending.returnKey);
+    if (error) {
+      pending.reject(this.#toPublishError(error, pending));
+    } else if (returned) {
+      pending.reject(
+        new UnroutableMessageError(
+          `[RabbitMqTransport](publish) No queue is bound to the routing key | transport=${this.#transportName} eventId=${pending.eventId} destination=${pending.destination}`
+        )
+      );
+    } else {
+      pending.resolve();
+    }
+  }
+  #toPublishError(error, { eventId, destination }) {
+    const { message } = toErrorInfo(error);
+    const detail = `transport=${this.#transportName} eventId=${eventId} destination=${destination} error=${message}`;
+    return message === NACK_MESSAGE ? new RabbitMqPublishRejectedError(
+      `[RabbitMqTransport](publish) Broker nacked the message | ${detail}`,
+      { cause: error }
+    ) : new RabbitMqUnavailableError(`[RabbitMqTransport](publish) Publish failed | ${detail}`, {
+      cause: error
+    });
+  }
+};
+function unroutableKey(messageId, routingKey) {
+  return `${String(messageId)}
+${routingKey}`;
+}
+function recordUnroutable(unroutable, key) {
+  unroutable.set(key, (unroutable.get(key) ?? 0) + 1);
+}
+function takeUnroutable(unroutable, key) {
+  const count = unroutable.get(key);
+  if (count === void 0) {
+    return false;
+  }
+  if (count === 1) {
+    unroutable.delete(key);
+  } else {
+    unroutable.set(key, count - 1);
+  }
+  return true;
+}
 function abortableSleep(milliseconds, signal) {
   if (signal.aborted) {
     return Promise.resolve();
   }
   return new Promise((resolve) => {
     const finish = () => {
-      clearTimeout(timer);
+      cancel();
       signal.removeEventListener("abort", finish);
       resolve();
     };
-    const timer = setTimeout(finish, milliseconds);
+    const cancel = schedule(systemClock, { run: finish, delayMs: milliseconds });
     signal.addEventListener("abort", finish, { once: true });
   });
 }
@@ -36,7 +143,17 @@ function abortableSleep(milliseconds, signal) {
 var ConnectionSupervisor = class {
   #settings;
   #stop = new AbortController();
+  /** Aborted by `forceClose`: destroys a socket that is still connecting. */
+  #force = new AbortController();
+  /** Resolves on `forceClose`: closing stops waiting for the broker. */
+  #forcing = new Promise((resolve) => {
+    this.#force.signal.addEventListener("abort", () => resolve(), { once: true });
+  });
   #current;
+  /** Connections being closed, until their closing handshake finishes. */
+  #closing = /* @__PURE__ */ new Set();
+  /** Set by `forceClose`: connections are cut instead of closed. */
+  #forced = false;
   #ready = false;
   #started = false;
   #closed = false;
@@ -83,7 +200,7 @@ var ConnectionSupervisor = class {
       return;
     }
     this.#handleLoss(connection, reason);
-    connection.close().catch(() => void 0);
+    void this.#closeConnection(connection);
   }
   /**
    * Stops reconnecting, runs `beforeDisconnect` while the connection is still
@@ -92,23 +209,54 @@ var ConnectionSupervisor = class {
   async close(beforeDisconnect) {
     this.#closed = true;
     this.#stop.abort();
-    await this.#reconnecting;
+    await Promise.race([this.#reconnecting, this.#forcing]);
     try {
-      await beforeDisconnect();
+      await Promise.race([beforeDisconnect(), this.#forcing]);
     } finally {
       const connection = this.#current;
       this.#current = void 0;
       this.#ready = false;
-      await connection?.close().catch(() => void 0);
+      if (connection !== void 0) {
+        await this.#closeConnection(connection);
+      }
     }
   }
+  /**
+   * Stops reconnecting and cuts every connection, open or closing, without the closing handshake. A
+   * connection that finishes opening afterwards is cut at once.
+   */
+  forceClose() {
+    this.#closed = true;
+    this.#forced = true;
+    this.#stop.abort();
+    this.#force.abort();
+    for (const connection of [this.#current, ...this.#closing]) {
+      if (connection !== void 0) {
+        destroySocket(connection);
+      }
+    }
+  }
+  /** Closes a connection, which `forceClose` can cut until the broker answered; cuts it once forced. */
+  async #closeConnection(connection) {
+    if (this.#forced) {
+      destroySocket(connection);
+      return;
+    }
+    this.#closing.add(connection);
+    await connection.close().catch(() => void 0);
+    this.#closing.delete(connection);
+  }
   async #establish() {
-    const connection = await this.#settings.connect();
+    const connection = await this.#settings.connect({ signal: this.#force.signal });
     connection.on("error", (error) => {
       this.#settings.logger.warn(
         `[ConnectionSupervisor](establish) Connection error | error=${error.message}`
       );
     });
+    if (this.#closed) {
+      await this.#closeConnection(connection);
+      throw new RabbitMqUnavailableError("[ConnectionSupervisor](establish) Transport is closed");
+    }
     connection.on("close", (error) => {
       this.#handleLoss(connection, error?.message ?? "closed by peer");
     });
@@ -131,7 +279,7 @@ var ConnectionSupervisor = class {
       this.#current = void 0;
     }
     this.#settings.onDisconnected();
-    await connection.close().catch(() => void 0);
+    await this.#closeConnection(connection);
   }
   #handleLoss(connection, reason) {
     if (connection !== this.#current) {
@@ -158,7 +306,7 @@ var ConnectionSupervisor = class {
     for (let attempt = 1; !this.#closed; attempt += 1) {
       const delayMs = computeRetryDelay(policy, attempt, this.#settings.random);
       this.#settings.logger.log(
-        `[ConnectionSupervisor](reconnect) Reconnecting | attempt=${attempt} delayMs=${delayMs}`
+        `[ConnectionSupervisor](reconnectUntilConnected) Reconnecting | attempt=${attempt} delayMs=${delayMs}`
       );
       await abortableSleep(delayMs, this.#stop.signal);
       if (this.#closed) {
@@ -167,78 +315,111 @@ var ConnectionSupervisor = class {
       try {
         await this.#establish();
         this.#settings.logger.log(
-          `[ConnectionSupervisor](reconnect) Reconnected | attempt=${attempt}`
+          `[ConnectionSupervisor](reconnectUntilConnected) Reconnected | attempt=${attempt}`
         );
         return;
       } catch (error) {
         this.#settings.logger.warn(
-          `[ConnectionSupervisor](reconnect) Attempt failed | attempt=${attempt} error=${toErrorInfo(error).message}`
+          `[ConnectionSupervisor](reconnectUntilConnected) Attempt failed | attempt=${attempt} error=${toErrorInfo(error).message}`
         );
       }
     }
   }
 };
+function destroySocket(connection) {
+  const model = connection;
+  model.connection?.stream?.destroy(
+    new RabbitMqUnavailableError("Connection cut: the shutdown deadline passed")
+  );
+}
 
 // src/json-payload.ts
 function assertJsonPayload(payload, eventId) {
-  visit(payload, "$", /* @__PURE__ */ new Set(), eventId);
+  visit(payload, { path: "$", ancestors: /* @__PURE__ */ new Set(), eventId });
 }
-function visit(value, path, ancestors, eventId) {
+function visit(value, {
+  path,
+  ancestors,
+  eventId
+}) {
   switch (typeof value) {
     case "string":
     case "boolean":
       return;
     case "number":
       if (!Number.isFinite(value)) {
-        throw refuse(eventId, path, `is ${value}, which JSON turns into null`);
+        throw refuse(eventId, { path, reason: `is ${value}, which JSON turns into null` });
       }
       return;
     case "object":
       if (value !== null) {
-        visitObject(value, path, ancestors, eventId);
+        visitObject(value, { path, ancestors, eventId });
       }
       return;
     default:
-      throw refuse(eventId, path, `is ${typeof value}, which JSON cannot represent`);
+      throw refuse(eventId, { path, reason: `is ${typeof value}, which JSON cannot represent` });
   }
 }
-function visitObject(value, path, ancestors, eventId) {
+function visitObject(value, {
+  path,
+  ancestors,
+  eventId
+}) {
   if (ancestors.has(value)) {
-    throw refuse(eventId, path, "is a circular reference");
+    throw refuse(eventId, { path, reason: "is a circular reference" });
   }
   ancestors.add(value);
   if (Array.isArray(value)) {
-    for (let index = 0; index < value.length; index += 1) {
-      if (!(index in value)) {
-        throw refuse(eventId, `${path}[${index}]`, "is an array hole, which JSON turns into null");
-      }
-      visit(value[index], `${path}[${index}]`, ancestors, eventId);
-    }
+    visitArray(value, { path, ancestors, eventId });
   } else {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw refuse(eventId, path, "is not a plain object (class instance, Date, Map or Set)");
-    }
-    if (Object.getOwnPropertySymbols(value).length > 0) {
-      throw refuse(eventId, path, "has a symbol key, which JSON drops");
-    }
-    for (const key of Object.keys(value)) {
-      visit(value[key], `${path}.${key}`, ancestors, eventId);
-    }
+    visitPlainObject(value, { path, ancestors, eventId });
   }
   ancestors.delete(value);
 }
-function refuse(eventId, path, reason) {
+function visitArray(value, { path, ancestors, eventId }) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (!(index in value)) {
+      throw refuse(eventId, {
+        path: `${path}[${index}]`,
+        reason: "is an array hole, which JSON turns into null"
+      });
+    }
+    visit(value[index], { path: `${path}[${index}]`, ancestors, eventId });
+  }
+}
+function visitPlainObject(value, { path, ancestors, eventId }) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw refuse(eventId, {
+      path,
+      reason: "is not a plain object (class instance, Date, Map or Set)"
+    });
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw refuse(eventId, { path, reason: "has a symbol key, which JSON drops" });
+  }
+  for (const key of Object.keys(value)) {
+    visit(value[key], {
+      path: `${path}.${key}`,
+      ancestors,
+      eventId
+    });
+  }
+}
+function refuse(eventId, { path, reason }) {
   return new UnserializablePayloadError(
     `Event ${eventId} has a payload JSON cannot represent faithfully: ${path} ${reason}`
   );
 }
 
 // src/wire-format.ts
+var MILLISECONDS_PER_SECOND = 1e3;
 var ATTRIBUTE_PREFIX = "cloudEvents:";
 var EVENT_HEADER_PREFIX = "relaybus:";
 var SPEC_VERSION = "1.0";
 var JSON_CONTENT_TYPE = "application/json";
+var STRUCTURED_CONTENT_TYPE = "application/cloudevents+json";
+var RESERVED_HEADER_PREFIXES = ["x-death", "x-first-death-", "x-last-death-", "x-relaybus-"];
 var SHORT_STRING_LIMIT_BYTES = 255;
 var RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i;
 function encodeEnvelope(envelope) {
@@ -252,6 +433,22 @@ function encodeEnvelope(envelope) {
     [`${ATTRIBUTE_PREFIX}time`]: envelope.occurredAt.toISOString(),
     [`${ATTRIBUTE_PREFIX}datacontenttype`]: JSON_CONTENT_TYPE
   };
+  addOptionalAttributes(headers, envelope);
+  return {
+    content: Buffer.from(JSON.stringify(envelope.payload), "utf8"),
+    options: {
+      contentType: JSON_CONTENT_TYPE,
+      persistent: true,
+      messageId: envelope.id,
+      timestamp: Math.floor(envelope.occurredAt.getTime() / MILLISECONDS_PER_SECOND),
+      ...mirror("type", envelope.type),
+      ...mirror("appId", envelope.source),
+      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
+      headers
+    }
+  };
+}
+function addOptionalAttributes(headers, envelope) {
   if (envelope.key !== null) {
     headers[`${ATTRIBUTE_PREFIX}subject`] = envelope.key;
   }
@@ -268,20 +465,44 @@ function encodeEnvelope(envelope) {
     );
     headers[`${EVENT_HEADER_PREFIX}${name}`] = value;
   }
+}
+function encodeStructuredEnvelope(envelope) {
+  assertJsonPayload(envelope.payload, envelope.id);
+  assertShortString("Event id", envelope.id);
+  const document = writeStructuredCloudEvent(envelope, {
+    time: envelope.occurredAt.toISOString(),
+    data: JSON.stringify(envelope.payload)
+  });
   return {
-    content: Buffer.from(JSON.stringify(envelope.payload), "utf8"),
+    content: Buffer.from(document, "utf8"),
     options: {
-      contentType: JSON_CONTENT_TYPE,
-      persistent: true,
-      messageId: envelope.id,
-      timestamp: Math.floor(envelope.occurredAt.getTime() / 1e3),
-      ...mirror("type", envelope.type),
-      ...mirror("appId", envelope.source),
-      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
-      headers
+      ...messageProperties(envelope),
+      contentType: STRUCTURED_CONTENT_TYPE,
+      headers: plainHeaders(envelope, envelope.headers)
     }
   };
 }
+function messageProperties(envelope) {
+  return {
+    persistent: true,
+    messageId: envelope.id,
+    timestamp: Math.floor(envelope.occurredAt.getTime() / MILLISECONDS_PER_SECOND),
+    ...mirror("type", envelope.type),
+    ...mirror("appId", envelope.source),
+    ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId)
+  };
+}
+function plainHeaders(envelope, headers) {
+  for (const name of Object.keys(headers)) {
+    if (RESERVED_HEADER_PREFIXES.some((prefix) => name.startsWith(prefix))) {
+      throw new RabbitMqUnencodableEventError(
+        `Event ${envelope.id} has a header '${name}', a name the broker or the transport reserves`
+      );
+    }
+    assertShortString(`Header name '${name}'`, name);
+  }
+  return Object.fromEntries(Object.entries(headers));
+}
 function assertShortString(label, value) {
   const bytes = Buffer.byteLength(value, "utf8");
   if (bytes > SHORT_STRING_LIMIT_BYTES) {
@@ -339,7 +560,7 @@ function parsePayload(content) {
 }
 function parseTime(rawTime, timestampSeconds) {
   if (rawTime === void 0) {
-    const fallback = typeof timestampSeconds === "number" ? new Date(timestampSeconds * 1e3) : void 0;
+    const fallback = typeof timestampSeconds === "number" ? new Date(timestampSeconds * MILLISECONDS_PER_SECOND) : void 0;
     if (fallback === void 0 || Number.isNaN(fallback.getTime())) {
       throw new MalformedMessageError("Message has no valid time (header cloudEvents:time)");
     }
@@ -366,6 +587,8 @@ function required(attribute, value) {
 }
 
 // src/inbound-decoders.ts
+var MILLISECONDS_PER_SECOND2 = 1e3;
+var { optionalAttribute, requiredAttribute, assertValidType, assertJsonDataContentType } = createCloudEventReaders((reason) => new MalformedMessageError(reason));
 var STRUCTURED_MEDIA_TYPE = "application/cloudevents+json";
 var strictUtf8 = new TextDecoder("utf-8", { fatal: true });
 var SPEC_VERSION2 = "1.0";
@@ -426,18 +649,13 @@ function plainJsonDecoder(options) {
     if (properties.headers?.[SPEC_VERSION_HEADER] !== void 0 || mediaTypeOf(properties.contentType) === STRUCTURED_MEDIA_TYPE) {
       return decodeCloudEvent(message);
     }
-    const plain = {
-      routingKey: message.fields.routingKey,
-      properties,
-      headers: readForeignHeaders(properties),
-      payload: parseJsonBody(message.content)
-    };
-    const type = resolveText(options.type, plain, "type");
+    const plain = plainMessageOf(message);
+    const type = RABBITMQ_EVENTS.text(options.type, { plain, name: "type" });
     if (type === void 0) {
       throw new MalformedMessageError("Message has no event type: the type option found none");
     }
     assertValidType(type, "The event type");
-    const id = resolveText(options.id, plain, "id") ?? nonEmptyText(properties.messageId);
+    const id = RABBITMQ_EVENTS.text(options.id, { plain, name: "id" }) ?? nonEmptyText(properties.messageId);
     if (id === void 0) {
       throw new MalformedMessageError(
         "Message has no id: set the messageId property on the producer or configure the id option"
@@ -446,8 +664,8 @@ function plainJsonDecoder(options) {
     return {
       id,
       type,
-      source: resolveText(options.source, plain, "source") ?? defaultSource(message),
-      key: resolveText(options.key, plain, "key") ?? null,
+      source: RABBITMQ_EVENTS.text(options.source, { plain, name: "source" }) ?? defaultSource(message),
+      key: RABBITMQ_EVENTS.text(options.key, { plain, name: "key" }) ?? null,
       payload: plain.payload,
       headers: plain.headers,
       correlationId: null,
@@ -456,27 +674,35 @@ function plainJsonDecoder(options) {
     };
   };
 }
-function completeDecodedEvent(decoded, message) {
-  if (typeof decoded !== "object" || decoded === null) {
-    throw new MalformedMessageError("The decoder must return an event object synchronously");
-  }
-  if ("then" in decoded) {
-    observeRejection(decoded);
-    throw new MalformedMessageError("The decoder must return an event object synchronously");
-  }
-  const event = decoded;
+function plainMessageOf(message) {
+  const { properties } = message;
   return {
-    id: event.id,
-    type: event.type,
-    source: event.source ?? defaultSource(message),
-    key: event.key ?? null,
-    payload: event.payload,
-    headers: event.headers ?? {},
-    correlationId: event.correlationId ?? null,
-    causationId: event.causationId ?? null,
-    occurredAt: event.occurredAt ?? propertyTimeOrNow(message.properties)
+    routingKey: message.fields.routingKey,
+    properties,
+    headers: readForeignHeaders(properties),
+    payload: parseJsonBody(message.content)
   };
 }
+var RabbitMqDecodedEvents = class extends DecodedEventReader {
+  invalid(reason) {
+    return new MalformedMessageError(reason);
+  }
+  defaultSource(message) {
+    return defaultSource(message);
+  }
+  /** None: AMQP messages carry no ordering key. */
+  defaultKey() {
+    return null;
+  }
+  /** The `timestamp` property, else the time of receipt. */
+  defaultTime(message) {
+    return propertyTimeOrNow(message.properties);
+  }
+};
+var RABBITMQ_EVENTS = new RabbitMqDecodedEvents();
+function completeDecodedEvent(decoded, message) {
+  return RABBITMQ_EVENTS.complete(decoded, message);
+}
 function parseJsonBody(content) {
   let text2;
   try {
@@ -490,47 +716,12 @@ function parseJsonBody(content) {
     throw new MalformedMessageError("Message body is not valid JSON");
   }
 }
-function mediaTypeOf(contentType) {
-  return typeof contentType === "string" ? contentType.split(";")[0].trim().toLowerCase() : void 0;
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function nonEmptyText(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function defaultSource(message) {
   return nonEmptyText(message.properties.appId) ?? message.fields.routingKey;
 }
-function optionalAttribute(body, name) {
-  const value = body[name];
-  if (value !== void 0 && typeof value !== "string") {
-    throw new MalformedMessageError(`Attribute '${name}' must be a string`);
-  }
-  return value;
-}
-function requiredAttribute(body, name) {
-  const value = optionalAttribute(body, name);
-  if (value === void 0 || value.length === 0) {
-    throw new MalformedMessageError(`Attribute '${name}' is missing or empty`);
-  }
-  return value;
-}
-function assertValidType(type, label) {
-  try {
-    assertEventType(type);
-  } catch (error) {
-    throw new MalformedMessageError(
-      `${label} is not a valid event type: ${error.message}`
-    );
-  }
-}
-function assertJsonDataContentType(dataContentType) {
-  const mediaType = mediaTypeOf(dataContentType);
-  if (mediaType !== void 0 && mediaType !== "application/json" && mediaType !== "text/json" && !mediaType.endsWith("+json")) {
-    throw new MalformedMessageError(`datacontenttype must be JSON, received '${dataContentType}'`);
-  }
-}
 function parseTime2(text2) {
   const time = new Date(text2);
   if (!RFC3339_PATTERN.test(text2) || Number.isNaN(time.getTime())) {
@@ -540,7 +731,7 @@ function parseTime2(text2) {
 }
 function propertyTimeOrNow(properties) {
   const { timestamp } = properties;
-  return typeof timestamp === "number" && Number.isFinite(timestamp) ? new Date(timestamp * 1e3) : /* @__PURE__ */ new Date();
+  return typeof timestamp === "number" && Number.isFinite(timestamp) ? new Date(timestamp * MILLISECONDS_PER_SECOND2) : /* @__PURE__ */ new Date();
 }
 function extensionAttributes(body) {
   return Object.fromEntries(
@@ -556,19 +747,6 @@ function readForeignHeaders(properties) {
     )
   );
 }
-function resolveText(option, message, name) {
-  const value = typeof option === "function" ? option(message) : option;
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    observeRejection(value);
-    throw new MalformedMessageError(
-      `The ${name} option returned ${typeof value}, expected a string`
-    );
-  }
-  return value.length === 0 ? void 0 : value;
-}
 function resolveOccurredAt(option, message) {
   const value = option?.(message);
   if (value === void 0) {
@@ -580,14 +758,62 @@ function resolveOccurredAt(option, message) {
   }
   return value;
 }
-function observeRejection(value) {
-  if (typeof value === "object" && value !== null && "then" in value) {
-    Promise.resolve(value).catch(() => void 0);
+
+// src/codecs.ts
+var cloudEventsBinary = Object.freeze({
+  encode: encodeEnvelope,
+  decode: decodeEnvelope
+});
+var cloudEventsStructured = Object.freeze({
+  encode: encodeStructuredEnvelope,
+  decode: decodeCloudEvent
+});
+var MESSAGE_ID_PROPERTY = "message-id-property";
+var DEFAULT_CONTENT_TYPE = "application/json";
+function jsonEnvelope(mapping) {
+  const format = createJsonEnvelopeFormat(mapping, {
+    transportIds: [MESSAGE_ID_PROPERTY],
+    failures: {
+      invalid: (reason) => new MalformedMessageError(reason),
+      unencodable: (reason) => new RabbitMqUnencodableEventError(reason)
+    }
+  });
+  const contentType = mapping.contentType ?? DEFAULT_CONTENT_TYPE;
+  return {
+    encode: (envelope) => {
+      assertJsonPayload(envelope.payload, envelope.id);
+      assertShortString("Event id", envelope.id);
+      const { body, headers } = format.write(envelope);
+      return {
+        content: Buffer.from(JSON.stringify(body), "utf8"),
+        options: {
+          ...messageProperties(envelope),
+          contentType,
+          headers: plainHeaders(envelope, headers)
+        }
+      };
+    },
+    decode: (message) => {
+      const fields = format.read({
+        body: parseJsonBody(message.content),
+        headers: readForeignHeaders(message.properties)
+      });
+      return { ...fields, id: fields.id ?? requireMessageId(message) };
+    }
+  };
+}
+function requireMessageId(message) {
+  const id = nonEmptyText(message.properties.messageId);
+  if (id === void 0) {
+    throw new MalformedMessageError("Message has no id: the messageId property is missing");
   }
+  return id;
 }
 var REDELIVERIES_HEADER = "x-relaybus-redeliveries";
 var FIRST_FAILURE_HEADER = "x-relaybus-first-failure-at";
 var DEAD_LETTER_REASON_HEADER = "x-relaybus-dead-letter-reason";
+var DEAD_LETTER_ERROR_NAME_HEADER = "x-relaybus-dead-letter-error-name";
+var DEAD_LETTER_ERROR_CODE_HEADER = "x-relaybus-dead-letter-error-code";
 var ORIGINAL_ROUTING_KEY_HEADER = "x-relaybus-routing-key";
 var RELAYBUS_STATE_HEADERS = [REDELIVERIES_HEADER, FIRST_FAILURE_HEADER];
 var BROKER_COUNTER_HEADERS = ["x-delivery-count", "x-acquired-count"];
@@ -612,7 +838,7 @@ function buildRetryLadder(policy) {
     delay *= policy.factor;
   }
 }
-function chooseRetryTier(ladder, delayMs, random) {
+function chooseRetryTier(ladder, { delayMs, random }) {
   const upperIndex = ladder.findIndex((tier) => tier >= delayMs);
   if (upperIndex === -1) {
     return ladder.at(-1);
@@ -635,6 +861,8 @@ function copyForRepublish(message, headerChanges) {
   for (const name of [
     ...RELAYBUS_STATE_HEADERS,
     DEAD_LETTER_REASON_HEADER,
+    DEAD_LETTER_ERROR_NAME_HEADER,
+    DEAD_LETTER_ERROR_CODE_HEADER,
     ...BROKER_COUNTER_HEADERS
   ]) {
     delete headers[name];
@@ -664,6 +892,8 @@ function withOriginalRoutingKey(message) {
 }
 
 // src/options.ts
+var DEFAULT_PREFETCH = 50;
+var DEFAULT_DELIVERY_LIMIT = 10;
 var DEFAULT_HANDLER_RETRY = {
   attempts: 3,
   initialDelayMs: 200,
@@ -690,7 +920,15 @@ var DEFAULT_RECONNECT = {
   retryIf: void 0
 };
 function resolveSettings(options) {
-  const exchange = nonEmpty(options.exchange ?? "relaybus", "exchange");
+  const basics = resolveBasics(options);
+  return {
+    ...resolveTopology(options, basics),
+    ...resolveRetries(options, basics),
+    ...resolveRuntime(options, basics)
+  };
+}
+function resolveBasics(options) {
+  const exchange = NonEmptyText.of(options.exchange ?? "relaybus", "exchange");
   const failOnConnectError = options.failOnConnectError ?? true;
   if (!failOnConnectError && options.reconnect === false) {
     throw new ConfigurationError(
@@ -698,39 +936,56 @@ function resolveSettings(options) {
     );
   }
   const ordered = options.ordered ?? false;
-  const prefetch = positiveInteger(options.prefetch ?? (ordered ? 1 : 50), "prefetch");
+  const prefetch = PositiveInteger.of(
+    options.prefetch ?? (ordered ? 1 : DEFAULT_PREFETCH),
+    "prefetch"
+  );
   if (ordered && prefetch !== 1) {
     throw new ConfigurationError(`ordered consumption needs prefetch 1, received ${prefetch}`);
   }
   const redelivery = createRetryPolicy(options.redelivery, DEFAULT_REDELIVERY);
+  return { exchange, failOnConnectError, ordered, prefetch, redelivery };
+}
+function resolveTopology(options, { exchange, prefetch }) {
   return {
-    name: nonEmpty(options.name ?? "rabbitmq", "name"),
+    name: NonEmptyText.of(options.name ?? "rabbitmq", "name"),
     connect: resolveConnect(options),
     exchange,
     prefetch,
-    queuePrefix: nonEmpty(options.queuePrefix ?? "relaybus", "queuePrefix"),
-    consumerGroup: optionalNonEmpty(options.consumerGroup, "consumerGroup"),
-    queue: optionalNonEmpty(options.queue, "queue"),
-    deadLetterExchange: nonEmpty(
+    queuePrefix: NonEmptyText.of(options.queuePrefix ?? "relaybus", "queuePrefix"),
+    consumerGroup: NonEmptyText.optional(options.consumerGroup, "consumerGroup"),
+    queue: NonEmptyText.optional(options.queue, "queue"),
+    deadLetterExchange: NonEmptyText.of(
       options.deadLetterExchange ?? `${exchange}.dead`,
       "deadLetterExchange"
     ),
-    deadLetterQueue: optionalNonEmpty(options.deadLetterQueue, "deadLetterQueue"),
-    deliveryLimit: positiveInteger(options.deliveryLimit ?? 10, "deliveryLimit"),
+    deadLetterQueue: NonEmptyText.optional(options.deadLetterQueue, "deadLetterQueue"),
+    deliveryLimit: PositiveInteger.of(
+      options.deliveryLimit ?? DEFAULT_DELIVERY_LIMIT,
+      "deliveryLimit"
+    )
+  };
+}
+function resolveRetries(options, { ordered, redelivery }) {
+  return {
     handlerRetry: createRetryPolicy(options.handlerRetry, DEFAULT_HANDLER_RETRY),
     redelivery,
     retryLadder: ordered ? [] : buildRetryLadder(redelivery),
-    redeliveryMaxAgeMs: positiveDuration(
+    redeliveryMaxAgeMs: Milliseconds.positive(
       options.redelivery?.maxAge ?? DEFAULT_REDELIVERY_MAX_AGE,
       "redelivery.maxAge"
     ),
-    ordered,
+    ordered
+  };
+}
+function resolveRuntime(options, { failOnConnectError }) {
+  return {
     reconnect: resolveReconnect(options.reconnect),
     failOnConnectError,
     allowUnroutable: options.allowUnroutable ?? false,
-    publishTimeoutMs: positiveDuration(options.publishTimeout ?? "30s", "publishTimeout"),
-    shutdownTimeoutMs: toMilliseconds(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
-    decode: resolveDecode(options.decode),
+    publishTimeoutMs: Milliseconds.positive(options.publishTimeout ?? "30s", "publishTimeout"),
+    shutdownTimeoutMs: Milliseconds.of(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
+    ...resolveCodec(options),
     logger: options.logger ?? console,
     random: options.random ?? Math.random
   };
@@ -746,11 +1001,21 @@ function resolveQueueName(settings) {
   }
   return `${settings.queuePrefix}.${settings.consumerGroup}`;
 }
-function resolveDecode(decode) {
-  if (decode === void 0) {
-    return decodeEnvelope;
+function resolveCodec({
+  codec,
+  decode
+}) {
+  if (decode !== void 0 && codec !== void 0) {
+    throw new ConfigurationError("Give 'codec' or the deprecated 'decode', not both");
+  }
+  const chosen = decode === void 0 ? codec ?? cloudEventsBinary : { encode: encodeEnvelope, decode };
+  if (chosen === cloudEventsBinary) {
+    return { encode: encodeEnvelope, decode: decodeEnvelope };
   }
-  return (message) => completeDecodedEvent(decode(message), message);
+  return {
+    encode: chosen.encode,
+    decode: (message) => completeDecodedEvent(chosen.decode(message), message)
+  };
 }
 function resolveConnect(options) {
   const { url, connect } = options;
@@ -760,9 +1025,10 @@ function resolveConnect(options) {
   if (connect !== void 0) {
     return connect;
   }
-  return async () => {
+  return async ({ signal }) => {
     const amqplib = await import('amqplib');
-    return amqplib.connect(url);
+    const socketOptions = { signal };
+    return amqplib.connect(url, socketOptions);
   };
 }
 function resolveReconnect(reconnect) {
@@ -771,28 +1037,6 @@ function resolveReconnect(reconnect) {
   }
   return createRetryPolicy({ ...reconnect, attempts: 1 }, DEFAULT_RECONNECT);
 }
-function nonEmpty(value, name) {
-  if (value.length === 0) {
-    throw new ConfigurationError(`${name} must not be empty`);
-  }
-  return value;
-}
-function optionalNonEmpty(value, name) {
-  return value === void 0 ? void 0 : nonEmpty(value, name);
-}
-function positiveInteger(value, name) {
-  if (!Number.isInteger(value) || value < 1) {
-    throw new ConfigurationError(`${name} must be a positive integer, received ${value}`);
-  }
-  return value;
-}
-function positiveDuration(value, name) {
-  const milliseconds = toMilliseconds(value, name);
-  if (milliseconds === 0) {
-    throw new ConfigurationError(`${name} must be greater than zero`);
-  }
-  return milliseconds;
-}
 
 // src/topology.ts
 function retryQueueName(queue, delayMs) {
@@ -934,74 +1178,115 @@ var QueueConsumer = class {
     this.#inFlight.add(task);
   }
   async #process(channel, message) {
-    const { queue, handlerRetry } = this.#settings;
-    let envelope;
-    try {
-      envelope = this.#settings.decode(withOriginalRoutingKey(message));
-    } catch (error) {
-      this.#settings.logger.error(
-        `[QueueConsumer](process) Dead-lettering malformed message | queue=${queue} routingKey=${message.fields.routingKey} error=${toErrorInfo(error).message}`
-      );
-      await this.#deadLetter(channel, message, "malformed message");
+    const decoded = await this.#decodeOrDeadLetter(channel, message);
+    if (decoded === void 0) {
       return;
     }
-    let redeliveries = readCounterHeader(message, REDELIVERIES_HEADER) ?? 0;
-    let firstFailureAt = readCounterHeader(message, FIRST_FAILURE_HEADER);
+    const { envelope } = decoded;
+    const delivery = {
+      channel,
+      message,
+      envelope,
+      redeliveries: readCounterHeader(message, REDELIVERIES_HEADER) ?? 0,
+      firstFailureAt: readCounterHeader(message, FIRST_FAILURE_HEADER)
+    };
     for (let attempt = 1; ; attempt += 1) {
       try {
-        await this.#settings.onMessage(envelope);
-        this.#settle(channel, message, "ack");
+        await this.#settings.onMessage(envelope, { destination: message.fields.routingKey });
+        this.#settle(channel, { message, settlement: "ack" });
         return;
       } catch (error) {
-        const failure = `queue=${queue} eventId=${envelope.id} attempt=${attempt} error=${toErrorInfo(error).message}`;
-        if (!isRetryableError(handlerRetry, error)) {
-          this.#settings.logger.error(
-            `[QueueConsumer](process) Dead-lettering message the handler cannot process | ${failure}`
-          );
-          await this.#deadLetter(channel, message, "non-retryable handler error");
-          return;
-        }
-        if (attempt < handlerRetry.attempts) {
-          const delayMs2 = computeRetryDelay(handlerRetry, attempt, this.#settings.random);
-          this.#settings.logger.warn(
-            `[QueueConsumer](process) Handler failed, retrying | ${failure} delayMs=${delayMs2}`
-          );
-          if (await this.#interrupted(delayMs2)) {
-            this.#settle(channel, message, "requeue");
-            return;
-          }
-          continue;
-        }
-        redeliveries += 1;
-        const now = Date.now();
-        firstFailureAt ??= now;
-        const delayMs = this.#redeliveryDelay(redeliveries);
-        if (now + delayMs - firstFailureAt > this.#settings.redeliveryMaxAgeMs) {
-          this.#settings.logger.error(
-            `[QueueConsumer](process) Dead-lettering message that kept failing | ${failure} redeliveries=${redeliveries - 1} failingForMs=${now - firstFailureAt} maxAgeMs=${this.#settings.redeliveryMaxAgeMs}`
-          );
-          await this.#deadLetter(channel, message, "redelivery window exhausted");
-          return;
-        }
-        this.#settings.logger.warn(
-          `[QueueConsumer](process) Handler attempts spent, retrying later | ${failure} redeliveries=${redeliveries} delayMs=${delayMs}`
-        );
-        if (!this.#settings.ordered) {
-          await this.#redeliverLater(channel, message, delayMs, redeliveries, firstFailureAt);
-          return;
-        }
-        if (await this.#interrupted(delayMs)) {
-          this.#settle(channel, message, "requeue");
+        if (await this.#afterFailure(delivery, { attempt, error }) === "settled") {
           return;
         }
       }
     }
   }
+  /** The event of `message`, or undefined after dead-lettering a message that is not one. */
+  async #decodeOrDeadLetter(channel, message) {
+    try {
+      return { envelope: this.#settings.decode(withOriginalRoutingKey(message)) };
+    } catch (error) {
+      this.#settings.logger.error(
+        `[QueueConsumer](decodeOrDeadLetter) Dead-lettering malformed message | queue=${this.#settings.queue} routingKey=${message.fields.routingKey} ${describeError(error)}`
+      );
+      this.#settings.onInvalidMessage?.({ destination: message.fields.routingKey, error });
+      await this.#deadLetter(channel, { message, reason: "malformed message", error });
+      return void 0;
+    }
+  }
+  /**
+   * Decides what follows a failed attempt: dead-letter a non-retryable error, retry on the same
+   * delivery while local attempts remain, else redeliver later. `retry` runs the handler again.
+   */
+  async #afterFailure(delivery, { attempt, error }) {
+    const { channel, message, envelope } = delivery;
+    const { queue, handlerRetry } = this.#settings;
+    const failure = `queue=${queue} eventId=${envelope.id} attempt=${attempt} ${describeError(error)}`;
+    if (!isRetryableError(handlerRetry, error)) {
+      this.#settings.logger.error(
+        `[QueueConsumer](afterFailure) Dead-lettering message the handler cannot process | ${failure}`
+      );
+      await this.#deadLetter(channel, {
+        message,
+        reason: "non-retryable handler error",
+        error
+      });
+      return "settled";
+    }
+    if (attempt < handlerRetry.attempts) {
+      const delayMs = computeRetryDelay(handlerRetry, attempt, this.#settings.random);
+      this.#settings.logger.warn(
+        `[QueueConsumer](afterFailure) Handler failed, retrying | ${failure} delayMs=${delayMs}`
+      );
+      return this.#waitOrRequeue(delivery, delayMs);
+    }
+    return this.#afterSpentAttempts(delivery, { failure, error });
+  }
+  /**
+   * The local attempts are spent: dead-letter a message that kept failing past `redeliveryMaxAgeMs`,
+   * else park it in a retry queue, or, when ordered, wait and retry it in place.
+   */
+  async #afterSpentAttempts(delivery, { failure, error }) {
+    const { channel, message } = delivery;
+    delivery.redeliveries += 1;
+    const now = Date.now();
+    delivery.firstFailureAt ??= now;
+    const { redeliveries, firstFailureAt } = delivery;
+    const delayMs = this.#redeliveryDelay(redeliveries);
+    if (now + delayMs - firstFailureAt > this.#settings.redeliveryMaxAgeMs) {
+      this.#settings.logger.error(
+        `[QueueConsumer](afterSpentAttempts) Dead-lettering message that kept failing | ${failure} redeliveries=${redeliveries - 1} failingForMs=${now - firstFailureAt} maxAgeMs=${this.#settings.redeliveryMaxAgeMs}`
+      );
+      await this.#deadLetter(channel, {
+        message,
+        reason: "redelivery window exhausted",
+        error
+      });
+      return "settled";
+    }
+    this.#settings.logger.warn(
+      `[QueueConsumer](afterSpentAttempts) Handler attempts spent, retrying later | ${failure} redeliveries=${redeliveries} delayMs=${delayMs}`
+    );
+    if (!this.#settings.ordered) {
+      await this.#redeliverLater(channel, { message, delayMs, redeliveries, firstFailureAt });
+      return "settled";
+    }
+    return this.#waitOrRequeue(delivery, delayMs);
+  }
+  /** Waits `delayMs` before the next attempt; requeues instead when the consumer stops meanwhile. */
+  async #waitOrRequeue(delivery, delayMs) {
+    if (await this.#interrupted(delayMs)) {
+      this.#settle(delivery.channel, { message: delivery.message, settlement: "requeue" });
+      return "settled";
+    }
+    return "retry";
+  }
   /** The backoff before the next delayed redelivery: a retry queue's TTL, or an exact wait when ordered. */
   #redeliveryDelay(redeliveries) {
     const { redelivery, retryLadder, ordered, random } = this.#settings;
     const delayMs = computeRetryDelay(redelivery, redeliveries, random);
-    return ordered ? delayMs : chooseRetryTier(retryLadder, delayMs, random);
+    return ordered ? delayMs : chooseRetryTier(retryLadder, { delayMs, random });
   }
   /** Sleeps; true when the consumer is stopping, so the caller must give the message back. */
   async #interrupted(delayMs) {
@@ -1014,7 +1299,8 @@ var QueueConsumer = class {
    * the original is requeued after the same delay, so it is neither lost nor
    * hot-looped.
    */
-  async #redeliverLater(channel, message, delayMs, redeliveries, firstFailureAt) {
+  async #redeliverLater(channel, input) {
+    const { message, delayMs, redeliveries, firstFailureAt } = input;
     const { content, options } = copyForRepublish(message, {
       [REDELIVERIES_HEADER]: String(redeliveries),
       [FIRST_FAILURE_HEADER]: String(firstFailureAt),
@@ -1022,20 +1308,18 @@ var QueueConsumer = class {
     });
     try {
       await this.#settings.republish(
-        "",
-        retryQueueName(this.#settings.queue, delayMs),
-        content,
-        options
+        { exchange: "", routingKey: retryQueueName(this.#settings.queue, delayMs) },
+        { content, options }
       );
     } catch (error) {
       this.#settings.logger.warn(
         `[QueueConsumer](redeliverLater) Could not park the message in the retry queue, requeueing it | queue=${this.#settings.queue} delayMs=${delayMs} error=${toErrorInfo(error).message}`
       );
       await this.#interrupted(delayMs);
-      this.#settle(channel, message, "requeue");
+      this.#settle(channel, { message, settlement: "requeue" });
       return;
     }
-    this.#settle(channel, message, "ack");
+    this.#settle(channel, { message, settlement: "ack" });
   }
   /**
    * Moves the message to the dead-letter queue through a confirmed copy that
@@ -1043,27 +1327,29 @@ var QueueConsumer = class {
    * message is rejected without requeue, which makes the broker dead-letter it
    * (at-least-once), so it still ends up in the dead-letter queue.
    */
-  async #deadLetter(channel, message, reason) {
+  async #deadLetter(channel, input) {
+    const { message, reason, error } = input;
+    const { name, code } = toErrorInfo(error);
     const { content, options } = copyForRepublish(message, {
-      [DEAD_LETTER_REASON_HEADER]: reason
+      [DEAD_LETTER_REASON_HEADER]: reason,
+      [DEAD_LETTER_ERROR_NAME_HEADER]: name,
+      ...code === void 0 ? {} : { [DEAD_LETTER_ERROR_CODE_HEADER]: code }
     });
     try {
       await this.#settings.republish(
-        this.#settings.deadLetterExchange,
-        this.#settings.queue,
-        content,
-        options
+        { exchange: this.#settings.deadLetterExchange, routingKey: this.#settings.queue },
+        { content, options }
       );
-    } catch (error) {
+    } catch (error2) {
       this.#settings.logger.warn(
-        `[QueueConsumer](deadLetter) Could not publish to the dead-letter exchange, leaving it to the broker | queue=${this.#settings.queue} error=${toErrorInfo(error).message}`
+        `[QueueConsumer](deadLetter) Could not publish to the dead-letter exchange, leaving it to the broker | queue=${this.#settings.queue} error=${toErrorInfo(error2).message}`
       );
-      this.#settle(channel, message, "dead-letter");
+      this.#settle(channel, { message, settlement: "dead-letter" });
       return;
     }
-    this.#settle(channel, message, "ack");
+    this.#settle(channel, { message, settlement: "ack" });
   }
-  #settle(channel, message, settlement) {
+  #settle(channel, { message, settlement }) {
     try {
       if (settlement === "ack") {
         channel.ack(message);
@@ -1077,6 +1363,10 @@ var QueueConsumer = class {
     }
   }
 };
+function describeError(error) {
+  const { message, name, code } = toErrorInfo(error);
+  return `error=${message} errorName=${name}${code === void 0 ? "" : ` code=${code}`}`;
+}
 
 // src/serial-queue.ts
 var SerialQueue = class {
@@ -1089,19 +1379,22 @@ var SerialQueue = class {
 };
 
 // src/rabbitmq-transport.ts
-var NACK_MESSAGE = "message nacked";
-var RabbitMqTransport = class {
+var RabbitMqTransport = class extends SubscribingTransport {
   name;
+  system = "rabbitmq";
   #settings;
   #supervisor;
+  #publishing;
   /** Serializes topology work so a subscription never races a reconnect. */
   #topologyWork = new SerialQueue();
   #live;
   #subscription;
-  #closed = false;
+  #closing;
   constructor(options) {
+    super();
     this.#settings = resolveSettings(options);
     this.name = this.#settings.name;
+    this.#publishing = new ConfirmedPublishing(this.name, this.#settings.publishTimeoutMs);
     this.#supervisor = new ConnectionSupervisor({
       connect: this.#settings.connect,
       reconnect: this.#settings.reconnect,
@@ -1138,62 +1431,17 @@ var RabbitMqTransport = class {
    * @throws {RabbitMqUnavailableError} not connected, channel lost, or confirm timed out
    * @throws {RabbitMqPublishRejectedError} the broker nacked the message
    * @throws {UnroutableMessageError} no queue is bound to `destination` (unless `allowUnroutable`)
+   * @throws whatever the `codec`'s `encode` throws, such as {@link RabbitMqUnencodableEventError}
    */
   async publish(envelope, destination) {
     assertShortString("Destination (routing key)", destination);
-    const { content, options } = encodeEnvelope(envelope);
-    await this.#publishConfirmed(
-      this.#settings.exchange,
-      destination,
+    const { content, options } = this.#settings.encode(envelope);
+    await this.#publishing.publish(this.#live?.publisher, {
+      exchange: this.#settings.exchange,
+      routingKey: destination,
       content,
       options,
-      !this.#settings.allowUnroutable
-    );
-  }
-  async #publishConfirmed(exchange, routingKey, content, options, mandatory) {
-    const publisher = this.#live?.publisher;
-    const eventId = options.messageId ?? "unknown";
-    if (publisher === void 0) {
-      throw new RabbitMqUnavailableError(
-        `[RabbitMqTransport](publish) Not connected to the broker | transport=${this.name} destination=${routingKey}`
-      );
-    }
-    const returnKey = unroutableKey(options.messageId, routingKey);
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(
-          new RabbitMqUnavailableError(
-            `[RabbitMqTransport](publish) No broker confirm within ${this.#settings.publishTimeoutMs}ms | transport=${this.name} eventId=${eventId} destination=${routingKey}`
-          )
-        );
-      }, this.#settings.publishTimeoutMs);
-      const onConfirm = (error) => {
-        clearTimeout(timer);
-        const returned = takeUnroutable(publisher.unroutable, returnKey);
-        if (error) {
-          reject(this.#toPublishError(error, eventId, routingKey));
-        } else if (returned) {
-          reject(
-            new UnroutableMessageError(
-              `[RabbitMqTransport](publish) No queue is bound to the routing key | transport=${this.name} eventId=${eventId} destination=${routingKey}`
-            )
-          );
-        } else {
-          resolve();
-        }
-      };
-      try {
-        publisher.channel.publish(
-          exchange,
-          routingKey,
-          content,
-          { ...options, mandatory },
-          onConfirm
-        );
-      } catch (error) {
-        clearTimeout(timer);
-        reject(this.#toPublishError(error, eventId, routingKey));
-      }
+      mandatory: !this.#settings.allowUnroutable
     });
   }
   /**
@@ -1201,7 +1449,11 @@ var RabbitMqTransport = class {
    * to `onMessage`. Call it once per transport; give each subscription its own
    * transport instance, with its own `name` and `consumerGroup`.
    */
-  async subscribe(destinations, onMessage) {
+  async openSubscription({
+    destinations,
+    onMessage,
+    hooks
+  }) {
     if (this.#subscription !== void 0) {
       throw new ConfigurationError(
         `Transport '${this.name}' already has a subscription; create another transport for another consumer group`
@@ -1212,33 +1464,8 @@ var RabbitMqTransport = class {
     }
     const queue = resolveQueueName(this.#settings);
     const subscription = {
-      topology: {
-        exchange: this.#settings.exchange,
-        queue,
-        deadLetterExchange: this.#settings.deadLetterExchange,
-        deadLetterQueue: this.#settings.deadLetterQueue ?? `${queue}.dead`,
-        deliveryLimit: this.#settings.deliveryLimit,
-        ordered: this.#settings.ordered,
-        retryDelaysMs: this.#settings.retryLadder,
-        destinations
-      },
-      consumer: new QueueConsumer({
-        queue,
-        prefetch: this.#settings.prefetch,
-        handlerRetry: this.#settings.handlerRetry,
-        redelivery: this.#settings.redelivery,
-        retryLadder: this.#settings.retryLadder,
-        redeliveryMaxAgeMs: this.#settings.redeliveryMaxAgeMs,
-        ordered: this.#settings.ordered,
-        deadLetterExchange: this.#settings.deadLetterExchange,
-        republish: (exchange, routingKey, content, options) => this.#publishConfirmed(exchange, routingKey, content, options, true),
-        shutdownTimeoutMs: this.#settings.shutdownTimeoutMs,
-        onMessage,
-        decode: this.#settings.decode,
-        onConsumerLost: (reason) => this.#supervisor.recover(reason),
-        logger: this.#settings.logger,
-        random: this.#settings.random
-      })
+      topology: this.#topologyOf(queue, destinations),
+      consumer: this.#createConsumer(queue, { onMessage, hooks })
     };
     await this.#topologyWork.run(async () => {
       this.#subscription = subscription;
@@ -1247,24 +1474,70 @@ var RabbitMqTransport = class {
       }
     });
   }
+  #topologyOf(queue, destinations) {
+    return {
+      exchange: this.#settings.exchange,
+      queue,
+      deadLetterExchange: this.#settings.deadLetterExchange,
+      deadLetterQueue: this.#settings.deadLetterQueue ?? `${queue}.dead`,
+      deliveryLimit: this.#settings.deliveryLimit,
+      ordered: this.#settings.ordered,
+      retryDelaysMs: this.#settings.retryLadder,
+      destinations
+    };
+  }
+  #createConsumer(queue, { onMessage, hooks }) {
+    return new QueueConsumer({
+      queue,
+      prefetch: this.#settings.prefetch,
+      handlerRetry: this.#settings.handlerRetry,
+      redelivery: this.#settings.redelivery,
+      retryLadder: this.#settings.retryLadder,
+      redeliveryMaxAgeMs: this.#settings.redeliveryMaxAgeMs,
+      ordered: this.#settings.ordered,
+      deadLetterExchange: this.#settings.deadLetterExchange,
+      republish: ({ exchange, routingKey }, { content, options }) => this.#publishing.publish(this.#live?.publisher, {
+        exchange,
+        routingKey,
+        content,
+        options,
+        mandatory: true
+      }),
+      shutdownTimeoutMs: this.#settings.shutdownTimeoutMs,
+      onMessage,
+      ...hooks === void 0 ? {} : { onInvalidMessage: hooks.onInvalidMessage },
+      decode: this.#settings.decode,
+      onConsumerLost: (reason) => this.#supervisor.recover(reason),
+      logger: this.#settings.logger,
+      random: this.#settings.random
+    });
+  }
   /**
    * Stops consuming, waits up to `shutdownTimeout` for running handlers
    * (messages still being retried go back to the queue), then closes the
-   * channels and the connection.
+   * channels and the connection. Once `options.signal` aborts (the bus shutdown deadline passed),
+   * the connection's socket is destroyed instead of waiting for the broker.
    */
-  async close() {
-    if (this.#closed) {
-      return;
+  async close(options = {}) {
+    const { signal } = options;
+    const force = () => this.#supervisor.forceClose();
+    if (signal?.aborted === true) {
+      force();
+    }
+    signal?.addEventListener("abort", force, { once: true });
+    try {
+      this.#closing ??= this.#supervisor.close(
+        () => this.#topologyWork.run(async () => {
+          const live = this.#live;
+          this.#live = void 0;
+          await this.#subscription?.consumer.stop();
+          await live?.publisher.channel.close().catch(() => void 0);
+        })
+      );
+      await this.#closing;
+    } finally {
+      signal?.removeEventListener("abort", force);
     }
-    this.#closed = true;
-    await this.#supervisor.close(
-      () => this.#topologyWork.run(async () => {
-        const live = this.#live;
-        this.#live = void 0;
-        await this.#subscription?.consumer.stop();
-        await live?.publisher.channel.close().catch(() => void 0);
-      })
-    );
   }
   async #establishChannels(connection) {
     await this.#topologyWork.run(async () => {
@@ -1308,64 +1581,8 @@ var RabbitMqTransport = class {
     this.#live = void 0;
     this.#subscription?.consumer.detach();
   }
-  #toPublishError(error, eventId, destination) {
-    const { message } = toErrorInfo(error);
-    const detail = `transport=${this.name} eventId=${eventId} destination=${destination} error=${message}`;
-    return message === NACK_MESSAGE ? new RabbitMqPublishRejectedError(
-      `[RabbitMqTransport](publish) Broker nacked the message | ${detail}`,
-      { cause: error }
-    ) : new RabbitMqUnavailableError(`[RabbitMqTransport](publish) Publish failed | ${detail}`, {
-      cause: error
-    });
-  }
 };
-function unroutableKey(messageId, routingKey) {
-  return `${String(messageId)}
-${routingKey}`;
-}
-function recordUnroutable(unroutable, key) {
-  unroutable.set(key, (unroutable.get(key) ?? 0) + 1);
-}
-function takeUnroutable(unroutable, key) {
-  const count = unroutable.get(key);
-  if (count === void 0) {
-    return false;
-  }
-  if (count === 1) {
-    unroutable.delete(key);
-  } else {
-    unroutable.set(key, count - 1);
-  }
-  return true;
-}
-function fromHeader(name) {
-  if (name.length === 0) {
-    throw new ConfigurationError("fromHeader needs a header name");
-  }
-  return (message) => Object.hasOwn(message.headers, name) ? message.headers[name] : void 0;
-}
-function fromPayloadField(path) {
-  const segments = path.split(".");
-  if (segments.some((segment) => segment.length === 0)) {
-    throw new ConfigurationError(
-      `fromPayloadField needs a dotted path of non-empty names, received '${path}'`
-    );
-  }
-  return (message) => {
-    let value = message.payload;
-    for (const segment of segments) {
-      if (typeof value !== "object" || value === null || !Object.hasOwn(value, segment)) {
-        return void 0;
-      }
-      value = value[segment];
-    }
-    if (typeof value === "string") {
-      return value;
-    }
-    return Number.isSafeInteger(value) ? String(value) : void 0;
-  };
-}
 
-export { AmqpLimitExceededError, MalformedMessageError, RabbitMqPublishRejectedError, RabbitMqTransport, RabbitMqUnavailableError, UnroutableMessageError, UnserializablePayloadError, decodeCloudEvent, fromHeader, fromPayloadField, plainJsonDecoder };
+export { AmqpLimitExceededError, MalformedMessageError, RabbitMqPublishRejectedError, RabbitMqTransport, RabbitMqUnavailableError, RabbitMqUnencodableEventError, UnroutableMessageError, UnserializablePayloadError, cloudEventsBinary, cloudEventsStructured, decodeCloudEvent, jsonEnvelope, plainJsonDecoder };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map