@drarzter/kafka-client 0.5.4 → 0.5.6

package/dist/chunk-3QXTW66R.mjs

@@ -1,947 +0,0 @@
-// src/client/kafka.client.ts
-import { KafkaJS } from "@confluentinc/kafka-javascript";
-
-// src/client/envelope.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-var HEADER_EVENT_ID = "x-event-id";
-var HEADER_CORRELATION_ID = "x-correlation-id";
-var HEADER_TIMESTAMP = "x-timestamp";
-var HEADER_SCHEMA_VERSION = "x-schema-version";
-var HEADER_TRACEPARENT = "traceparent";
-var envelopeStorage = new AsyncLocalStorage();
-function getEnvelopeContext() {
-  return envelopeStorage.getStore();
-}
-function runWithEnvelopeContext(ctx, fn) {
-  return envelopeStorage.run(ctx, fn);
-}
-function buildEnvelopeHeaders(options = {}) {
-  const ctx = getEnvelopeContext();
-  const correlationId = options.correlationId ?? ctx?.correlationId ?? randomUUID();
-  const eventId = options.eventId ?? randomUUID();
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const schemaVersion = String(options.schemaVersion ?? 1);
-  const envelope = {
-    [HEADER_EVENT_ID]: eventId,
-    [HEADER_CORRELATION_ID]: correlationId,
-    [HEADER_TIMESTAMP]: timestamp,
-    [HEADER_SCHEMA_VERSION]: schemaVersion
-  };
-  if (ctx?.traceparent) {
-    envelope[HEADER_TRACEPARENT] = ctx.traceparent;
-  }
-  return { ...envelope, ...options.headers };
-}
-function decodeHeaders(raw) {
-  if (!raw) return {};
-  const result = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (value === void 0) continue;
-    if (Array.isArray(value)) {
-      result[key] = value.map((v) => Buffer.isBuffer(v) ? v.toString() : v).join(",");
-    } else {
-      result[key] = Buffer.isBuffer(value) ? value.toString() : value;
-    }
-  }
-  return result;
-}
-function extractEnvelope(payload, headers, topic2, partition, offset) {
-  return {
-    payload,
-    topic: topic2,
-    partition,
-    offset,
-    eventId: headers[HEADER_EVENT_ID] ?? randomUUID(),
-    correlationId: headers[HEADER_CORRELATION_ID] ?? randomUUID(),
-    timestamp: headers[HEADER_TIMESTAMP] ?? (/* @__PURE__ */ new Date()).toISOString(),
-    schemaVersion: Number(headers[HEADER_SCHEMA_VERSION] ?? 1),
-    traceparent: headers[HEADER_TRACEPARENT],
-    headers
-  };
-}
-
-// src/client/errors.ts
-var KafkaProcessingError = class extends Error {
-  constructor(message, topic2, originalMessage, options) {
-    super(message, options);
-    this.topic = topic2;
-    this.originalMessage = originalMessage;
-    this.name = "KafkaProcessingError";
-    if (options?.cause) this.cause = options.cause;
-  }
-};
-var KafkaValidationError = class extends Error {
-  constructor(topic2, originalMessage, options) {
-    super(`Schema validation failed for topic "${topic2}"`, options);
-    this.topic = topic2;
-    this.originalMessage = originalMessage;
-    this.name = "KafkaValidationError";
-    if (options?.cause) this.cause = options.cause;
-  }
-};
-var KafkaRetryExhaustedError = class extends KafkaProcessingError {
-  constructor(topic2, originalMessage, attempts, options) {
-    super(
-      `Message processing failed after ${attempts} attempts on topic "${topic2}"`,
-      topic2,
-      originalMessage,
-      options
-    );
-    this.attempts = attempts;
-    this.name = "KafkaRetryExhaustedError";
-  }
-};
-
-// src/client/consumer-pipeline.ts
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function parseJsonMessage(raw, topic2, logger) {
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    logger.error(
-      `Failed to parse message from topic ${topic2}:`,
-      toError(error).stack
-    );
-    return null;
-  }
-}
-async function validateWithSchema(message, raw, topic2, schemaMap, interceptors, dlq, deps) {
-  const schema = schemaMap.get(topic2);
-  if (!schema) return message;
-  try {
-    return await schema.parse(message);
-  } catch (error) {
-    const err = toError(error);
-    const validationError = new KafkaValidationError(topic2, message, {
-      cause: err
-    });
-    deps.logger.error(
-      `Schema validation failed for topic ${topic2}:`,
-      err.message
-    );
-    if (dlq) {
-      await sendToDlq(topic2, raw, deps, {
-        error: validationError,
-        attempt: 0,
-        originalHeaders: deps.originalHeaders
-      });
-    } else {
-      await deps.onMessageLost?.({ topic: topic2, error: validationError, attempt: 0, headers: deps.originalHeaders ?? {} });
-    }
-    const errorEnvelope = extractEnvelope(message, deps.originalHeaders ?? {}, topic2, -1, "");
-    for (const interceptor of interceptors) {
-      await interceptor.onError?.(errorEnvelope, validationError);
-    }
-    return null;
-  }
-}
-async function sendToDlq(topic2, rawMessage, deps, meta) {
-  const dlqTopic = `${topic2}.dlq`;
-  const headers = {
-    ...meta?.originalHeaders ?? {},
-    "x-dlq-original-topic": topic2,
-    "x-dlq-failed-at": (/* @__PURE__ */ new Date()).toISOString(),
-    "x-dlq-error-message": meta?.error.message ?? "unknown",
-    "x-dlq-error-stack": meta?.error.stack?.slice(0, 2e3) ?? "",
-    "x-dlq-attempt-count": String(meta?.attempt ?? 0)
-  };
-  try {
-    await deps.producer.send({
-      topic: dlqTopic,
-      messages: [{ value: rawMessage, headers }]
-    });
-    deps.logger.warn(`Message sent to DLQ: ${dlqTopic}`);
-  } catch (error) {
-    deps.logger.error(
-      `Failed to send message to DLQ ${dlqTopic}:`,
-      toError(error).stack
-    );
-  }
-}
-var RETRY_HEADER_ATTEMPT = "x-retry-attempt";
-var RETRY_HEADER_AFTER = "x-retry-after";
-var RETRY_HEADER_MAX_RETRIES = "x-retry-max-retries";
-var RETRY_HEADER_ORIGINAL_TOPIC = "x-retry-original-topic";
-async function sendToRetryTopic(originalTopic, rawMessages, attempt, maxRetries, delayMs, originalHeaders, deps) {
-  const retryTopic = `${originalTopic}.retry`;
-  const {
-    [RETRY_HEADER_ATTEMPT]: _a,
-    [RETRY_HEADER_AFTER]: _b,
-    [RETRY_HEADER_MAX_RETRIES]: _c,
-    [RETRY_HEADER_ORIGINAL_TOPIC]: _d,
-    ...userHeaders
-  } = originalHeaders;
-  const headers = {
-    ...userHeaders,
-    [RETRY_HEADER_ATTEMPT]: String(attempt),
-    [RETRY_HEADER_AFTER]: String(Date.now() + delayMs),
-    [RETRY_HEADER_MAX_RETRIES]: String(maxRetries),
-    [RETRY_HEADER_ORIGINAL_TOPIC]: originalTopic
-  };
-  try {
-    for (const raw of rawMessages) {
-      await deps.producer.send({ topic: retryTopic, messages: [{ value: raw, headers }] });
-    }
-    deps.logger.warn(
-      `Message queued in retry topic ${retryTopic} (attempt ${attempt}/${maxRetries})`
-    );
-  } catch (error) {
-    deps.logger.error(
-      `Failed to send message to retry topic ${retryTopic}:`,
-      toError(error).stack
-    );
-  }
-}
-async function executeWithRetry(fn, ctx, deps) {
-  const { envelope, rawMessages, interceptors, dlq, retry, isBatch, retryTopics } = ctx;
-  const maxAttempts = retryTopics ? 1 : retry ? retry.maxRetries + 1 : 1;
-  const backoffMs = retry?.backoffMs ?? 1e3;
-  const maxBackoffMs = retry?.maxBackoffMs ?? 3e4;
-  const envelopes = Array.isArray(envelope) ? envelope : [envelope];
-  const topic2 = envelopes[0]?.topic ?? "unknown";
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const cleanups = [];
-    try {
-      for (const env of envelopes) {
-        for (const inst of deps.instrumentation) {
-          const cleanup = inst.beforeConsume?.(env);
-          if (typeof cleanup === "function") cleanups.push(cleanup);
-        }
-      }
-      for (const env of envelopes) {
-        for (const interceptor of interceptors) {
-          await interceptor.before?.(env);
-        }
-      }
-      await fn();
-      for (const env of envelopes) {
-        for (const interceptor of interceptors) {
-          await interceptor.after?.(env);
-        }
-      }
-      for (const cleanup of cleanups) cleanup();
-      return;
-    } catch (error) {
-      const err = toError(error);
-      const isLastAttempt = attempt === maxAttempts;
-      for (const env of envelopes) {
-        for (const inst of deps.instrumentation) {
-          inst.onConsumeError?.(env, err);
-        }
-      }
-      for (const cleanup of cleanups) cleanup();
-      if (isLastAttempt && maxAttempts > 1) {
-        const exhaustedError = new KafkaRetryExhaustedError(
-          topic2,
-          envelopes.map((e) => e.payload),
-          maxAttempts,
-          { cause: err }
-        );
-        for (const env of envelopes) {
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(env, exhaustedError);
-          }
-        }
-      } else {
-        for (const env of envelopes) {
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(env, err);
-          }
-        }
-      }
-      deps.logger.error(
-        `Error processing ${isBatch ? "batch" : "message"} from topic ${topic2} (attempt ${attempt}/${maxAttempts}):`,
-        err.stack
-      );
-      if (retryTopics && retry) {
-        const cap = Math.min(backoffMs, maxBackoffMs);
-        const delay = Math.floor(Math.random() * cap);
-        await sendToRetryTopic(
-          topic2,
-          rawMessages,
-          1,
-          retry.maxRetries,
-          delay,
-          envelopes[0]?.headers ?? {},
-          deps
-        );
-      } else if (isLastAttempt) {
-        if (dlq) {
-          const dlqMeta = {
-            error: err,
-            attempt,
-            originalHeaders: envelopes[0]?.headers
-          };
-          for (const raw of rawMessages) {
-            await sendToDlq(topic2, raw, deps, dlqMeta);
-          }
-        } else {
-          await deps.onMessageLost?.({
-            topic: topic2,
-            error: err,
-            attempt,
-            headers: envelopes[0]?.headers ?? {}
-          });
-        }
-      } else {
-        const cap = Math.min(backoffMs * 2 ** (attempt - 1), maxBackoffMs);
-        await sleep(Math.random() * cap);
-      }
-    }
-  }
-}
-
-// src/client/subscribe-retry.ts
-async function subscribeWithRetry(consumer, topics, logger, retryOpts) {
-  const maxAttempts = retryOpts?.retries ?? 5;
-  const backoffMs = retryOpts?.backoffMs ?? 5e3;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      await consumer.subscribe({ topics });
-      return;
-    } catch (error) {
-      if (attempt === maxAttempts) throw error;
-      const msg = toError(error).message;
-      logger.warn(
-        `Failed to subscribe to [${topics.join(", ")}] (attempt ${attempt}/${maxAttempts}): ${msg}. Retrying in ${backoffMs}ms...`
-      );
-      await sleep(backoffMs);
-    }
-  }
-}
-
-// src/client/kafka.client.ts
-var { Kafka: KafkaClass, logLevel: KafkaLogLevel } = KafkaJS;
-var KafkaClient = class {
-  kafka;
-  producer;
-  txProducer;
-  consumers = /* @__PURE__ */ new Map();
-  admin;
-  logger;
-  autoCreateTopicsEnabled;
-  strictSchemasEnabled;
-  numPartitions;
-  ensuredTopics = /* @__PURE__ */ new Set();
-  defaultGroupId;
-  schemaRegistry = /* @__PURE__ */ new Map();
-  runningConsumers = /* @__PURE__ */ new Map();
-  instrumentation;
-  onMessageLost;
-  isAdminConnected = false;
-  clientId;
-  constructor(clientId, groupId, brokers, options) {
-    this.clientId = clientId;
-    this.defaultGroupId = groupId;
-    this.logger = options?.logger ?? {
-      log: (msg) => console.log(`[KafkaClient:${clientId}] ${msg}`),
-      warn: (msg, ...args) => console.warn(`[KafkaClient:${clientId}] ${msg}`, ...args),
-      error: (msg, ...args) => console.error(`[KafkaClient:${clientId}] ${msg}`, ...args)
-    };
-    this.autoCreateTopicsEnabled = options?.autoCreateTopics ?? false;
-    this.strictSchemasEnabled = options?.strictSchemas ?? true;
-    this.numPartitions = options?.numPartitions ?? 1;
-    this.instrumentation = options?.instrumentation ?? [];
-    this.onMessageLost = options?.onMessageLost;
-    this.kafka = new KafkaClass({
-      kafkaJS: {
-        clientId: this.clientId,
-        brokers,
-        logLevel: KafkaLogLevel.ERROR
-      }
-    });
-    this.producer = this.kafka.producer({
-      kafkaJS: {
-        acks: -1
-      }
-    });
-    this.admin = this.kafka.admin();
-  }
-  async sendMessage(topicOrDesc, message, options = {}) {
-    const payload = await this.buildSendPayload(topicOrDesc, [
-      {
-        value: message,
-        key: options.key,
-        headers: options.headers,
-        correlationId: options.correlationId,
-        schemaVersion: options.schemaVersion,
-        eventId: options.eventId
-      }
-    ]);
-    await this.ensureTopic(payload.topic);
-    await this.producer.send(payload);
-    for (const inst of this.instrumentation) {
-      inst.afterSend?.(payload.topic);
-    }
-  }
-  async sendBatch(topicOrDesc, messages) {
-    const payload = await this.buildSendPayload(topicOrDesc, messages);
-    await this.ensureTopic(payload.topic);
-    await this.producer.send(payload);
-    for (const inst of this.instrumentation) {
-      inst.afterSend?.(payload.topic);
-    }
-  }
-  /** Execute multiple sends atomically. Commits on success, aborts on error. */
-  async transaction(fn) {
-    if (!this.txProducer) {
-      this.txProducer = this.kafka.producer({
-        kafkaJS: {
-          acks: -1,
-          idempotent: true,
-          transactionalId: `${this.clientId}-tx`,
-          maxInFlightRequests: 1
-        }
-      });
-      await this.txProducer.connect();
-    }
-    const tx = await this.txProducer.transaction();
-    try {
-      const ctx = {
-        send: async (topicOrDesc, message, options = {}) => {
-          const payload = await this.buildSendPayload(topicOrDesc, [
-            {
-              value: message,
-              key: options.key,
-              headers: options.headers,
-              correlationId: options.correlationId,
-              schemaVersion: options.schemaVersion,
-              eventId: options.eventId
-            }
-          ]);
-          await this.ensureTopic(payload.topic);
-          await tx.send(payload);
-        },
-        sendBatch: async (topicOrDesc, messages) => {
-          const payload = await this.buildSendPayload(topicOrDesc, messages);
-          await this.ensureTopic(payload.topic);
-          await tx.send(payload);
-        }
-      };
-      await fn(ctx);
-      await tx.commit();
-    } catch (error) {
-      try {
-        await tx.abort();
-      } catch (abortError) {
-        this.logger.error(
-          "Failed to abort transaction:",
-          toError(abortError).message
-        );
-      }
-      throw error;
-    }
-  }
-  // ── Producer lifecycle ───────────────────────────────────────────
-  /** Connect the idempotent producer. Called automatically by `KafkaModule.register()`. */
-  async connectProducer() {
-    await this.producer.connect();
-    this.logger.log("Producer connected");
-  }
-  async disconnectProducer() {
-    await this.producer.disconnect();
-    this.logger.log("Producer disconnected");
-  }
-  async startConsumer(topics, handleMessage, options = {}) {
-    if (options.retryTopics && !options.retry) {
-      throw new Error(
-        "retryTopics requires retry to be configured \u2014 set retry.maxRetries to enable the retry topic chain"
-      );
-    }
-    const { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachMessage", options);
-    const deps = { logger: this.logger, producer: this.producer, instrumentation: this.instrumentation, onMessageLost: this.onMessageLost };
-    await consumer.run({
-      eachMessage: async ({ topic: topic2, partition, message }) => {
-        if (!message.value) {
-          this.logger.warn(`Received empty message from topic ${topic2}`);
-          return;
-        }
-        const raw = message.value.toString();
-        const parsed = parseJsonMessage(raw, topic2, this.logger);
-        if (parsed === null) return;
-        const headers = decodeHeaders(message.headers);
-        const validated = await validateWithSchema(
-          parsed,
-          raw,
-          topic2,
-          schemaMap,
-          interceptors,
-          dlq,
-          { ...deps, originalHeaders: headers }
-        );
-        if (validated === null) return;
-        const envelope = extractEnvelope(
-          validated,
-          headers,
-          topic2,
-          partition,
-          message.offset
-        );
-        await executeWithRetry(
-          () => runWithEnvelopeContext(
-            { correlationId: envelope.correlationId, traceparent: envelope.traceparent },
-            () => handleMessage(envelope)
-          ),
-          { envelope, rawMessages: [raw], interceptors, dlq, retry, retryTopics: options.retryTopics },
-          deps
-        );
-      }
-    });
-    this.runningConsumers.set(gid, "eachMessage");
-    if (options.retryTopics && retry) {
-      await this.startRetryTopicConsumers(
-        topicNames,
-        gid,
-        handleMessage,
-        retry,
-        dlq,
-        interceptors,
-        schemaMap
-      );
-    }
-  }
-  async startBatchConsumer(topics, handleBatch, options = {}) {
-    const { consumer, schemaMap, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachBatch", options);
-    const deps = { logger: this.logger, producer: this.producer, instrumentation: this.instrumentation, onMessageLost: this.onMessageLost };
-    await consumer.run({
-      eachBatch: async ({
-        batch,
-        heartbeat,
-        resolveOffset,
-        commitOffsetsIfNecessary
-      }) => {
-        const envelopes = [];
-        const rawMessages = [];
-        for (const message of batch.messages) {
-          if (!message.value) {
-            this.logger.warn(
-              `Received empty message from topic ${batch.topic}`
-            );
-            continue;
-          }
-          const raw = message.value.toString();
-          const parsed = parseJsonMessage(raw, batch.topic, this.logger);
-          if (parsed === null) continue;
-          const headers = decodeHeaders(message.headers);
-          const validated = await validateWithSchema(
-            parsed,
-            raw,
-            batch.topic,
-            schemaMap,
-            interceptors,
-            dlq,
-            { ...deps, originalHeaders: headers }
-          );
-          if (validated === null) continue;
-          envelopes.push(
-            extractEnvelope(validated, headers, batch.topic, batch.partition, message.offset)
-          );
-          rawMessages.push(raw);
-        }
-        if (envelopes.length === 0) return;
-        const meta = {
-          partition: batch.partition,
-          highWatermark: batch.highWatermark,
-          heartbeat,
-          resolveOffset,
-          commitOffsetsIfNecessary
-        };
-        await executeWithRetry(
-          () => handleBatch(envelopes, meta),
-          {
-            envelope: envelopes,
-            rawMessages: batch.messages.filter((m) => m.value).map((m) => m.value.toString()),
-            interceptors,
-            dlq,
-            retry,
-            isBatch: true
-          },
-          deps
-        );
-      }
-    });
-    this.runningConsumers.set(gid, "eachBatch");
-  }
-  // ── Consumer lifecycle ───────────────────────────────────────────
-  async stopConsumer(groupId) {
-    if (groupId !== void 0) {
-      const consumer = this.consumers.get(groupId);
-      if (!consumer) {
-        this.logger.warn(`stopConsumer: no active consumer for group "${groupId}"`);
-        return;
-      }
-      await consumer.disconnect().catch(() => {
-      });
-      this.consumers.delete(groupId);
-      this.runningConsumers.delete(groupId);
-      this.logger.log(`Consumer disconnected: group "${groupId}"`);
-    } else {
-      const tasks = Array.from(this.consumers.values()).map(
-        (c) => c.disconnect().catch(() => {
-        })
-      );
-      await Promise.allSettled(tasks);
-      this.consumers.clear();
-      this.runningConsumers.clear();
-      this.logger.log("All consumers disconnected");
-    }
-  }
-  /** Check broker connectivity and return status, clientId, and available topics. */
-  async checkStatus() {
-    if (!this.isAdminConnected) {
-      await this.admin.connect();
-      this.isAdminConnected = true;
-    }
-    const topics = await this.admin.listTopics();
-    return { status: "up", clientId: this.clientId, topics };
-  }
-  getClientId() {
-    return this.clientId;
-  }
-  /** Gracefully disconnect producer, all consumers, and admin. */
-  async disconnect() {
-    const tasks = [this.producer.disconnect()];
-    if (this.txProducer) {
-      tasks.push(this.txProducer.disconnect());
-      this.txProducer = void 0;
-    }
-    for (const consumer of this.consumers.values()) {
-      tasks.push(consumer.disconnect());
-    }
-    if (this.isAdminConnected) {
-      tasks.push(this.admin.disconnect());
-      this.isAdminConnected = false;
-    }
-    await Promise.allSettled(tasks);
-    this.consumers.clear();
-    this.runningConsumers.clear();
-    this.logger.log("All connections closed");
-  }
-  // ── Retry topic chain ────────────────────────────────────────────
-  /**
-   * Auto-start companion consumers on `<topic>.retry` for each original topic.
-   * Called by `startConsumer` when `retryTopics: true`.
-   *
-   * Flow per message:
-   *   1. Sleep until `x-retry-after` (scheduled by the main consumer or previous retry hop)
-   *   2. Call the original handler
-   *   3. On failure: if retries remain → re-send to `<originalTopic>.retry` with incremented attempt
-   *                  if exhausted       → DLQ or onMessageLost
-   */
-  async startRetryTopicConsumers(originalTopics, originalGroupId, handleMessage, retry, dlq, interceptors, schemaMap) {
-    const retryTopicNames = originalTopics.map((t) => `${t}.retry`);
-    const retryGroupId = `${originalGroupId}-retry`;
-    const backoffMs = retry.backoffMs ?? 1e3;
-    const maxBackoffMs = retry.maxBackoffMs ?? 3e4;
-    const deps = {
-      logger: this.logger,
-      producer: this.producer,
-      instrumentation: this.instrumentation,
-      onMessageLost: this.onMessageLost
-    };
-    for (const rt of retryTopicNames) {
-      await this.ensureTopic(rt);
-    }
-    const consumer = this.getOrCreateConsumer(retryGroupId, false, true);
-    await consumer.connect();
-    await subscribeWithRetry(consumer, retryTopicNames, this.logger);
-    await consumer.run({
-      eachMessage: async ({ topic: retryTopic, partition, message }) => {
-        if (!message.value) return;
-        const raw = message.value.toString();
-        const parsed = parseJsonMessage(raw, retryTopic, this.logger);
-        if (parsed === null) return;
-        const headers = decodeHeaders(message.headers);
-        const originalTopic = headers[RETRY_HEADER_ORIGINAL_TOPIC] ?? retryTopic.replace(/\.retry$/, "");
-        const currentAttempt = parseInt(
-          headers[RETRY_HEADER_ATTEMPT] ?? "1",
-          10
-        );
-        const maxRetries = parseInt(
-          headers[RETRY_HEADER_MAX_RETRIES] ?? String(retry.maxRetries),
-          10
-        );
-        const retryAfter = parseInt(
-          headers[RETRY_HEADER_AFTER] ?? "0",
-          10
-        );
-        const remaining = retryAfter - Date.now();
-        if (remaining > 0) {
-          consumer.pause([{ topic: retryTopic, partitions: [partition] }]);
-          await sleep(remaining);
-          consumer.resume([{ topic: retryTopic, partitions: [partition] }]);
-        }
-        const validated = await validateWithSchema(
-          parsed,
-          raw,
-          originalTopic,
-          schemaMap,
-          interceptors,
-          dlq,
-          { ...deps, originalHeaders: headers }
-        );
-        if (validated === null) return;
-        const envelope = extractEnvelope(
-          validated,
-          headers,
-          originalTopic,
-          partition,
-          message.offset
-        );
-        try {
-          const cleanups = [];
-          for (const inst of this.instrumentation) {
-            const c = inst.beforeConsume?.(envelope);
-            if (typeof c === "function") cleanups.push(c);
-          }
-          for (const interceptor of interceptors) await interceptor.before?.(envelope);
-          await runWithEnvelopeContext(
-            { correlationId: envelope.correlationId, traceparent: envelope.traceparent },
-            () => handleMessage(envelope)
-          );
-          for (const interceptor of interceptors) await interceptor.after?.(envelope);
-          for (const cleanup of cleanups) cleanup();
-        } catch (error) {
-          const err = toError(error);
-          const nextAttempt = currentAttempt + 1;
-          const exhausted = currentAttempt >= maxRetries;
-          for (const inst of this.instrumentation) inst.onConsumeError?.(envelope, err);
-          const reportedError = exhausted && maxRetries > 1 ? new KafkaRetryExhaustedError(originalTopic, [envelope.payload], maxRetries, { cause: err }) : err;
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(envelope, reportedError);
-          }
-          this.logger.error(
-            `Retry consumer error for ${originalTopic} (attempt ${currentAttempt}/${maxRetries}):`,
-            err.stack
-          );
-          if (!exhausted) {
-            const cap = Math.min(backoffMs * 2 ** currentAttempt, maxBackoffMs);
-            const delay = Math.floor(Math.random() * cap);
-            await sendToRetryTopic(
-              originalTopic,
-              [raw],
-              nextAttempt,
-              maxRetries,
-              delay,
-              headers,
-              deps
-            );
-          } else if (dlq) {
-            await sendToDlq(originalTopic, raw, deps, {
-              error: err,
-              // +1 to account for the main consumer's initial attempt before
-              // routing to the retry topic, making this consistent with the
-              // in-process retry path where attempt counts all tries.
-              attempt: currentAttempt + 1,
-              originalHeaders: headers
-            });
-          } else {
-            await deps.onMessageLost?.({
-              topic: originalTopic,
-              error: err,
-              attempt: currentAttempt,
-              headers
-            });
-          }
-        }
-      }
-    });
-    this.runningConsumers.set(retryGroupId, "eachMessage");
-    await this.waitForPartitionAssignment(consumer, retryTopicNames);
-    this.logger.log(
-      `Retry topic consumers started for: ${originalTopics.join(", ")} (group: ${retryGroupId})`
-    );
-  }
-  // ── Private helpers ──────────────────────────────────────────────
-  /**
-   * Poll `consumer.assignment()` until the consumer has received at least one
-   * partition for the given topics, then return. Logs a warning and returns
-   * (rather than throwing) on timeout so that a slow broker does not break
-   * the caller — in the worst case a message sent immediately after would be
-   * missed, which is the same behaviour as before this guard was added.
-   */
-  async waitForPartitionAssignment(consumer, topics, timeoutMs = 1e4) {
-    const topicSet = new Set(topics);
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      try {
-        const assigned = consumer.assignment();
-        if (assigned.some((a) => topicSet.has(a.topic))) return;
-      } catch {
-      }
-      await sleep(200);
-    }
-    this.logger.warn(
-      `Retry consumer did not receive partition assignments for [${topics.join(", ")}] within ${timeoutMs}ms`
-    );
-  }
-  getOrCreateConsumer(groupId, fromBeginning, autoCommit) {
-    if (!this.consumers.has(groupId)) {
-      this.consumers.set(
-        groupId,
-        this.kafka.consumer({
-          kafkaJS: { groupId, fromBeginning, autoCommit }
-        })
-      );
-    }
-    return this.consumers.get(groupId);
-  }
-  resolveTopicName(topicOrDescriptor) {
-    if (typeof topicOrDescriptor === "string") return topicOrDescriptor;
-    if (topicOrDescriptor && typeof topicOrDescriptor === "object" && "__topic" in topicOrDescriptor) {
-      return topicOrDescriptor.__topic;
-    }
-    return String(topicOrDescriptor);
-  }
-  async ensureTopic(topic2) {
-    if (!this.autoCreateTopicsEnabled || this.ensuredTopics.has(topic2)) return;
-    if (!this.isAdminConnected) {
-      await this.admin.connect();
-      this.isAdminConnected = true;
-    }
-    await this.admin.createTopics({
-      topics: [{ topic: topic2, numPartitions: this.numPartitions }]
-    });
-    this.ensuredTopics.add(topic2);
-  }
-  /** Register schema from descriptor into global registry (side-effect). */
-  registerSchema(topicOrDesc) {
-    if (topicOrDesc?.__schema) {
-      const topic2 = this.resolveTopicName(topicOrDesc);
-      this.schemaRegistry.set(topic2, topicOrDesc.__schema);
-    }
-  }
-  /** Validate message against schema. Pure — no side-effects on registry. */
-  async validateMessage(topicOrDesc, message) {
-    if (topicOrDesc?.__schema) {
-      return await topicOrDesc.__schema.parse(message);
-    }
-    if (this.strictSchemasEnabled && typeof topicOrDesc === "string") {
-      const schema = this.schemaRegistry.get(topicOrDesc);
-      if (schema) return await schema.parse(message);
-    }
-    return message;
-  }
-  /**
-   * Build a kafkajs-ready send payload.
-   * Handles: topic resolution, schema registration, validation, JSON serialization,
-   * envelope header generation, and instrumentation hooks.
-   */
-  async buildSendPayload(topicOrDesc, messages) {
-    this.registerSchema(topicOrDesc);
-    const topic2 = this.resolveTopicName(topicOrDesc);
-    const builtMessages = await Promise.all(
-      messages.map(async (m) => {
-        const envelopeHeaders = buildEnvelopeHeaders({
-          correlationId: m.correlationId,
-          schemaVersion: m.schemaVersion,
-          eventId: m.eventId,
-          headers: m.headers
-        });
-        for (const inst of this.instrumentation) {
-          inst.beforeSend?.(topic2, envelopeHeaders);
-        }
-        return {
-          value: JSON.stringify(await this.validateMessage(topicOrDesc, m.value)),
-          key: m.key ?? null,
-          headers: envelopeHeaders
-        };
-      })
-    );
-    return { topic: topic2, messages: builtMessages };
-  }
-  /** Shared consumer setup: groupId check, schema map, connect, subscribe. */
-  async setupConsumer(topics, mode, options) {
-    const {
-      groupId: optGroupId,
-      fromBeginning = false,
-      retry,
-      dlq = false,
-      interceptors = [],
-      schemas: optionSchemas
-    } = options;
-    const gid = optGroupId || this.defaultGroupId;
-    const existingMode = this.runningConsumers.get(gid);
-    const oppositeMode = mode === "eachMessage" ? "eachBatch" : "eachMessage";
-    if (existingMode === oppositeMode) {
-      throw new Error(
-        `Cannot use ${mode} on consumer group "${gid}" \u2014 it is already running with ${oppositeMode}. Use a different groupId for this consumer.`
-      );
-    }
-    const consumer = this.getOrCreateConsumer(gid, fromBeginning, options.autoCommit ?? true);
-    const schemaMap = this.buildSchemaMap(topics, optionSchemas);
-    const topicNames = topics.map(
-      (t) => this.resolveTopicName(t)
-    );
-    for (const t of topicNames) {
-      await this.ensureTopic(t);
-    }
-    if (dlq) {
-      for (const t of topicNames) {
-        await this.ensureTopic(`${t}.dlq`);
-      }
-    }
-    await consumer.connect();
-    await subscribeWithRetry(consumer, topicNames, this.logger, options.subscribeRetry);
-    this.logger.log(
-      `${mode === "eachBatch" ? "Batch consumer" : "Consumer"} subscribed to topics: ${topicNames.join(", ")}`
-    );
-    return { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry };
-  }
-  buildSchemaMap(topics, optionSchemas) {
-    const schemaMap = /* @__PURE__ */ new Map();
-    for (const t of topics) {
-      if (t?.__schema) {
-        const name = this.resolveTopicName(t);
-        schemaMap.set(name, t.__schema);
-        this.schemaRegistry.set(name, t.__schema);
-      }
-    }
-    if (optionSchemas) {
-      for (const [k, v] of optionSchemas) {
-        schemaMap.set(k, v);
-        this.schemaRegistry.set(k, v);
-      }
-    }
-    return schemaMap;
-  }
-};
-
-// src/client/topic.ts
-function topic(name) {
-  const fn = () => ({
-    __topic: name,
-    __type: void 0
-  });
-  fn.schema = (schema) => ({
-    __topic: name,
-    __type: void 0,
-    __schema: schema
-  });
-  return fn;
-}
-
-export {
-  HEADER_EVENT_ID,
-  HEADER_CORRELATION_ID,
-  HEADER_TIMESTAMP,
-  HEADER_SCHEMA_VERSION,
-  HEADER_TRACEPARENT,
-  getEnvelopeContext,
-  runWithEnvelopeContext,
-  buildEnvelopeHeaders,
-  decodeHeaders,
-  extractEnvelope,
-  KafkaProcessingError,
-  KafkaValidationError,
-  KafkaRetryExhaustedError,
-  KafkaClient,
-  topic
-};
-//# sourceMappingURL=chunk-3QXTW66R.mjs.map