@relaybus/kafka 0.0.0-stage → 0.0.0

package/dist/index.cjs

@@ -0,0 +1,719 @@
+'use strict';
+
+var core = require('@relaybus/core');
+
+// src/cloudevents-codec.ts
+var InvalidKafkaMessageError = class extends core.RelayBusError {
+};
+var UnencodableEventError = class extends core.NonRetryableError {
+  name = "UnencodableEventError";
+};
+var SPEC_VERSION = "1.0";
+var CONTENT_TYPE = "content-type";
+var JSON_MEDIA_TYPE = "application/json";
+var CLOUDEVENTS_PREFIX = "ce_";
+var ESCAPE_PREFIX = "x-relaybus-h-";
+var RESERVED_PREFIXES = [CLOUDEVENTS_PREFIX, "x-relaybus-"];
+var HEADER = {
+  specVersion: "ce_specversion",
+  id: "ce_id",
+  type: "ce_type",
+  source: "ce_source",
+  time: "ce_time",
+  subject: "ce_subject",
+  correlationId: "ce_correlationid",
+  causationId: "ce_causationid"
+};
+var PROTOCOL_HEADERS = /* @__PURE__ */ new Set([...Object.values(HEADER), CONTENT_TYPE]);
+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");
+function encodeEnvelope(envelope) {
+  const value = serializePayload(envelope);
+  const entries = Object.entries(envelope.headers).map(
+    ([name, headerValue]) => [escapeUserHeaderName(name), headerValue]
+  );
+  entries.push(
+    [HEADER.specVersion, SPEC_VERSION],
+    [HEADER.id, envelope.id],
+    [HEADER.type, envelope.type],
+    [HEADER.source, envelope.source],
+    [HEADER.time, formatTime(envelope)],
+    [CONTENT_TYPE, JSON_MEDIA_TYPE]
+  );
+  if (envelope.key !== null) {
+    entries.push([HEADER.subject, envelope.key]);
+  }
+  if (envelope.correlationId !== null) {
+    entries.push([HEADER.correlationId, envelope.correlationId]);
+  }
+  if (envelope.causationId !== null) {
+    entries.push([HEADER.causationId, envelope.causationId]);
+  }
+  return { key: envelope.key, value, headers: Object.fromEntries(entries) };
+}
+function serializePayload(envelope) {
+  let value;
+  try {
+    value = JSON.stringify(envelope.payload);
+  } catch (error) {
+    throw new UnencodableEventError(
+      `Event ${envelope.id} has a payload that JSON cannot represent: ${error.message}`
+    );
+  }
+  if (value === void 0) {
+    throw new UnencodableEventError(
+      `Event ${envelope.id} has a payload that JSON cannot represent (undefined, a function or a symbol)`
+    );
+  }
+  return value;
+}
+function formatTime(envelope) {
+  const year = envelope.occurredAt.getUTCFullYear();
+  if (Number.isNaN(year) || year < 0 || year > 9999) {
+    throw new UnencodableEventError(
+      `Event ${envelope.id} has an occurredAt that is not an RFC 3339 instant (invalid date or year outside 0..9999)`
+    );
+  }
+  return envelope.occurredAt.toISOString();
+}
+function decodeEnvelope(message) {
+  const headers = readHeaders(message.headers);
+  if (headers.get(HEADER.specVersion) !== SPEC_VERSION) {
+    throw invalid(`${HEADER.specVersion} must be '${SPEC_VERSION}'`);
+  }
+  const type = requireHeader(headers, HEADER.type);
+  try {
+    core.assertEventType(type);
+  } catch (error) {
+    throw invalid(`${HEADER.type} is not a valid event type: ${error.message}`);
+  }
+  assertJsonContentType(headers.get(CONTENT_TYPE));
+  return {
+    id: requireHeader(headers, HEADER.id),
+    type,
+    source: requireHeader(headers, HEADER.source),
+    key: resolveKey(headers.get(HEADER.subject), message.key),
+    payload: parsePayload(message.value),
+    headers: collectUserHeaders(headers),
+    correlationId: headers.get(HEADER.correlationId) ?? null,
+    causationId: headers.get(HEADER.causationId) ?? null,
+    occurredAt: resolveTime(headers.get(HEADER.time), message.timestamp)
+  };
+}
+function invalid(reason) {
+  return new InvalidKafkaMessageError(reason);
+}
+function escapeUserHeaderName(name) {
+  const lowered = name.toLowerCase();
+  const reserved = lowered === CONTENT_TYPE || RESERVED_PREFIXES.some((p) => lowered.startsWith(p));
+  return reserved ? `${ESCAPE_PREFIX}${name}` : name;
+}
+function readHeaders(incoming) {
+  const headers = /* @__PURE__ */ new Map();
+  for (const [name, raw] of Object.entries(incoming ?? {})) {
+    if (raw === void 0) {
+      continue;
+    }
+    if (typeof raw !== "string" && !(raw instanceof Uint8Array)) {
+      throw invalid(`Header '${name}' is repeated`);
+    }
+    headers.set(name, decodeText(raw, PROTOCOL_HEADERS.has(name), `Header '${name}'`));
+  }
+  return headers;
+}
+function decodeText(raw, strict, label) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  try {
+    return (strict ? strictUtf8 : lenientUtf8).decode(raw);
+  } catch {
+    throw invalid(`${label} is not valid UTF-8`);
+  }
+}
+function requireHeader(headers, name) {
+  const value = headers.get(name);
+  if (value === void 0 || value.length === 0) {
+    throw invalid(`Header '${name}' is missing or empty`);
+  }
+  return value;
+}
+function assertJsonContentType(contentType) {
+  const mediaType = contentType?.split(";")[0]?.trim().toLowerCase();
+  if (mediaType !== JSON_MEDIA_TYPE) {
+    throw invalid(`${CONTENT_TYPE} must be '${JSON_MEDIA_TYPE}', received '${contentType ?? ""}'`);
+  }
+}
+function resolveTime(text, recordTimestamp) {
+  if (text !== void 0 && text.length > 0) {
+    return parseTime(text);
+  }
+  const milliseconds = Number(recordTimestamp);
+  const time = new Date(milliseconds);
+  if (recordTimestamp === void 0 || recordTimestamp === "" || Number.isNaN(time.getTime())) {
+    throw invalid(`${HEADER.time} is missing and the record has no usable timestamp`);
+  }
+  return time;
+}
+function parseTime(text) {
+  const time = new Date(text);
+  if (!RFC3339_PATTERN.test(text) || Number.isNaN(time.getTime())) {
+    throw invalid(`${HEADER.time} is not an RFC 3339 timestamp: '${text}'`);
+  }
+  return time;
+}
+function parsePayload(value) {
+  if (value === null) {
+    throw invalid("Message has no value");
+  }
+  const text = decodeText(value, true, "Message value");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw invalid("Message value is not valid JSON");
+  }
+}
+function resolveKey(subject, recordKey) {
+  const keyText = recordKey === null ? null : decodeText(recordKey, true, "Message key");
+  if (subject !== void 0 && keyText !== null && subject !== keyText) {
+    throw invalid(`${HEADER.subject} does not match the message key`);
+  }
+  return subject ?? keyText;
+}
+function collectUserHeaders(headers) {
+  const entries = [];
+  for (const [name, value] of headers) {
+    if (!PROTOCOL_HEADERS.has(name)) {
+      entries.push([
+        name.startsWith(ESCAPE_PREFIX) ? name.slice(ESCAPE_PREFIX.length) : name,
+        value
+      ]);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function toOutgoingHeaders(incoming) {
+  const entries = [];
+  for (const [name, raw] of Object.entries(incoming ?? {})) {
+    if (raw !== void 0) {
+      entries.push([
+        name,
+        Array.isArray(raw) ? raw.map(toBufferOrString) : toBufferOrString(raw)
+      ]);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function toBufferOrString(value) {
+  return typeof value === "string" ? value : Buffer.from(value);
+}
+var PublishTimeoutError = class extends core.RelayBusError {
+  name = "PublishTimeoutError";
+};
+var HandlerFailedError = class extends core.RelayBusError {
+  name = "HandlerFailedError";
+};
+var DEFAULTS = {
+  name: "kafka",
+  maxInFlightRequests: 1,
+  maxAttempts: 5,
+  initialBackoff: "200ms",
+  maxBackoff: "5s",
+  startupTimeout: "30s",
+  publishTimeout: "30s",
+  heartbeatInterval: "1s",
+  restartInitialBackoff: "1s",
+  restartMaxBackoff: "30s"
+};
+var KafkaTransport = class {
+  name;
+  #kafka;
+  #groupId;
+  #fromBeginning;
+  #maxInFlightRequests;
+  #producerConfig;
+  #consumerConfig;
+  #invalidPolicy;
+  #logger;
+  #settings;
+  #sleepers = /* @__PURE__ */ new Set();
+  #state = "idle";
+  #producer;
+  #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 core.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.#logger = options.logger ?? console;
+    this.#settings = resolveSettings(options);
+  }
+  /**
+   * True while the consumer is joined to its group, not between a crash or
+   * rebalance and the next join, and no partition is stalled on a record whose
+   * handler keeps failing. Use it for readiness so a consumer that silently
+   * stopped is noticed.
+   */
+  isConsuming() {
+    return this.#state === "subscribed" && this.#groupJoined && this.#stalledPartitions.size === 0;
+  }
+  /**
+   * True once the producer is connected and, if the transport subscribed, the
+   * consumer is consuming. False before `connect`, after `close` and while a
+   * dead consumer is being restarted.
+   */
+  isReady() {
+    if (this.#state === "closed" || !this.#producerConnected) {
+      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();
+  }
+  async publish(envelope, destination) {
+    const producer = await this.#connectedProducer();
+    const { key, value, headers } = encodeEnvelope(envelope);
+    await this.#send(producer, {
+      topic: destination,
+      acks: -1,
+      messages: [{ key, value, headers }]
+    });
+  }
+  /**
+   * Starts the consumer and resolves once it joined its group, so a start-up
+   * that cannot consume fails loudly instead of looking healthy.
+   *
+   * @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);
+    this.#state = "subscribed";
+    const consumer = this.#kafka.consumer({ ...this.#consumerConfig, groupId: this.#groupId });
+    this.#consumer = consumer;
+    this.#observeConsumer(consumer);
+    const start = () => this.#startConsumer(consumer, [...destinations], onMessage);
+    this.#startConsuming = start;
+    try {
+      await start();
+    } catch (error) {
+      await consumer.disconnect().catch(() => void 0);
+      this.#groupJoined = false;
+      this.#consumer = void 0;
+      this.#state = "idle";
+      throw error;
+    }
+    this.#consuming = true;
+    this.#logger.log(
+      `[KafkaTransport](subscribe) Consuming | transport=${this.name} group=${this.#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;
+    this.#groupJoined = false;
+    this.#producerConnected = false;
+    for (const wake of this.#sleepers) {
+      wake();
+    }
+    this.#joinWaiter?.reject(new core.RelayBusError(`Transport '${this.name}' is closed`));
+    await this.#restartLoop;
+    const producer = await pendingProducer?.catch(() => void 0);
+    const results = await Promise.allSettled([
+      this.#consumer?.disconnect(),
+      producer?.disconnect()
+    ]);
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure !== void 0) {
+      throw failure.reason;
+    }
+  }
+  #assertCanSubscribe(destinations) {
+    if (this.#state === "closed") {
+      throw new core.RelayBusError(`Transport '${this.name}' is closed`);
+    }
+    if (this.#state === "subscribed") {
+      throw new core.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 core.ConfigurationError(`Transport '${this.name}' needs a groupId to subscribe`);
+    }
+    if (destinations.length === 0) {
+      throw new core.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 core.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 core.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) {
+    let envelope;
+    try {
+      envelope = decodeEnvelope(payload.message);
+    } catch (error) {
+      if (!(error instanceof InvalidKafkaMessageError)) {
+        throw toHandlerFailure(error);
+      }
+      await this.#withRetries(
+        payload,
+        "handleInvalid",
+        () => this.#handleInvalid(payload, error.message)
+      );
+      return;
+    }
+    await this.#withRetries(payload, "deliver", async () => {
+      try {
+        await onMessage(envelope);
+      } catch (error) {
+        if (!(error instanceof core.NonRetryableError)) {
+          throw error;
+        }
+        await this.#handleInvalid(payload, error.message);
+      }
+    });
+  }
+  async #handleInvalid(payload, reason) {
+    const { topic, partition, message } = payload;
+    const location = `topic=${topic} partition=${partition} offset=${message.offset}`;
+    const policy = this.#invalidPolicy;
+    const deadLetterTopic = this.#deadLetterTopicFor(topic);
+    if (policy === "skip") {
+      this.#logger.error(
+        `[KafkaTransport](handleInvalid) Skipping malformed message | ${location} reason=${reason}`
+      );
+    } else if (typeof policy === "function") {
+      await policy({
+        topic,
+        partition,
+        offset: message.offset,
+        reason,
+        key: message.key,
+        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
+            }
+          }
+        ]
+      });
+      this.#logger.error(
+        `[KafkaTransport](handleInvalid) Dead-lettered malformed message | ${location} deadLetterTopic=${deadLetterTopic} reason=${reason}`
+      );
+    }
+  }
+  /**
+   * Runs `operation` up to `maxAttempts` times with exponential backoff. The
+   * 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;
+    const location = `topic=${payload.topic} partition=${payload.partition} offset=${payload.message.offset}`;
+    const partitionKey = `${payload.topic}:${payload.partition}`;
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        await operation();
+        this.#stalledPartitions.delete(partitionKey);
+        return;
+      } catch (error) {
+        const reason = core.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}`
+          );
+          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
+        );
+      }
+    }
+  }
+  /** 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)) {
+      this.#groupJoined = true;
+      return;
+    }
+    const names = consumer.events;
+    const listen = (name, listener) => {
+      if (name !== void 0) {
+        consumer.on(name, listener);
+      }
+    };
+    listen(names.GROUP_JOIN, () => {
+      this.#groupJoined = true;
+      this.#joinWaiter?.resolve();
+      this.#logger.log(`[KafkaTransport](observeConsumer) Joined group | group=${this.#groupId}`);
+    });
+    listen(names.REBALANCING, () => {
+      this.#groupJoined = false;
+      this.#stalledPartitions.clear();
+      this.#logger.warn(`[KafkaTransport](observeConsumer) Rebalancing | group=${this.#groupId}`);
+    });
+    listen(names.CRASH, (event) => this.#handleCrash(event));
+    listen(names.STOP, () => {
+      this.#groupJoined = false;
+    });
+    listen(names.DISCONNECT, () => {
+      this.#groupJoined = false;
+    });
+  }
+  #handleCrash(event) {
+    const { error, restart } = event.payload ?? {};
+    this.#groupJoined = false;
+    this.#logger.error(
+      `[KafkaTransport](handleCrash) Consumer crashed | group=${this.#groupId} restart=${String(restart)} error=${core.toErrorInfo(error).message}`
+    );
+    this.#joinWaiter?.reject(error);
+    if (restart === false && this.#consuming && this.#restartLoop === void 0) {
+      this.#restartLoop = this.#restartConsumer().finally(() => {
+        this.#restartLoop = void 0;
+      });
+    }
+  }
+  /**
+   * The client gave up on the consumer (`restart=false`): reconnect it and run
+   * again, with bounded backoff, until it joined or the transport closed.
+   */
+  async #restartConsumer() {
+    const { restartInitialBackoffMs, restartMaxBackoffMs } = 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)
+      );
+      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}`
+        );
+        return;
+      } catch (error) {
+        this.#logger.error(
+          `[KafkaTransport](restartConsumer) Restart failed, will retry | group=${this.#groupId} attempt=${attempt} error=${core.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 core.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 core.ConfigurationError(
+      `processing.maxAttempts must be a positive integer, received ${maxAttempts}`
+    );
+  }
+  return {
+    maxAttempts,
+    initialBackoffMs: core.toMilliseconds(
+      options.processing?.initialBackoff ?? DEFAULTS.initialBackoff,
+      "processing.initialBackoff"
+    ),
+    maxBackoffMs: core.toMilliseconds(
+      options.processing?.maxBackoff ?? DEFAULTS.maxBackoff,
+      "processing.maxBackoff"
+    ),
+    startupTimeoutMs: core.toMilliseconds(
+      options.startupTimeout ?? DEFAULTS.startupTimeout,
+      "startupTimeout"
+    ),
+    publishTimeoutMs: core.toMilliseconds(
+      options.publishTimeout ?? DEFAULTS.publishTimeout,
+      "publishTimeout"
+    ),
+    heartbeatIntervalMs: Math.max(
+      1,
+      core.toMilliseconds(
+        options.processing?.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
+        "processing.heartbeatInterval"
+      )
+    ),
+    restartInitialBackoffMs: core.toMilliseconds(
+      options.restart?.initialBackoff ?? DEFAULTS.restartInitialBackoff,
+      "restart.initialBackoff"
+    ),
+    restartMaxBackoffMs: core.toMilliseconds(
+      options.restart?.maxBackoff ?? DEFAULTS.restartMaxBackoff,
+      "restart.maxBackoff"
+    )
+  };
+}
+function toHandlerFailure(error) {
+  const { name, message } = core.toErrorInfo(error);
+  return new HandlerFailedError(`${name}: ${message}`);
+}
+
+exports.HandlerFailedError = HandlerFailedError;
+exports.InvalidKafkaMessageError = InvalidKafkaMessageError;
+exports.KafkaTransport = KafkaTransport;
+exports.PublishTimeoutError = PublishTimeoutError;
+exports.UnencodableEventError = UnencodableEventError;
+exports.decodeEnvelope = decodeEnvelope;
+exports.encodeEnvelope = encodeEnvelope;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map