@relaybus/rabbitmq 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -1,35 +1,48 @@
 'use strict';
 
 var core = require('@relaybus/core');
+var internal = require('@relaybus/core/internal');
 
 // src/errors.ts
 var RabbitMqUnavailableError = class extends core.RelayBusError {
+  name = "RabbitMqUnavailableError";
+  code = "RELAYBUS_RABBITMQ_UNAVAILABLE";
 };
 var RabbitMqPublishRejectedError = class extends core.RelayBusError {
+  name = "RabbitMqPublishRejectedError";
+  code = "RELAYBUS_RABBITMQ_PUBLISH_REJECTED";
 };
 var UnroutableMessageError = class extends core.RelayBusError {
+  name = "UnroutableMessageError";
+  code = "RELAYBUS_RABBITMQ_UNROUTABLE_MESSAGE";
 };
 var MalformedMessageError = class extends core.RelayBusError {
+  name = "MalformedMessageError";
+  code = "RELAYBUS_RABBITMQ_MALFORMED_MESSAGE";
 };
 var UnserializablePayloadError = class extends core.NonRetryableError {
   name = "UnserializablePayloadError";
+  code = "RELAYBUS_RABBITMQ_UNSERIALIZABLE_PAYLOAD";
 };
 var AmqpLimitExceededError = class extends core.NonRetryableError {
   name = "AmqpLimitExceededError";
+  code = "RELAYBUS_RABBITMQ_AMQP_LIMIT_EXCEEDED";
+};
+var RabbitMqUnencodableEventError = class extends core.NonRetryableError {
+  name = "RabbitMqUnencodableEventError";
+  code = "RELAYBUS_RABBITMQ_UNENCODABLE_EVENT";
 };
-
-// src/abortable-sleep.ts
 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 = internal.schedule(core.systemClock, { run: finish, delayMs: milliseconds });
     signal.addEventListener("abort", finish, { once: true });
   });
 }
@@ -38,7 +51,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;
@@ -85,7 +108,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
@@ -94,23 +117,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");
     });
