@relaybus/kafka 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,14 +1,36 @@
-import { RelayBusError, NonRetryableError, assertEventType, ConfigurationError, toErrorInfo, toMilliseconds } from '@relaybus/core';
+import { RelayBusError, NonRetryableError, assertEventType, toErrorInfo, systemClock, ConfigurationError } from '@relaybus/core';
+import { createCloudEventReaders, DecodedEventReader, mediaTypeOf, isJsonObject, observeRejection, createJsonEnvelopeFormat, SubscribingTransport, writeStructuredCloudEvent, schedule, BoundedInteger, PositiveInteger, ExponentialBackoff, Milliseconds } from '@relaybus/core/internal';
+export { fromHeader, fromPayloadField } from '@relaybus/core/internal';
 
-// src/cloudevents-codec.ts
+// src/errors.ts
 var InvalidKafkaMessageError = class extends RelayBusError {
+  name = "InvalidKafkaMessageError";
+  code = "RELAYBUS_KAFKA_INVALID_MESSAGE";
 };
 var UnencodableEventError = class extends NonRetryableError {
   name = "UnencodableEventError";
+  code = "RELAYBUS_KAFKA_UNENCODABLE_EVENT";
+};
+var PublishTimeoutError = class extends RelayBusError {
+  name = "PublishTimeoutError";
+  code = "RELAYBUS_KAFKA_PUBLISH_TIMEOUT";
+};
+var TransportClosedError = class extends RelayBusError {
+  name = "TransportClosedError";
+  code = "RELAYBUS_KAFKA_TRANSPORT_CLOSED";
+};
+var GroupJoinTimeoutError = class extends RelayBusError {
+  name = "GroupJoinTimeoutError";
+  code = "RELAYBUS_KAFKA_GROUP_JOIN_TIMEOUT";
+};
+var HandlerFailedError = class extends RelayBusError {
+  name = "HandlerFailedError";
+  code = "RELAYBUS_KAFKA_HANDLER_FAILED";
 };
 var SPEC_VERSION = "1.0";
 var CONTENT_TYPE = "content-type";
 var JSON_MEDIA_TYPE = "application/json";
+var STRUCTURED_MEDIA_TYPE = "application/cloudevents+json";
 var CLOUDEVENTS_PREFIX = "ce_";
 var ESCAPE_PREFIX = "x-relaybus-h-";
 var RESERVED_PREFIXES = [CLOUDEVENTS_PREFIX, "x-relaybus-"];
@@ -23,6 +45,7 @@ var HEADER = {
   causationId: "ce_causationid"
 };
 var PROTOCOL_HEADERS = /* @__PURE__ */ new Set([...Object.values(HEADER), CONTENT_TYPE]);
+var MAXIMUM_RFC3339_YEAR = 9999;
 var RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i;
 var strictUtf8 = new TextDecoder("utf-8", { fatal: true });
 var lenientUtf8 = new TextDecoder("utf-8");
@@ -50,25 +73,39 @@ function encodeEnvelope(envelope) {
   }
   return { key: envelope.key, value, headers: Object.fromEntries(entries) };
 }