@@ -133,7 +187,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) {
@@ -160,7 +214,7 @@ var ConnectionSupervisor = class {
     for (let attempt = 1; !this.#closed; attempt += 1) {
       const delayMs = core.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) {
@@ -169,20 +223,512 @@ 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=${core.toErrorInfo(error).message}`
+          `[ConnectionSupervisor](reconnectUntilConnected) Attempt failed | attempt=${attempt} error=${core.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, { path: "$", ancestors: /* @__PURE__ */ new Set(), 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, reason: `is ${value}, which JSON turns into null` });
+      }
+      return;
+    case "object":
+      if (value !== null) {
+        visitObject(value, { path, ancestors, eventId });
+      }
+      return;
+    default:
+      throw refuse(eventId, { path, reason: `is ${typeof value}, which JSON cannot represent` });
+  }
+}
+function visitObject(value, {
+  path,
+  ancestors,
+  eventId
+}) {
+  if (ancestors.has(value)) {
+    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: `${path}[${index}]`,
+          reason: "is an array hole, which JSON turns into null"
+        });
+      }
+      visit(value[index], { path: `${path}[${index}]`, ancestors, eventId });
+    }
+  } else {
+    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
+      });
+    }
+  }
+  ancestors.delete(value);
+}
+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) {
+  assertJsonPayload(envelope.payload, envelope.id);
+  assertShortString("Event id", envelope.id);
+  const headers = {
+    [`${ATTRIBUTE_PREFIX}specversion`]: SPEC_VERSION,
+    [`${ATTRIBUTE_PREFIX}id`]: envelope.id,
+    [`${ATTRIBUTE_PREFIX}type`]: envelope.type,
+    [`${ATTRIBUTE_PREFIX}source`]: envelope.source,
+    [`${ATTRIBUTE_PREFIX}time`]: envelope.occurredAt.toISOString(),
+    [`${ATTRIBUTE_PREFIX}datacontenttype`]: JSON_CONTENT_TYPE
+  };
+  if (envelope.key !== null) {
+    headers[`${ATTRIBUTE_PREFIX}subject`] = envelope.key;
+  }
+  if (envelope.causationId !== null) {
+    headers[`${ATTRIBUTE_PREFIX}causationid`] = envelope.causationId;
+  }
+  if (envelope.correlationId !== null) {
+    headers[`${ATTRIBUTE_PREFIX}correlationid`] = envelope.correlationId;
+  }
+  for (const [name, value] of Object.entries(envelope.headers)) {
+    assertShortString(
+      `Header name '${EVENT_HEADER_PREFIX}${name}'`,
+      `${EVENT_HEADER_PREFIX}${name}`
+    );
+    headers[`${EVENT_HEADER_PREFIX}${name}`] = value;
+  }
+  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 encodeStructuredEnvelope(envelope) {
+  assertJsonPayload(envelope.payload, envelope.id);
+  assertShortString("Event id", envelope.id);
+  const document = internal.writeStructuredCloudEvent(envelope, {
+    time: envelope.occurredAt.toISOString(),
+    data: JSON.stringify(envelope.payload)
+  });
+  return {
+    content: Buffer.from(document, "utf8"),
+    options: {
+      ...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) {
+    throw new AmqpLimitExceededError(
+      `${label} is ${bytes} bytes, above the AMQP limit of ${SHORT_STRING_LIMIT_BYTES} bytes`
+    );
+  }
+}
+function mirror(name, value) {
+  return Buffer.byteLength(value, "utf8") > SHORT_STRING_LIMIT_BYTES ? {} : { [name]: value };
+}
+function decodeEnvelope(message) {
+  const { properties } = message;
+  const attributes = properties.headers ?? {};
+  if (attributes[`${ATTRIBUTE_PREFIX}specversion`] !== SPEC_VERSION) {
+    throw new MalformedMessageError(
+      `Message is not a CloudEvents ${SPEC_VERSION} event (header ${ATTRIBUTE_PREFIX}specversion)`
+    );
+  }
+  return {
+    id: required("id", text(attributes[`${ATTRIBUTE_PREFIX}id`]) ?? text(properties.messageId)),
+    type: required("type", text(attributes[`${ATTRIBUTE_PREFIX}type`]) ?? text(properties.type)),
+    source: required(
+      "source",
+      text(attributes[`${ATTRIBUTE_PREFIX}source`]) ?? text(properties.appId)
+    ),
+    key: text(attributes[`${ATTRIBUTE_PREFIX}subject`]) ?? null,
+    payload: parsePayload(message.content),
+    headers: extractEventHeaders(attributes),
+    correlationId: text(attributes[`${ATTRIBUTE_PREFIX}correlationid`]) ?? text(properties.correlationId) ?? null,
+    causationId: text(attributes[`${ATTRIBUTE_PREFIX}causationid`]) ?? null,
+    occurredAt: parseTime(attributes[`${ATTRIBUTE_PREFIX}time`], properties.timestamp)
+  };
+}
+function extractEventHeaders(attributes) {
+  const headers = {};
+  for (const [name, value] of Object.entries(attributes)) {
+    if (name.startsWith(EVENT_HEADER_PREFIX) && typeof value === "string") {
+      Object.defineProperty(headers, name.slice(EVENT_HEADER_PREFIX.length), {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  return headers;
+}
+function parsePayload(content) {
+  try {
+    return JSON.parse(content.toString("utf8"));
+  } catch {
+    throw new MalformedMessageError("Message body is not valid JSON");
+  }
+}
+function parseTime(rawTime, timestampSeconds) {
+  if (rawTime === 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)");
+    }
+    return fallback;
+  }
+  const occurredAt = typeof rawTime === "string" && RFC3339_PATTERN.test(rawTime) ? new Date(rawTime) : void 0;
+  if (occurredAt === void 0 || Number.isNaN(occurredAt.getTime())) {
+    throw new MalformedMessageError(
+      "Message time (header cloudEvents:time) is not an RFC 3339 timestamp"
+    );
+  }
+  return occurredAt;
+}
+function text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function required(attribute, value) {
+  if (value === void 0 || value.length === 0) {
+    throw new MalformedMessageError(
+      `Message has no ${attribute} (header ${ATTRIBUTE_PREFIX}${attribute})`
+    );
+  }
+  return value;
+}
+
+// src/inbound-decoders.ts
+var MILLISECONDS_PER_SECOND2 = 1e3;
+var { optionalAttribute, requiredAttribute, assertValidType, assertJsonDataContentType } = internal.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";
+var SPEC_VERSION_HEADER = "cloudEvents:specversion";
+var INTERNAL_HEADER_PREFIXES = ["x-relaybus-", "x-first-death-", "x-last-death-"];
+var STRUCTURED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "specversion",
+  "id",
+  "type",
+  "source",
+  "time",
+  "subject",
+  "datacontenttype",
+  "dataschema",
+  "data",
+  "data_base64",
+  "correlationid",
+  "causationid"
+]);
+function decodeCloudEvent(message) {
+  if (internal.mediaTypeOf(message.properties.contentType) !== STRUCTURED_MEDIA_TYPE) {
+    return decodeEnvelope(message);
+  }
+  const body = parseJsonBody(message.content);
+  if (!internal.isJsonObject(body)) {
+    throw new MalformedMessageError("A structured CloudEvent must be a JSON object");
+  }
+  if (body["specversion"] !== SPEC_VERSION2) {
+    throw new MalformedMessageError(`specversion must be '${SPEC_VERSION2}'`);
+  }
+  const type = requiredAttribute(body, "type");
+  assertValidType(type, "type");
+  assertJsonDataContentType(optionalAttribute(body, "datacontenttype"));
+  if (Object.hasOwn(body, "data_base64")) {
+    throw new MalformedMessageError(
+      "data_base64 is not supported: relaybus payloads are JSON, send them as data"
+    );
+  }
+  const time = optionalAttribute(body, "time");
+  return {
+    id: requiredAttribute(body, "id"),
+    type,
+    source: requiredAttribute(body, "source"),
+    key: optionalAttribute(body, "subject") ?? null,
+    payload: Object.hasOwn(body, "data") ? body["data"] : null,
+    headers: { ...readForeignHeaders(message.properties), ...extensionAttributes(body) },
+    correlationId: optionalAttribute(body, "correlationid") ?? null,
+    causationId: optionalAttribute(body, "causationid") ?? null,
+    occurredAt: time === void 0 ? propertyTimeOrNow(message.properties) : parseTime2(time)
+  };
+}
+function plainJsonDecoder(options) {
+  if (typeof options.type === "string") {
+    core.assertEventType(options.type);
+  }
+  return (message) => {
+    const { properties } = message;
+    if (properties.headers?.[SPEC_VERSION_HEADER] !== void 0 || internal.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, { message: 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, { message: 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"
+      );
+    }
+    return {
+      id,
+      type,
+      source: resolveText(options.source, { message: plain, name: "source" }) ?? defaultSource(message),
+      key: resolveText(options.key, { message: plain, name: "key" }) ?? null,
+      payload: plain.payload,
+      headers: plain.headers,
+      correlationId: null,
+      causationId: null,
+      occurredAt: resolveOccurredAt(options.occurredAt, plain)
+    };
+  };
+}
+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;
+  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)
+  };
+}
+function parseJsonBody(content) {
+  let text2;
+  try {
+    text2 = strictUtf8.decode(content);
+  } catch {
+    throw new MalformedMessageError("Message body is not valid UTF-8");
+  }
+  try {
+    return JSON.parse(text2);
+  } catch {
+    throw new MalformedMessageError("Message body is not valid JSON");
+  }
+}
+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 parseTime2(text2) {
+  const time = new Date(text2);
+  if (!RFC3339_PATTERN.test(text2) || Number.isNaN(time.getTime())) {
+    throw new MalformedMessageError(`time is not an RFC 3339 timestamp: '${text2}'`);
+  }
+  return time;
+}
+function propertyTimeOrNow(properties) {
+  const { timestamp } = properties;
+  return typeof timestamp === "number" && Number.isFinite(timestamp) ? new Date(timestamp * MILLISECONDS_PER_SECOND2) : /* @__PURE__ */ new Date();
+}
+function extensionAttributes(body) {
+  return Object.fromEntries(
+    Object.entries(body).filter(
+      (entry) => !STRUCTURED_ATTRIBUTES.has(entry[0]) && typeof entry[1] === "string"
+    )
+  );
+}
+function readForeignHeaders(properties) {
+  return Object.fromEntries(
+    Object.entries(properties.headers ?? {}).filter(
+      (entry) => typeof entry[1] === "string" && !INTERNAL_HEADER_PREFIXES.some((prefix) => entry[0].startsWith(prefix))
+    )
+  );
+}
+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) {
+    return propertyTimeOrNow(message.properties);
+  }
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    observeRejection(value);
+    throw new MalformedMessageError("The occurredAt option returned no valid Date");
+  }
+  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 = internal.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"];
 var MAXIMUM_LADDER_TIERS = 16;