+function encodeStructuredEnvelope(envelope) {
+  const value = writeStructuredCloudEvent(envelope, {
+    time: formatTime(envelope),
+    data: serializePayload(envelope)
+  });
+  const entries = Object.entries(envelope.headers).map(
+    ([name, headerValue]) => [escapeUserHeaderName(name), headerValue]
+  );
+  entries.push([CONTENT_TYPE, STRUCTURED_MEDIA_TYPE]);
+  return { key: envelope.key, value, headers: Object.fromEntries(entries) };
+}
 function serializePayload(envelope) {
-  let value;
+  return serializeJson(envelope, envelope.payload);
+}
+function serializeJson(envelope, value) {
+  let text;
   try {
-    value = JSON.stringify(envelope.payload);
+    text = JSON.stringify(value);
   } catch (error) {
     throw new UnencodableEventError(
       `Event ${envelope.id} has a payload that JSON cannot represent: ${error.message}`
     );
   }
-  if (value === void 0) {
+  if (text === void 0) {
     throw new UnencodableEventError(
       `Event ${envelope.id} has a payload that JSON cannot represent (undefined, a function or a symbol)`
     );
   }
-  return value;
+  return text;
 }
 function formatTime(envelope) {
   const year = envelope.occurredAt.getUTCFullYear();
-  if (Number.isNaN(year) || year < 0 || year > 9999) {
+  if (Number.isNaN(year) || year < 0 || year > MAXIMUM_RFC3339_YEAR) {
     throw new UnencodableEventError(
       `Event ${envelope.id} has an occurredAt that is not an RFC 3339 instant (invalid date or year outside 0..9999)`
     );
@@ -116,11 +153,14 @@ function readHeaders(incoming) {
     if (typeof raw !== "string" && !(raw instanceof Uint8Array)) {
       throw invalid(`Header '${name}' is repeated`);
     }
-    headers.set(name, decodeText(raw, PROTOCOL_HEADERS.has(name), `Header '${name}'`));
+    headers.set(
+      name,
+      decodeText(raw, { strict: PROTOCOL_HEADERS.has(name), label: `Header '${name}'` })
+    );
   }
   return headers;
 }
-function decodeText(raw, strict, label) {
+function decodeText(raw, { strict, label }) {
   if (typeof raw === "string") {
     return raw;
   }
@@ -143,19 +183,19 @@ function assertJsonContentType(contentType) {
     throw invalid(`${CONTENT_TYPE} must be '${JSON_MEDIA_TYPE}', received '${contentType ?? ""}'`);
   }
 }
-function resolveTime(text, recordTimestamp) {
+function resolveTime(text, recordTimestamp2) {
   if (text !== void 0 && text.length > 0) {
     return parseTime(text);
   }
-  const time = readRecordTimestamp(recordTimestamp);
+  const time = readRecordTimestamp(recordTimestamp2);
   if (time === void 0) {
     throw invalid(`${HEADER.time} is missing and the record has no usable timestamp`);
   }
   return time;
 }
-function readRecordTimestamp(recordTimestamp) {
-  const time = new Date(Number(recordTimestamp));
-  return recordTimestamp === void 0 || recordTimestamp === "" || Number.isNaN(time.getTime()) ? void 0 : time;
+function readRecordTimestamp(recordTimestamp2) {
+  const time = new Date(Number(recordTimestamp2));
+  return recordTimestamp2 === void 0 || recordTimestamp2 === "" || Number.isNaN(time.getTime()) ? void 0 : time;
 }
 function parseTime(text, label = HEADER.time) {
   const time = new Date(text);
@@ -168,7 +208,7 @@ function parsePayload(value) {
   if (value === null) {
     throw invalid("Message has no value");
   }
-  const text = decodeText(value, true, "Message value");
+  const text = decodeText(value, { strict: true, label: "Message value" });
   try {
     return JSON.parse(text);
   } catch {
@@ -183,7 +223,7 @@ function resolveKey(subject, recordKey) {
   return subject ?? keyText;
 }
 function readRecordKey(recordKey) {
-  return recordKey === null ? null : decodeText(recordKey, true, "Message key");
+  return recordKey === null ? null : decodeText(recordKey, { strict: true, label: "Message key" });
 }
 function collectUserHeaders(headers) {
   const entries = [];
@@ -212,7 +252,8 @@ function toOutgoingHeaders(incoming) {
 function toBufferOrString(value) {
   return typeof value === "string" ? value : Buffer.from(value);
 }
-var STRUCTURED_MEDIA_TYPE = "application/cloudevents+json";
+var { optionalAttribute, requiredAttribute, assertValidType, assertJsonDataContentType } = createCloudEventReaders(invalid);
+var STRUCTURED_MEDIA_TYPE2 = "application/cloudevents+json";
 var exactUtf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 var SPEC_VERSION2 = "1.0";
 var SPEC_VERSION_HEADER = "ce_specversion";
@@ -232,7 +273,7 @@ var STRUCTURED_ATTRIBUTES = /* @__PURE__ */ new Set([
 ]);
 function decodeCloudEvent(record) {
   const headers = readHeaders(record.headers);
-  if (mediaTypeOf(headers.get(CONTENT_TYPE)) !== STRUCTURED_MEDIA_TYPE) {
+  if (mediaTypeOf(headers.get(CONTENT_TYPE)) !== STRUCTURED_MEDIA_TYPE2) {
     return decodeEnvelope(record);
   }
   const body = parsePayload(record.value);
@@ -267,89 +308,59 @@ function plainJsonDecoder(options) {
   }
   return (record) => {
     const headers = readHeadersLeniently(record.headers);
-    if (record.headers?.[SPEC_VERSION_HEADER] !== void 0 || mediaTypeOf(headers[CONTENT_TYPE]) === STRUCTURED_MEDIA_TYPE) {
+    if (record.headers?.[SPEC_VERSION_HEADER] !== void 0 || mediaTypeOf(headers[CONTENT_TYPE]) === STRUCTURED_MEDIA_TYPE2) {
       return decodeCloudEvent(record);
     }
-    const plain = {
-      topic: record.topic,
-      partition: record.partition,
-      offset: record.offset,
-      key: readKeyLeniently(record.key),
-      headers,
-      payload: parsePayload(record.value),
-      timestamp: record.timestamp
-    };
-    const type = resolveText(options.type, plain, "type");
+    const plain = plainRecordOf(record, headers);
+    const type = KAFKA_EVENTS.text(options.type, { plain, name: "type" });
     if (type === void 0) {
       throw invalid("Record has no event type: the type option found none");
     }
     assertValidType(type, "The event type");
     return {
-      id: resolveText(options.id, plain, "id") ?? `kafka:${record.topic}:${record.partition}:${record.offset}`,
+      id: KAFKA_EVENTS.text(options.id, { plain, name: "id" }) ?? `kafka:${record.topic}:${record.partition}:${record.offset}`,
       type,
-      source: resolveText(options.source, plain, "source") ?? record.topic,
-      key: options.key === void 0 ? plain.key : resolveText(options.key, plain, "key") ?? null,
+      source: KAFKA_EVENTS.text(options.source, { plain, name: "source" }) ?? record.topic,
+      key: options.key === void 0 ? plain.key : KAFKA_EVENTS.text(options.key, { plain, name: "key" }) ?? null,
       payload: plain.payload,
       headers,
       correlationId: null,
       causationId: null,
-      occurredAt: resolveOccurredAt(options.occurredAt, plain, record)
+      occurredAt: resolveOccurredAt(options.occurredAt, { plain, record })
     };
   };
 }
-function completeDecodedEvent(decoded, record) {
-  if (typeof decoded !== "object" || decoded === null) {
-    throw invalid("The decoder must return an event object synchronously");
-  }
-  if ("then" in decoded) {
-    observeRejection(decoded);
-    throw invalid("The decoder must return an event object synchronously");
-  }
-  const event = decoded;
+function plainRecordOf(record, headers) {
   return {
-    id: event.id,
-    type: event.type,
-    source: event.source ?? record.topic,
-    key: event.key === void 0 ? readRecordKey(record.key) : event.key,
-    payload: event.payload,
-    headers: event.headers ?? {},
-    correlationId: event.correlationId ?? null,
-    causationId: event.causationId ?? null,
-    occurredAt: event.occurredAt ?? requireRecordTimestamp(record)
+    topic: record.topic,
+    partition: record.partition,
+    offset: record.offset,
+    key: readKeyLeniently(record.key),
+    headers,
+    payload: parsePayload(record.value),
+    timestamp: record.timestamp
   };
 }
-function mediaTypeOf(contentType) {
-  return contentType?.split(";")[0]?.trim().toLowerCase();
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalAttribute(body, name) {
-  const value = body[name];
-  if (value !== void 0 && typeof value !== "string") {
-    throw invalid(`Attribute '${name}' must be a string`);
+var KafkaDecodedEvents = class extends DecodedEventReader {
+  invalid(reason) {
+    return invalid(reason);
   }
-  return value;
-}
-function requiredAttribute(body, name) {
-  const value = optionalAttribute(body, name);
-  if (value === void 0 || value.length === 0) {
-    throw invalid(`Attribute '${name}' is missing or empty`);
+  /** The topic. */
+  defaultSource(record) {
+    return record.topic;
   }
-  return value;
-}
-function assertValidType(type, label) {
-  try {
-    assertEventType(type);
-  } catch (error) {
-    throw invalid(`${label} is not a valid event type: ${error.message}`);
+  /** The record key as UTF-8 text. */
+  defaultKey(record) {
+    return readRecordKey(record.key);
   }
-}
-function assertJsonDataContentType(dataContentType) {
-  const mediaType = mediaTypeOf(dataContentType);
-  if (mediaType !== void 0 && mediaType !== "application/json" && mediaType !== "text/json" && !mediaType.endsWith("+json")) {
-    throw invalid(`datacontenttype must be JSON, received '${dataContentType}'`);
+  /** The record timestamp; a record without a usable one is malformed. */
+  defaultTime(record) {
+    return requireRecordTimestamp(record);
   }
+};
+var KAFKA_EVENTS = new KafkaDecodedEvents();
+function completeDecodedEvent(decoded, record) {
+  return KAFKA_EVENTS.complete(decoded, record);
 }
 function extensionAttributes(body) {
   return Object.fromEntries(
@@ -396,18 +407,7 @@ function readKeyLeniently(key) {
     return Buffer.from(key).toString("base64");
   }
 }
-function resolveText(option, record, name) {
-  const value = typeof option === "function" ? option(record) : option;
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    observeRejection(value);
-    throw invalid(`The ${name} option returned ${typeof value}, expected a string`);
-  }
-  return value.length === 0 ? void 0 : value;
-}
-function resolveOccurredAt(option, plain, record) {
+function resolveOccurredAt(option, { plain, record }) {
   const value = option?.(plain);
   if (value === void 0) {
     return requireRecordTimestamp(record);
@@ -418,18 +418,205 @@ function resolveOccurredAt(option, plain, record) {
   }
   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 RECORD_POSITION = "record-position";
+var EVENT_ID_HEADER = "relaybus-event-id";
+var DEFAULT_CONTENT_TYPE = "application/json";
+function jsonEnvelope(mapping) {
+  const format = createJsonEnvelopeFormat(mapping, {
+    transportIds: [RECORD_POSITION],
+    failures: { invalid, unencodable: (reason) => new UnencodableEventError(reason) }
+  });
+  const contentType = mapping.contentType ?? DEFAULT_CONTENT_TYPE;
+  const stampsTime = mapping.occurredAt === void 0;
+  const ownHeaders = (envelope) => mapping.id === RECORD_POSITION ? { [CONTENT_TYPE]: contentType, [EVENT_ID_HEADER]: envelope.id } : { [CONTENT_TYPE]: contentType };
+  return {
+    encode: (envelope) => encodeJson(envelope, { format, stampsTime, ownHeaders }),
+    decode: (record) => decodeJson(record, format)
+  };
+}
+function encodeJson(envelope, { format, stampsTime, ownHeaders }) {
+  assertRepresentable(envelope);
+  const { body, headers } = format.write(envelope);
+  const taken = [CONTENT_TYPE, EVENT_ID_HEADER].find((name) => Object.hasOwn(headers, name));
+  if (taken !== void 0) {
+    throw new UnencodableEventError(
+      `Event ${envelope.id} has a header '${taken}', which the codec writes itself`
+    );
   }
+  return {
+    key: envelope.key,
+    value: serializeJson(envelope, body),
+    headers: { ...headers, ...ownHeaders(envelope) },
+    ...stampsTime ? { timestamp: recordTimestamp(envelope) } : {}
+  };
 }
-
-// src/kafka-transport.ts
-var PublishTimeoutError = class extends RelayBusError {
-  name = "PublishTimeoutError";
+function decodeJson(record, format) {
+  const { [EVENT_ID_HEADER]: eventId, ...headers } = withoutContentType(
+    readHeadersLeniently(record.headers)
+  );
+  const fields = format.read({ body: parsePayload(record.value), headers });
+  return {
+    ...fields,
+    id: fields.id ?? (eventId === void 0 || eventId === "" ? `kafka:${record.topic}:${record.partition}:${record.offset}` : eventId)
+  };
+}
+function withoutContentType(headers) {
+  return Object.fromEntries(Object.entries(headers).filter(([name]) => name !== CONTENT_TYPE));
+}
+function assertRepresentable(envelope) {
+  const kind = typeof envelope.payload;
+  if (kind === "undefined" || kind === "function" || kind === "symbol") {
+    throw new UnencodableEventError(
+      `Event ${envelope.id} has a payload that JSON cannot represent (undefined, a function or a symbol)`
+    );
+  }
+}
+function recordTimestamp(envelope) {
+  formatTime(envelope);
+  return String(envelope.occurredAt.getTime());
+}
+function tracksMembership(consumer) {
+  return consumer.on !== void 0 && consumer.events?.GROUP_JOIN !== void 0;
+}
+var GroupJoinWatch = class {
+  #settings;
+  #waiter;
+  constructor(settings) {
+    this.#settings = settings;
+  }
+  /** The consumer joined its group. */
+  joined() {
+    this.#waiter?.resolve();
+  }
+  /** The consumer crashed while it was joining. */
+  failed(error) {
+    this.#waiter?.reject(error);
+  }
+  /** The transport closed while the consumer was joining. */
+  closed() {
+    this.#waiter?.reject(new TransportClosedError(`Transport '${this.#settings.name}' is closed`));
+  }
+  /** Connects and subscribes the consumer, runs it and resolves once it joined its group. */
+  async start(consumer, {
+    topics,
+    fromBeginning,
+    eachMessage
+  }) {
+    await consumer.connect();
+    await consumer.subscribe({ topics, fromBeginning });
+    const joined = this.#wait(consumer);
+    try {
+      await consumer.run({ eachMessage });
+      await joined.promise;
+    } finally {
+      joined.dispose();
+    }
+  }
+  #wait(consumer) {
+    if (!tracksMembership(consumer)) {
+      return { promise: Promise.resolve(), dispose: () => void 0 };
+    }
+    const { name, groupId, timings } = this.#settings;
+    let cancel;
+    const promise = new Promise((resolve, reject) => {
+      this.#waiter = { resolve, reject };
+      cancel = schedule(systemClock, {
+        run: () => {
+          reject(
+            new GroupJoinTimeoutError(
+              `Consumer of transport '${name}' did not join group '${groupId}' within ${timings.startupTimeoutMs}ms`
+            )
+          );
+        },
+        delayMs: timings.startupTimeoutMs
+      });
+    });
+    promise.catch(() => void 0);
+    return {
+      promise,
+      dispose: () => {
+        cancel?.();
+        this.#waiter = void 0;
+      }
+    };
+  }
 };
-var HandlerFailedError = class extends RelayBusError {
-  name = "HandlerFailedError";
+var KafkaProducerSession = class {
+  #settings;
+  /** Whether the transport is closed: then nothing connects any more. */
+  #isClosed;
+  #producer;
+  #connected = false;
+  constructor(settings, isClosed) {
+    this.#settings = settings;
+    this.#isClosed = isClosed;
+  }
+  /** True once the producer connected, until the transport closes. */
+  get isConnected() {
+    return this.#connected;
+  }
+  /** The producer opened so far, if any: what closing must disconnect. */
+  get pending() {
+    return this.#producer;
+  }
+  markClosed() {
+    this.#connected = false;
+  }
+  connected() {
+    if (this.#isClosed()) {
+      return Promise.reject(
+        new TransportClosedError(`Transport '${this.#settings.name}' is closed`)
+      );
+    }
+    this.#producer ??= this.#open();
+    return this.#producer;
+  }
+  /** Sends with the publish timeout; the late outcome of a timed-out send is ignored. */
+  async send(producer, record) {
+    const { name, timings } = this.#settings;
+    let cancel;
+    const timeout = new Promise((_resolve, reject) => {
+      cancel = schedule(systemClock, {
+        run: () => {
+          reject(
+            new PublishTimeoutError(
+              `Transport '${name}' got no broker ack for topic '${record.topic}' within ${timings.publishTimeoutMs}ms`
+            )
+          );
+        },
+        delayMs: timings.publishTimeoutMs
+      });
+    });
+    const sending = producer.send(record);
+    sending.catch(() => void 0);
+    try {
+      await Promise.race([sending, timeout]);
+    } finally {
+      cancel?.();
+    }
+  }
+  async #open() {
+    const { kafka, producerConfig, maxInFlightRequests } = this.#settings;
+    const producer = kafka.producer({ ...producerConfig, idempotent: true, maxInFlightRequests });
+    try {
+      await producer.connect();
+    } catch (error) {
+      this.#producer = void 0;
+      throw error;
+    }
+    this.#connected = !this.#isClosed();
+    return producer;
+  }
 };
 var DEFAULTS = {
   name: "kafka",
@@ -443,46 +630,224 @@ var DEFAULTS = {
   restartInitialBackoff: "1s",
   restartMaxBackoff: "30s"
 };
-var KafkaTransport = class {
+var MAXIMUM_IN_FLIGHT_REQUESTS = 5;
+function resolveKafkaSettings(options) {
+  return {
+    name: options.name ?? DEFAULTS.name,
+    kafka: options.kafka,
+    groupId: options.groupId,
+    fromBeginning: options.fromBeginning ?? true,
+    maxInFlightRequests: BoundedInteger.of(
+      options.maxInFlightRequests ?? DEFAULTS.maxInFlightRequests,
+      { name: "maxInFlightRequests", minimum: 1, maximum: MAXIMUM_IN_FLIGHT_REQUESTS }
+    ),
+    producerConfig: options.producerConfig ?? {},
+    consumerConfig: options.consumerConfig ?? {},
+    invalidPolicy: options.onInvalidMessage ?? "dead-letter",
+    codec: resolveCodec(options),
+    logger: options.logger ?? console,
+    timings: resolveTimings(options)
+  };
+}
+function resolveCodec({ codec, decode }) {
+  if (decode === void 0) {
+    return codec ?? cloudEventsBinary;
+  }
+  if (codec !== void 0) {
+    throw new ConfigurationError("Give 'codec' or the deprecated 'decode', not both");
+  }
+  return { encode: encodeEnvelope, decode };
+}
+function resolveTimings(options) {
+  const processing = options.processing ?? {};
+  const maxAttempts = PositiveInteger.of(
+    processing.maxAttempts ?? DEFAULTS.maxAttempts,
+    "processing.maxAttempts"
+  );
+  return {
+    maxAttempts,
+    processingBackoff: new ExponentialBackoff({
+      initialMs: Milliseconds.of(
+        processing.initialBackoff ?? DEFAULTS.initialBackoff,
+        "processing.initialBackoff"
+      ),
+      maxMs: Milliseconds.of(processing.maxBackoff ?? DEFAULTS.maxBackoff, "processing.maxBackoff")
+    }),
+    startupTimeoutMs: Milliseconds.of(
+      options.startupTimeout ?? DEFAULTS.startupTimeout,
+      "startupTimeout"
+    ),
+    publishTimeoutMs: Milliseconds.of(
+      options.publishTimeout ?? DEFAULTS.publishTimeout,
+      "publishTimeout"
+    ),
+    heartbeatIntervalMs: Math.max(
+      1,
+      Milliseconds.of(
+        processing.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
+        "processing.heartbeatInterval"
+      )
+    ),
+    restartBackoff: resolveRestartBackoff(options.restart ?? {})
+  };
+}
+function resolveRestartBackoff(restart) {
+  return new ExponentialBackoff({
+    initialMs: Milliseconds.of(
+      restart.initialBackoff ?? DEFAULTS.restartInitialBackoff,
+      "restart.initialBackoff"
+    ),
+    maxMs: Milliseconds.of(restart.maxBackoff ?? DEFAULTS.restartMaxBackoff, "restart.maxBackoff")
+  });
+}
+function deadLetterTopicFor(policy, sourceTopic) {
+  if (policy === "dead-letter") {
+    return `${sourceTopic}.dead`;
+  }
+  if (typeof policy === "object") {
+    const { deadLetterTopic } = policy;
+    return typeof deadLetterTopic === "function" ? deadLetterTopic(sourceTopic) : deadLetterTopic;
+  }
+  return void 0;
+}
+function toHandlerFailure(error) {
+  const { name, message } = toErrorInfo(error);
+  return new HandlerFailedError(`${name}: ${message}`);
+}
+function assertCanSubscribe(state, {
+  settings,
+  destinations
+}) {
+  const { name, groupId, invalidPolicy } = settings;
+  if (state === "closed") {
+    throw new TransportClosedError(`Transport '${name}' is closed`);
+  }
+  if (state === "subscribed") {
+    throw new ConfigurationError(
+      `Transport '${name}' already subscribed; list every topic in one subscription or use one KafkaTransport per consumer group`
+    );
+  }
+  if (groupId === void 0 || groupId.length === 0) {
+    throw new ConfigurationError(`Transport '${name}' needs a groupId to subscribe`);
+  }
+  if (destinations.length === 0) {
+    throw new ConfigurationError(`Transport '${name}' subscribed to no topics`);
+  }
+  for (const topic of destinations) {
+    const deadLetterTopic = deadLetterTopicFor(invalidPolicy, topic);
+    if (deadLetterTopic !== void 0 && destinations.includes(deadLetterTopic)) {
+      throw new ConfigurationError(
+        `Dead letter topic '${deadLetterTopic}' is also consumed, which would loop`
+      );
+    }
+  }
+}
+
+// src/kafka-records.ts
+function decodeRecord(codec, { topic, partition, message }) {
+  if (codec === cloudEventsBinary) {
+    return decodeEnvelope(message);
+  }
+  const record = {
+    topic,
+    partition,
+    offset: message.offset,
+    key: message.key,
+    value: message.value,
+    headers: message.headers,
+    timestamp: message.timestamp
+  };
+  return completeDecodedEvent(codec.decode(record), record);
+}
+function deadLetterRecord({ topic, partition, message }, {
+  reason,
+  name,
+  code,
+  deadLetterTopic
+}) {
+  const headers = {
+    ...toOutgoingHeaders(message.headers),
+    "relaybus-invalid-reason": reason,
+    "relaybus-source-topic": topic,
+    "relaybus-source-partition": String(partition),
+    "relaybus-source-offset": message.offset,
+    "relaybus-error-name": name
+  };
+  if (code === void 0) {
+    delete headers["relaybus-error-code"];
+  } else {
+    headers["relaybus-error-code"] = code;
+  }
+  return {
+    topic: deadLetterTopic,
+    acks: -1,
+    messages: [
+      {
+        key: message.key === null ? null : Buffer.from(message.key),
+        value: message.value === null ? null : Buffer.from(message.value),
+        headers
+      }
+    ]
+  };
+}
+var WakeableSleeps = class {
+  #sleepers = /* @__PURE__ */ new Set();
+  sleep(milliseconds) {
+    return new Promise((resolve) => {
+      const wake = () => {
+        cancel();
+        this.#sleepers.delete(wake);
+        resolve();
+      };
+      const cancel = schedule(systemClock, { run: wake, delayMs: milliseconds });
+      this.#sleepers.add(wake);
+    });
+  }
+  wakeAll() {
+    for (const wake of this.#sleepers) {
+      wake();
+    }
+  }
+  /**
+   * Sleeps `milliseconds` in slices of at most `sliceMs`, running `between` after each, until done
+   * or `stopped`: a long backoff then never outlives the session timeout.
+   */
+  async sleepInSlices(milliseconds, {
+    sliceMs,
+    between,
+    stopped
+  }) {
+    let remaining = milliseconds;
+    do {
+      const slice = Math.min(remaining, sliceMs);
+      await this.sleep(slice);
+      await between();
+      remaining -= slice;
+    } while (remaining > 0 && !stopped());
+  }
+};
+
+// src/kafka-transport.ts
+var KafkaTransport = class extends SubscribingTransport {
   name;
-  #kafka;
-  #groupId;
-  #fromBeginning;
-  #maxInFlightRequests;
-  #producerConfig;
-  #consumerConfig;
-  #invalidPolicy;
-  #decode;
-  #logger;
+  system = "kafka";
   #settings;
-  #sleepers = /* @__PURE__ */ new Set();
-  #state = "idle";
   #producer;
+  #groupJoin;
+  #sleeps = new WakeableSleeps();
+  #state = "idle";
   #consumer;
   #groupJoined = false;
   #consuming = false;
-  #producerConnected = false;
   #restartLoop;
   #stalledPartitions = /* @__PURE__ */ new Set();
   #startConsuming;
-  #joinWaiter;
   constructor(options) {
-    this.name = options.name ?? DEFAULTS.name;
-    this.#kafka = options.kafka;
-    this.#groupId = options.groupId;
-    this.#fromBeginning = options.fromBeginning ?? true;
-    this.#maxInFlightRequests = options.maxInFlightRequests ?? DEFAULTS.maxInFlightRequests;
-    if (!Number.isInteger(this.#maxInFlightRequests) || this.#maxInFlightRequests < 1 || this.#maxInFlightRequests > 5) {
-      throw new ConfigurationError(
-        `maxInFlightRequests must be an integer from 1 to 5, received ${this.#maxInFlightRequests}`
-      );
-    }
-    this.#producerConfig = options.producerConfig ?? {};
-    this.#consumerConfig = options.consumerConfig ?? {};
-    this.#invalidPolicy = options.onInvalidMessage ?? "dead-letter";
-    this.#decode = options.decode;
-    this.#logger = options.logger ?? console;
-    this.#settings = resolveSettings(options);
+    super();
+    this.#settings = resolveKafkaSettings(options);
+    this.name = this.#settings.name;
+    this.#producer = new KafkaProducerSession(this.#settings, () => this.#state === "closed");
+    this.#groupJoin = new GroupJoinWatch(this.#settings);
   }
   /**
    * True while the consumer is joined to its group, not between a crash or
@@ -499,22 +864,21 @@ var KafkaTransport = class {
    * dead consumer is being restarted.
    */
   isReady() {
-    if (this.#state === "closed" || !this.#producerConnected) {
+    if (this.#state === "closed" || !this.#producer.isConnected) {
       return false;
     }
     return this.#state === "idle" || this.isConsuming();
   }
   /** Connects the producer. Called by the bus on start; `publish` also connects on demand. */
   async connect() {
-    await this.#connectedProducer();
+    await this.#producer.connected();
   }
   async publish(envelope, destination) {
-    const producer = await this.#connectedProducer();
-    const { key, value, headers } = encodeEnvelope(envelope);
-    await this.#send(producer, {
+    const producer = await this.#producer.connected();
+    await this.#producer.send(producer, {
       topic: destination,
       acks: -1,
-      messages: [{ key, value, headers }]
+      messages: [this.#settings.codec.encode(envelope)]
     });
   }
   /**
@@ -524,13 +888,21 @@ var KafkaTransport = class {
    * @throws ConfigurationError when `groupId` is missing, `destinations` is empty
    * or the transport already subscribed (create one transport per subscription).
    */
-  async subscribe(destinations, onMessage) {
-    this.#assertCanSubscribe(destinations);
+  openSubscription(subscription) {
+    return this.#subscribe(subscription);
+  }
+  async #subscribe({ destinations, onMessage, hooks }) {
+    assertCanSubscribe(this.#state, { settings: this.#settings, destinations });
     this.#state = "subscribed";
-    const consumer = this.#kafka.consumer({ ...this.#consumerConfig, groupId: this.#groupId });
+    const { kafka, consumerConfig, groupId } = this.#settings;
+    const consumer = kafka.consumer({ ...consumerConfig, groupId });
     this.#consumer = consumer;
     this.#observeConsumer(consumer);
-    const start = () => this.#startConsumer(consumer, [...destinations], onMessage);
+    const start = () => this.#groupJoin.start(consumer, {
+      topics: [...destinations],
+      fromBeginning: this.#settings.fromBeginning,
+      eachMessage: (payload) => this.#handleMessage(payload, { onMessage, hooks })
+    });
     this.#startConsuming = start;
     try {
       await start();
@@ -542,34 +914,21 @@ var KafkaTransport = class {
       throw error;
     }
     this.#consuming = true;
-    this.#logger.log(
-      `[KafkaTransport](subscribe) Consuming | transport=${this.name} group=${this.#groupId} topics=${destinations.join(",")}`
+    this.#settings.logger.log(
+      `[KafkaTransport](subscribe) Consuming | transport=${this.name} group=${groupId} topics=${destinations.join(",")}`
     );
   }
-  async #startConsumer(consumer, destinations, onMessage) {
-    await consumer.connect();
-    await consumer.subscribe({ topics: destinations, fromBeginning: this.#fromBeginning });
-    const joined = this.#waitForGroupJoin(consumer);
-    try {
-      await consumer.run({ eachMessage: (payload) => this.#handleMessage(payload, onMessage) });
-      await joined.promise;
-    } finally {
-      joined.dispose();
-    }
-  }
   /** Stops consuming and disconnects the consumer and the producer. Safe to call twice. */
   async close() {
     if (this.#state === "closed") {
       return;
     }
     this.#state = "closed";
-    const pendingProducer = this.#producer;
+    const pendingProducer = this.#producer.pending;
     this.#groupJoined = false;
-    this.#producerConnected = false;
-    for (const wake of this.#sleepers) {
-      wake();
-    }
-    this.#joinWaiter?.reject(new RelayBusError(`Transport '${this.name}' is closed`));
+    this.#producer.markClosed();
+    this.#sleeps.wakeAll();
+    this.#groupJoin.closed();
     await this.#restartLoop;
     const producer = await pendingProducer?.catch(() => void 0);
     const results = await Promise.allSettled([
@@ -581,130 +940,45 @@ var KafkaTransport = class {
       throw failure.reason;
     }
   }
-  #assertCanSubscribe(destinations) {
-    if (this.#state === "closed") {
-      throw new RelayBusError(`Transport '${this.name}' is closed`);
-    }
-    if (this.#state === "subscribed") {
-      throw new ConfigurationError(
-        `Transport '${this.name}' already subscribed; list every topic in one subscription or use one KafkaTransport per consumer group`
-      );
-    }
-    if (this.#groupId === void 0 || this.#groupId.length === 0) {
-      throw new ConfigurationError(`Transport '${this.name}' needs a groupId to subscribe`);
-    }
-    if (destinations.length === 0) {
-      throw new ConfigurationError(`Transport '${this.name}' subscribed to no topics`);
-    }
-    for (const topic of destinations) {
-      const deadLetterTopic = this.#deadLetterTopicFor(topic);
-      if (deadLetterTopic !== void 0 && destinations.includes(deadLetterTopic)) {
-        throw new ConfigurationError(
-          `Dead letter topic '${deadLetterTopic}' is also consumed, which would loop`
-        );
-      }
-    }
-  }
-  /** The dead-letter topic for records of `sourceTopic`, or undefined when the policy does not use one. */
-  #deadLetterTopicFor(sourceTopic) {
-    const policy = this.#invalidPolicy;
-    if (policy === "dead-letter") {
-      return `${sourceTopic}.dead`;
-    }
-    if (typeof policy === "object") {
-      const { deadLetterTopic } = policy;
-      return typeof deadLetterTopic === "function" ? deadLetterTopic(sourceTopic) : deadLetterTopic;
-    }
-    return void 0;
-  }
-  /** Sends with the publish timeout; the late outcome of a timed-out send is ignored. */
-  async #send(producer, record) {
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-      timer = setTimeout(() => {
-        reject(
-          new PublishTimeoutError(
-            `Transport '${this.name}' got no broker ack for topic '${record.topic}' within ${this.#settings.publishTimeoutMs}ms`
-          )
-        );
-      }, this.#settings.publishTimeoutMs);
-    });
-    const sending = producer.send(record);
-    sending.catch(() => void 0);
-    try {
-      await Promise.race([sending, timeout]);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  #connectedProducer() {
-    if (this.#state === "closed") {
-      return Promise.reject(new RelayBusError(`Transport '${this.name}' is closed`));
-    }
-    this.#producer ??= this.#openProducer();
-    return this.#producer;
-  }
-  async #openProducer() {
-    const producer = this.#kafka.producer({
-      ...this.#producerConfig,
-      idempotent: true,
-      maxInFlightRequests: this.#maxInFlightRequests
-    });
-    try {
-      await producer.connect();
-    } catch (error) {
-      this.#producer = void 0;
-      throw error;
-    }
-    this.#producerConnected = this.#state !== "closed";
-    return producer;
-  }
-  async #handleMessage(payload, onMessage) {
+  async #handleMessage(payload, route) {
     let envelope;
     try {
-      envelope = this.#decodeRecord(payload);
+      envelope = decodeRecord(this.#settings.codec, payload);
     } catch (error) {
-      if (this.#decode === void 0 && !(error instanceof InvalidKafkaMessageError)) {
+      if (this.#settings.codec === cloudEventsBinary && !(error instanceof InvalidKafkaMessageError)) {
         throw toHandlerFailure(error);
       }
-      const reason = toErrorInfo(error).message;
-      await this.#withRetries(payload, "handleInvalid", () => this.#handleInvalid(payload, reason));
+      route.hooks?.onInvalidMessage({ destination: payload.topic, error });
+      await this.#withRetries(payload, {
+        method: "handleInvalid",
+        operation: () => this.#handleInvalid(payload, error)
+      });
       return;
     }
-    await this.#withRetries(payload, "deliver", async () => {
-      try {
-        await onMessage(envelope);
-      } catch (error) {
-        if (!(error instanceof NonRetryableError)) {
-          throw error;
+    await this.#withRetries(payload, {
+      method: "deliver",
+      operation: async () => {
+        try {
+          await route.onMessage(envelope, { destination: payload.topic });
+        } catch (error) {
+          if (!(error instanceof NonRetryableError)) {
+            throw error;
+          }
+          await this.#handleInvalid(payload, error);
         }
-        await this.#handleInvalid(payload, error.message);
       }
     });
   }
-  #decodeRecord({ topic, partition, message }) {
-    if (this.#decode === void 0) {
-      return decodeEnvelope(message);
-    }
-    const record = {
-      topic,
-      partition,
-      offset: message.offset,
-      key: message.key,
-      value: message.value,
-      headers: message.headers,
-      timestamp: message.timestamp
-    };
-    return completeDecodedEvent(this.#decode(record), record);
-  }
-  async #handleInvalid(payload, reason) {
+  async #handleInvalid(payload, error) {
     const { topic, partition, message } = payload;
+    const { message: reason, name, code } = toErrorInfo(error);
     const location = `topic=${topic} partition=${partition} offset=${message.offset}`;
-    const policy = this.#invalidPolicy;
-    const deadLetterTopic = this.#deadLetterTopicFor(topic);
+    const errorFields = `errorName=${name}${code === void 0 ? "" : ` code=${code}`}`;
+    const policy = this.#settings.invalidPolicy;
+    const deadLetterTopic = deadLetterTopicFor(policy, topic);
     if (policy === "skip") {
-      this.#logger.error(
-        `[KafkaTransport](handleInvalid) Skipping malformed message | ${location} reason=${reason}`
+      this.#settings.logger.error(
+        `[KafkaTransport](handleInvalid) Skipping malformed message | ${location} reason=${reason} ${errorFields}`
       );
     } else if (typeof policy === "function") {
       await policy({
@@ -716,26 +990,16 @@ var KafkaTransport = class {
         value: message.value
       });
     } else {
-      const producer = await this.#connectedProducer();
-      await this.#send(producer, {
-        topic: deadLetterTopic,
-        acks: -1,
-        messages: [
-          {
-            key: message.key === null ? null : Buffer.from(message.key),
-            value: message.value === null ? null : Buffer.from(message.value),
-            headers: {
-              ...toOutgoingHeaders(message.headers),
-              "relaybus-invalid-reason": reason,
-              "relaybus-source-topic": topic,
-              "relaybus-source-partition": String(partition),
-              "relaybus-source-offset": message.offset
-            }
-          }
-        ]
+      const record = deadLetterRecord(payload, {
+        reason,
+        name,
+        code,
+        deadLetterTopic
       });
-      this.#logger.error(
-        `[KafkaTransport](handleInvalid) Dead-lettered malformed message | ${location} deadLetterTopic=${deadLetterTopic} reason=${reason}`
+      const producer = await this.#producer.connected();
+      await this.#producer.send(producer, record);
+      this.#settings.logger.error(
+        `[KafkaTransport](handleInvalid) Dead-lettered malformed message | ${location} deadLetterTopic=${deadLetterTopic} reason=${reason} ${errorFields}`
       );
     }
   }
@@ -744,8 +1008,9 @@ var KafkaTransport = class {
    * last error is rethrown so the client leaves the offset uncommitted and
    * redelivers the record; heartbeats between attempts keep the session alive.
    */
-  async #withRetries(payload, method, operation) {
-    const { maxAttempts, initialBackoffMs, maxBackoffMs } = this.#settings;
+  async #withRetries(payload, { method, operation }) {
+    const { maxAttempts, processingBackoff } = this.#settings.timings;
+    const { logger } = this.#settings;
     const location = `topic=${payload.topic} partition=${payload.partition} offset=${payload.message.offset}`;
     const partitionKey = `${payload.topic}:${payload.partition}`;
     for (let attempt = 1; ; attempt += 1) {
@@ -757,51 +1022,28 @@ var KafkaTransport = class {
         const reason = toErrorInfo(error).message;
         if (attempt >= maxAttempts || this.#state === "closed") {
           this.#stalledPartitions.add(partitionKey);
-          this.#logger.error(
-            `[KafkaTransport](${method}) Giving up for now, the record stays uncommitted and will be redelivered | ${location} attempts=${attempt} error=${reason}`
+          logger.error(
+            `[KafkaTransport](withRetries) Giving up for now, the record stays uncommitted and will be redelivered | operation=${method} ${location} attempts=${attempt} error=${reason}`
           );
           throw toHandlerFailure(error);
         }
-        this.#logger.warn(
-          `[KafkaTransport](${method}) Attempt failed, retrying | ${location} attempt=${attempt} error=${reason}`
-        );
-        await this.#sleepWithHeartbeats(
-          Math.min(initialBackoffMs * 2 ** (attempt - 1), maxBackoffMs),
-          payload
+        logger.warn(
+          `[KafkaTransport](withRetries) Attempt failed, retrying | operation=${method} ${location} attempt=${attempt} error=${reason}`
         );
+        await this.#sleeps.sleepInSlices(processingBackoff.delayFor(attempt), {
+          sliceMs: this.#settings.timings.heartbeatIntervalMs,
+          between: () => payload.heartbeat(),
+          stopped: () => this.#state === "closed"
+        });
       }
     }
   }
-  /** Sleeps in slices and heartbeats after each, so a long backoff never outlives the session timeout. */
-  async #sleepWithHeartbeats(milliseconds, payload) {
-    let remaining = milliseconds;
-    do {
-      const slice = Math.min(remaining, this.#settings.heartbeatIntervalMs);
-      await this.#sleep(slice);
-      await payload.heartbeat();
-      remaining -= slice;
-    } while (remaining > 0 && this.#state !== "closed");
-  }
-  #sleep(milliseconds) {
-    return new Promise((resolve) => {
-      const wake = () => {
-        clearTimeout(timer);
-        this.#sleepers.delete(wake);
-        resolve();
-      };
-      const timer = setTimeout(wake, milliseconds);
-      this.#sleepers.add(wake);
-    });
-  }
-  /** Whether the client exposes the instrumentation needed to follow the group membership. */
-  #tracksMembership(consumer) {
-    return consumer.on !== void 0 && consumer.events?.GROUP_JOIN !== void 0;
-  }
   #observeConsumer(consumer) {
-    if (!this.#tracksMembership(consumer)) {
+    if (!tracksMembership(consumer)) {
       this.#groupJoined = true;
       return;
     }
+    const { logger, groupId } = this.#settings;
     const names = consumer.events;
     const listen = (name, listener) => {
       if (name !== void 0) {
@@ -810,29 +1052,28 @@ var KafkaTransport = class {
     };
     listen(names.GROUP_JOIN, () => {
       this.#groupJoined = true;
-      this.#joinWaiter?.resolve();
-      this.#logger.log(`[KafkaTransport](observeConsumer) Joined group | group=${this.#groupId}`);
+      this.#groupJoin.joined();
+      logger.log(`[KafkaTransport](observeConsumer) Joined group | group=${groupId}`);
     });
     listen(names.REBALANCING, () => {
       this.#groupJoined = false;
       this.#stalledPartitions.clear();
-      this.#logger.warn(`[KafkaTransport](observeConsumer) Rebalancing | group=${this.#groupId}`);
+      logger.warn(`[KafkaTransport](observeConsumer) Rebalancing | group=${groupId}`);
     });
     listen(names.CRASH, (event) => this.#handleCrash(event));
-    listen(names.STOP, () => {
+    const leftGroup = () => {
       this.#groupJoined = false;
-    });
-    listen(names.DISCONNECT, () => {
-      this.#groupJoined = false;
-    });
+    };
+    listen(names.STOP, leftGroup);
+    listen(names.DISCONNECT, leftGroup);
   }
   #handleCrash(event) {
     const { error, restart } = event.payload ?? {};
     this.#groupJoined = false;
-    this.#logger.error(
-      `[KafkaTransport](handleCrash) Consumer crashed | group=${this.#groupId} restart=${String(restart)} error=${toErrorInfo(error).message}`
+    this.#settings.logger.error(
+      `[KafkaTransport](handleCrash) Consumer crashed | group=${this.#settings.groupId} restart=${String(restart)} error=${toErrorInfo(error).message}`
     );
-    this.#joinWaiter?.reject(error);
+    this.#groupJoin.failed(error);
     if (restart === false && this.#consuming && this.#restartLoop === void 0) {
       this.#restartLoop = this.#restartConsumer().finally(() => {
         this.#restartLoop = void 0;
@@ -844,128 +1085,29 @@ var KafkaTransport = class {
    * again, with bounded backoff, until it joined or the transport closed.
    */
   async #restartConsumer() {
-    const { restartInitialBackoffMs, restartMaxBackoffMs } = this.#settings;
+    const { logger, groupId, timings } = this.#settings;
     const consumer = this.#consumer;
     for (let attempt = 1; this.#state === "subscribed"; attempt += 1) {
-      await this.#sleep(
-        Math.min(restartInitialBackoffMs * 2 ** (attempt - 1), restartMaxBackoffMs)
-      );
+      await this.#sleeps.sleep(timings.restartBackoff.delayFor(attempt));
       if (this.#state !== "subscribed") {
         return;
       }
       await consumer.disconnect().catch(() => void 0);
       try {
         await this.#startConsuming();
-        this.#logger.log(
-          `[KafkaTransport](restartConsumer) Consumer restarted | group=${this.#groupId} attempt=${attempt}`
+        logger.log(
+          `[KafkaTransport](restartConsumer) Consumer restarted | group=${groupId} attempt=${attempt}`
         );
         return;
       } catch (error) {
-        this.#logger.error(
-          `[KafkaTransport](restartConsumer) Restart failed, will retry | group=${this.#groupId} attempt=${attempt} error=${toErrorInfo(error).message}`
+        logger.error(
+          `[KafkaTransport](restartConsumer) Restart failed, will retry | group=${groupId} attempt=${attempt} error=${toErrorInfo(error).message}`
         );
       }
     }
   }
-  #waitForGroupJoin(consumer) {
-    if (!this.#tracksMembership(consumer)) {
-      return { promise: Promise.resolve(), dispose: () => void 0 };
-    }
-    let timer;
-    const promise = new Promise((resolve, reject) => {
-      this.#joinWaiter = { resolve, reject };
-      timer = setTimeout(() => {
-        reject(
-          new RelayBusError(
-            `Consumer of transport '${this.name}' did not join group '${this.#groupId}' within ${this.#settings.startupTimeoutMs}ms`
-          )
-        );
-      }, this.#settings.startupTimeoutMs);
-    });
-    promise.catch(() => void 0);
-    return {
-      promise,
-      dispose: () => {
-        clearTimeout(timer);
-        this.#joinWaiter = void 0;
-      }
-    };
-  }
 };
-function resolveSettings(options) {
-  const maxAttempts = options.processing?.maxAttempts ?? DEFAULTS.maxAttempts;
-  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-    throw new ConfigurationError(
-      `processing.maxAttempts must be a positive integer, received ${maxAttempts}`
-    );
-  }
-  return {
-    maxAttempts,
-    initialBackoffMs: toMilliseconds(
-      options.processing?.initialBackoff ?? DEFAULTS.initialBackoff,
-      "processing.initialBackoff"
-    ),
-    maxBackoffMs: toMilliseconds(
-      options.processing?.maxBackoff ?? DEFAULTS.maxBackoff,
-      "processing.maxBackoff"
-    ),
-    startupTimeoutMs: toMilliseconds(
-      options.startupTimeout ?? DEFAULTS.startupTimeout,
-      "startupTimeout"
-    ),
-    publishTimeoutMs: toMilliseconds(
-      options.publishTimeout ?? DEFAULTS.publishTimeout,
-      "publishTimeout"
-    ),
-    heartbeatIntervalMs: Math.max(
-      1,
-      toMilliseconds(
-        options.processing?.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-        "processing.heartbeatInterval"
-      )
-    ),
-    restartInitialBackoffMs: toMilliseconds(
-      options.restart?.initialBackoff ?? DEFAULTS.restartInitialBackoff,
-      "restart.initialBackoff"
-    ),
-    restartMaxBackoffMs: toMilliseconds(
-      options.restart?.maxBackoff ?? DEFAULTS.restartMaxBackoff,
-      "restart.maxBackoff"
-    )
-  };
-}
-function toHandlerFailure(error) {
-  const { name, message } = toErrorInfo(error);
-  return new HandlerFailedError(`${name}: ${message}`);
-}
-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 { HandlerFailedError, InvalidKafkaMessageError, KafkaTransport, PublishTimeoutError, UnencodableEventError, decodeCloudEvent, decodeEnvelope, encodeEnvelope, fromHeader, fromPayloadField, plainJsonDecoder };
+export { GroupJoinTimeoutError, HandlerFailedError, InvalidKafkaMessageError, KafkaTransport, PublishTimeoutError, TransportClosedError, UnencodableEventError, cloudEventsBinary, cloudEventsStructured, decodeCloudEvent, decodeEnvelope, encodeEnvelope, jsonEnvelope, plainJsonDecoder };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map