@@ -206,7 +752,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);
@@ -219,7 +765,7 @@ function chooseRetryTier(ladder, delayMs, random) {
   return random() < (delayMs - lower) / (upper - lower) ? upper : lower;
 }
 function readCounterHeader(message, name) {
-  const value = message.properties.headers[name];
+  const value = message.properties.headers?.[name];
   const parsed = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
   return typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
 }
@@ -229,6 +775,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];
@@ -248,8 +796,18 @@ function copyForRepublish(message, headerChanges) {
     }
   };
 }
+function originalRoutingKey(message) {
+  const original = message.properties.headers?.[ORIGINAL_ROUTING_KEY_HEADER];
+  return typeof original === "string" ? original : message.fields.routingKey;
+}
+function withOriginalRoutingKey(message) {
+  const routingKey = originalRoutingKey(message);
+  return routingKey === message.fields.routingKey ? message : { ...message, fields: { ...message.fields, routingKey } };
+}
 
 // src/options.ts
+var DEFAULT_PREFETCH = 50;
+var DEFAULT_DELIVERY_LIMIT = 10;
 var DEFAULT_HANDLER_RETRY = {
   attempts: 3,
   initialDelayMs: 200,
@@ -276,6 +834,14 @@ var DEFAULT_RECONNECT = {
   retryIf: void 0
 };
 function resolveSettings(options) {
+  const basics = resolveBasics(options);
+  return {
+    ...resolveTopology(options, basics),
+    ...resolveRetries(options, basics),
+    ...resolveRuntime(options, basics)
+  };
+}
+function resolveBasics(options) {
   const exchange = nonEmpty(options.exchange ?? "relaybus", "exchange");
   const failOnConnectError = options.failOnConnectError ?? true;
   if (!failOnConnectError && options.reconnect === false) {
@@ -284,11 +850,17 @@ function resolveSettings(options) {
     );
   }
   const ordered = options.ordered ?? false;
-  const prefetch = positiveInteger(options.prefetch ?? (ordered ? 1 : 50), "prefetch");
+  const prefetch = internal.assertPositiveInteger(
+    options.prefetch ?? (ordered ? 1 : DEFAULT_PREFETCH),
+    "prefetch"
+  );
   if (ordered && prefetch !== 1) {
     throw new core.ConfigurationError(`ordered consumption needs prefetch 1, received ${prefetch}`);
   }
   const redelivery = core.createRetryPolicy(options.redelivery, DEFAULT_REDELIVERY);
+  return { exchange, failOnConnectError, ordered, prefetch, redelivery };
+}
+function resolveTopology(options, { exchange, prefetch }) {
   return {
     name: nonEmpty(options.name ?? "rabbitmq", "name"),
     connect: resolveConnect(options),
@@ -302,7 +874,14 @@ function resolveSettings(options) {
       "deadLetterExchange"
     ),
     deadLetterQueue: optionalNonEmpty(options.deadLetterQueue, "deadLetterQueue"),
-    deliveryLimit: positiveInteger(options.deliveryLimit ?? 10, "deliveryLimit"),
+    deliveryLimit: internal.assertPositiveInteger(
+      options.deliveryLimit ?? DEFAULT_DELIVERY_LIMIT,
+      "deliveryLimit"
+    )
+  };
+}
+function resolveRetries(options, { ordered, redelivery }) {
+  return {
     handlerRetry: core.createRetryPolicy(options.handlerRetry, DEFAULT_HANDLER_RETRY),
     redelivery,
     retryLadder: ordered ? [] : buildRetryLadder(redelivery),
@@ -310,12 +889,17 @@ function resolveSettings(options) {
       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: core.toMilliseconds(options.shutdownTimeout ?? "30s", "shutdownTimeout"),
+    ...resolveCodec(options),
     logger: options.logger ?? console,
     random: options.random ?? Math.random
   };
@@ -331,6 +915,22 @@ function resolveQueueName(settings) {
   }
   return `${settings.queuePrefix}.${settings.consumerGroup}`;
 }
+function resolveCodec({
+  codec,
+  decode
+}) {
+  if (decode !== void 0 && codec !== void 0) {
+    throw new core.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 {
+    encode: chosen.encode,
+    decode: (message) => completeDecodedEvent(chosen.decode(message), message)
+  };
+}
 function resolveConnect(options) {
   const { url, connect } = options;
   if (url === void 0 === (connect === void 0)) {
@@ -339,9 +939,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) {
@@ -359,12 +960,6 @@ function nonEmpty(value, name) {
 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 core.ConfigurationError(`${name} must be a positive integer, received ${value}`);
-  }
-  return value;
-}
 function positiveDuration(value, name) {
   const milliseconds = core.toMilliseconds(value, name);
   if (milliseconds === 0) {
@@ -418,192 +1013,6 @@ async function assertConsumerTopology(channel, topology) {
   }
 }
 
-// src/json-payload.ts
-function assertJsonPayload(payload, eventId) {
-  visit(payload, "$", /* @__PURE__ */ new Set(), 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`);
-      }
-      return;
-    case "object":
-      if (value !== null) {
-        visitObject(value, path, ancestors, eventId);
-      }
-      return;
-    default:
-      throw refuse(eventId, path, `is ${typeof value}, which JSON cannot represent`);
-  }
-}
-function visitObject(value, path, ancestors, eventId) {
-  if (ancestors.has(value)) {
-    throw refuse(eventId, path, "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);
-    }
-  } 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);
-    }
-  }
-  ancestors.delete(value);
-}
-function refuse(eventId, path, reason) {
-  return new UnserializablePayloadError(
-    `Event ${eventId} has a payload JSON cannot represent faithfully: ${path} ${reason}`
-  );
-}
-
-// src/wire-format.ts
-var ATTRIBUTE_PREFIX = "cloudEvents:";
-var EVENT_HEADER_PREFIX = "relaybus:";
-var SPEC_VERSION = "1.0";
-var JSON_CONTENT_TYPE = "application/json";
-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) {
-  assertJsonPayload(envelope.payload, envelope.id);
-  assertShortString("Event id", envelope.id);
-  const headers = {
-    [`${ATTRIBUTE_PREFIX}specversion`]: SPEC_VERSION,
-    [`${ATTRIBUTE_PREFIX}id`]: envelope.id,
-    [`${ATTRIBUTE_PREFIX}type`]: envelope.type,
-    [`${ATTRIBUTE_PREFIX}source`]: envelope.source,
-    [`${ATTRIBUTE_PREFIX}time`]: envelope.occurredAt.toISOString(),
-    [`${ATTRIBUTE_PREFIX}datacontenttype`]: JSON_CONTENT_TYPE
-  };
-  if (envelope.key !== null) {
-    headers[`${ATTRIBUTE_PREFIX}subject`] = envelope.key;
-  }
-  if (envelope.causationId !== null) {
-    headers[`${ATTRIBUTE_PREFIX}causationid`] = envelope.causationId;
-  }
-  if (envelope.correlationId !== null) {
-    headers[`${ATTRIBUTE_PREFIX}correlationid`] = envelope.correlationId;
-  }
-  for (const [name, value] of Object.entries(envelope.headers)) {
-    assertShortString(
-      `Header name '${EVENT_HEADER_PREFIX}${name}'`,
-      `${EVENT_HEADER_PREFIX}${name}`
-    );
-    headers[`${EVENT_HEADER_PREFIX}${name}`] = value;
-  }
-  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() / 1e3),
-      ...mirror("type", envelope.type),
-      ...mirror("appId", envelope.source),
-      ...envelope.correlationId === null ? {} : mirror("correlationId", envelope.correlationId),
-      headers
-    }
-  };
-}
-function assertShortString(label, value) {
-  const bytes = Buffer.byteLength(value, "utf8");
-  if (bytes > SHORT_STRING_LIMIT_BYTES) {
-    throw new AmqpLimitExceededError(
-      `${label} is ${bytes} bytes, above the AMQP limit of ${SHORT_STRING_LIMIT_BYTES} bytes`
-    );
-  }
-}
-function mirror(name, value) {
-  return Buffer.byteLength(value, "utf8") > SHORT_STRING_LIMIT_BYTES ? {} : { [name]: value };
-}
-function decodeEnvelope(message) {
-  const { properties } = message;
-  const attributes = properties.headers ?? {};
-  if (attributes[`${ATTRIBUTE_PREFIX}specversion`] !== SPEC_VERSION) {
-    throw new MalformedMessageError(
-      `Message is not a CloudEvents ${SPEC_VERSION} event (header ${ATTRIBUTE_PREFIX}specversion)`
-    );
-  }
-  return {
-    id: required("id", text(attributes[`${ATTRIBUTE_PREFIX}id`]) ?? text(properties.messageId)),
-    type: required("type", text(attributes[`${ATTRIBUTE_PREFIX}type`]) ?? text(properties.type)),
-    source: required(
-      "source",
-      text(attributes[`${ATTRIBUTE_PREFIX}source`]) ?? text(properties.appId)
-    ),
-    key: text(attributes[`${ATTRIBUTE_PREFIX}subject`]) ?? null,
-    payload: parsePayload(message.content),
-    headers: extractEventHeaders(attributes),
-    correlationId: text(attributes[`${ATTRIBUTE_PREFIX}correlationid`]) ?? text(properties.correlationId) ?? null,
-    causationId: text(attributes[`${ATTRIBUTE_PREFIX}causationid`]) ?? null,
-    occurredAt: parseTime(attributes[`${ATTRIBUTE_PREFIX}time`], properties.timestamp)
-  };
-}
-function extractEventHeaders(attributes) {
-  const headers = {};
-  for (const [name, value] of Object.entries(attributes)) {
-    if (name.startsWith(EVENT_HEADER_PREFIX) && typeof value === "string") {
-      Object.defineProperty(headers, name.slice(EVENT_HEADER_PREFIX.length), {
-        value,
-        enumerable: true,
-        writable: true,
-        configurable: true
-      });
-    }
-  }
-  return headers;
-}
-function parsePayload(content) {
-  try {
-    return JSON.parse(content.toString("utf8"));
-  } catch {
-    throw new MalformedMessageError("Message body is not valid JSON");
-  }
-}
-function parseTime(rawTime, timestampSeconds) {
-  if (rawTime === void 0) {
-    const fallback = typeof timestampSeconds === "number" ? new Date(timestampSeconds * 1e3) : void 0;
-    if (fallback === void 0 || Number.isNaN(fallback.getTime())) {
-      throw new MalformedMessageError("Message has no valid time (header cloudEvents:time)");
-    }
-    return fallback;
-  }
-  const occurredAt = typeof rawTime === "string" && RFC3339_PATTERN.test(rawTime) ? new Date(rawTime) : void 0;
-  if (occurredAt === void 0 || Number.isNaN(occurredAt.getTime())) {
-    throw new MalformedMessageError(
-      "Message time (header cloudEvents:time) is not an RFC 3339 timestamp"
-    );
-  }
-  return occurredAt;
-}
-function text(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function required(attribute, value) {
-  if (value === void 0 || value.length === 0) {
-    throw new MalformedMessageError(
-      `Message has no ${attribute} (header ${ATTRIBUTE_PREFIX}${attribute})`
-    );
-  }
-  return value;
-}
-
 // src/queue-consumer.ts
 var QueueConsumer = class {
   #settings;
@@ -699,74 +1108,115 @@ var QueueConsumer = class {
     this.#inFlight.add(task);
   }
   async #process(channel, message) {
-    const { queue, handlerRetry } = this.#settings;
-    let envelope;
-    try {
-      envelope = decodeEnvelope(message);
-    } catch (error) {
-      this.#settings.logger.error(
-        `[QueueConsumer](process) Dead-lettering malformed message | queue=${queue} routingKey=${message.fields.routingKey} error=${core.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=${core.toErrorInfo(error).message}`;
-        if (!core.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 = core.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 (!core.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 = core.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 = core.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) {
@@ -779,27 +1229,27 @@ 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)
+      [FIRST_FAILURE_HEADER]: String(firstFailureAt),
+      [ORIGINAL_ROUTING_KEY_HEADER]: originalRoutingKey(message)
     });
     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=${core.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
@@ -807,27 +1257,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 } = core.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=${core.toErrorInfo(error).message}`
+        `[QueueConsumer](deadLetter) Could not publish to the dead-letter exchange, leaving it to the broker | queue=${this.#settings.queue} error=${core.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);
@@ -841,6 +1293,10 @@ var QueueConsumer = class {
     }
   }
 };
+function describeError(error) {
+  const { message, name, code } = core.toErrorInfo(error);
+  return `error=${message} errorName=${name}${code === void 0 ? "" : ` code=${code}`}`;
+}
 
 // src/serial-queue.ts
 var SerialQueue = class {
@@ -856,13 +1312,14 @@ var SerialQueue = class {
 var NACK_MESSAGE = "message nacked";
 var RabbitMqTransport = class {
   name;
+  system = "rabbitmq";
   #settings;
   #supervisor;
   /** Serializes topology work so a subscription never races a reconnect. */
   #topologyWork = new SerialQueue();
   #live;
   #subscription;
-  #closed = false;
+  #closing;
   constructor(options) {
     this.#settings = resolveSettings(options);
     this.name = this.#settings.name;
@@ -902,19 +1359,21 @@ 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.#publishConfirmed({
+      exchange: this.#settings.exchange,
+      routingKey: destination,
       content,
       options,
-      !this.#settings.allowUnroutable
-    );
+      mandatory: !this.#settings.allowUnroutable
+    });
   }
-  async #publishConfirmed(exchange, routingKey, content, options, mandatory) {
+  async #publishConfirmed(input) {
+    const { exchange, routingKey, content, options, mandatory } = input;
     const publisher = this.#live?.publisher;
     const eventId = options.messageId ?? "unknown";
     if (publisher === void 0) {
@@ -924,18 +1383,21 @@ var RabbitMqTransport = class {
     }
     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 cancelTimeout = internal.schedule(core.systemClock, {
+        run: () => {
+          reject(
+            new RabbitMqUnavailableError(
+              `[RabbitMqTransport](publish) No broker confirm within ${this.#settings.publishTimeoutMs}ms | transport=${this.name} eventId=${eventId} destination=${routingKey}`
+            )
+          );
+        },
+        delayMs: this.#settings.publishTimeoutMs
+      });
       const onConfirm = (error) => {
-        clearTimeout(timer);
+        cancelTimeout();
         const returned = takeUnroutable(publisher.unroutable, returnKey);
         if (error) {
-          reject(this.#toPublishError(error, eventId, routingKey));
+          reject(this.#toPublishError(error, { eventId, destination: routingKey }));
         } else if (returned) {
           reject(
             new UnroutableMessageError(
@@ -955,8 +1417,8 @@ var RabbitMqTransport = class {
           onConfirm
         );
       } catch (error) {
-        clearTimeout(timer);
-        reject(this.#toPublishError(error, eventId, routingKey));
+        cancelTimeout();
+        reject(this.#toPublishError(error, { eventId, destination: routingKey }));
       }
     });
   }
@@ -965,7 +1427,8 @@ 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) {
+  // eslint-disable-next-line relaybus/max-two-params -- the Transport.subscribe signature
+  async subscribe(destinations, onMessage, hooks) {
     if (this.#subscription !== void 0) {
       throw new core.ConfigurationError(
         `Transport '${this.name}' already has a subscription; create another transport for another consumer group`
@@ -995,9 +1458,11 @@ var RabbitMqTransport = class {
         redeliveryMaxAgeMs: this.#settings.redeliveryMaxAgeMs,
         ordered: this.#settings.ordered,
         deadLetterExchange: this.#settings.deadLetterExchange,
-        republish: (exchange, routingKey, content, options) => this.#publishConfirmed(exchange, routingKey, content, options, true),
+        republish: ({ exchange, routingKey }, { content, options }) => this.#publishConfirmed({ 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
@@ -1013,21 +1478,29 @@ var RabbitMqTransport = class {
   /**
    * 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 () => {
@@ -1071,7 +1544,7 @@ var RabbitMqTransport = class {
     this.#live = void 0;
     this.#subscription?.consumer.detach();
   }
-  #toPublishError(error, eventId, destination) {
+  #toPublishError(error, { eventId, destination }) {
     const { message } = core.toErrorInfo(error);
     const detail = `transport=${this.name} eventId=${eventId} destination=${destination} error=${message}`;
     return message === NACK_MESSAGE ? new RabbitMqPublishRejectedError(
@@ -1102,12 +1575,26 @@ function takeUnroutable(unroutable, key) {
   return true;
 }
 
+Object.defineProperty(exports, "fromHeader", {
+  enumerable: true,
+  get: function () { return internal.fromHeader; }
+});
+Object.defineProperty(exports, "fromPayloadField", {
+  enumerable: true,
+  get: function () { return internal.fromPayloadField; }
+});
 exports.AmqpLimitExceededError = AmqpLimitExceededError;
 exports.MalformedMessageError = MalformedMessageError;
 exports.RabbitMqPublishRejectedError = RabbitMqPublishRejectedError;
 exports.RabbitMqTransport = RabbitMqTransport;
 exports.RabbitMqUnavailableError = RabbitMqUnavailableError;
+exports.RabbitMqUnencodableEventError = RabbitMqUnencodableEventError;
 exports.UnroutableMessageError = UnroutableMessageError;
 exports.UnserializablePayloadError = UnserializablePayloadError;
+exports.cloudEventsBinary = cloudEventsBinary;
+exports.cloudEventsStructured = cloudEventsStructured;
+exports.decodeCloudEvent = decodeCloudEvent;
+exports.jsonEnvelope = jsonEnvelope;
+exports.plainJsonDecoder = plainJsonDecoder;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map