@drarzter/kafka-client 0.6.3 → 0.6.6

package/README.md

@@ -30,6 +30,7 @@ Type-safe Kafka client for Node.js. Framework-agnostic core with a first-class N
 - [Instrumentation](#instrumentation)
 - [Options reference](#options-reference)
 - [Error classes](#error-classes)
+- [Deduplication (Lamport Clock)](#deduplication-lamport-clock)
 - [Retry topic chain](#retry-topic-chain)
 - [stopConsumer](#stopconsumer)
 - [Graceful shutdown](#graceful-shutdown)
@@ -65,6 +66,7 @@ Safe by default. Configurable when you need it. Escape hatches for when you know
 - **Topic descriptors** — `topic()` DX sugar lets you define topics as standalone typed objects instead of string keys
 - **Framework-agnostic** — use standalone or with NestJS (`register()` / `registerAsync()`, DI, lifecycle hooks)
 - **Idempotent producer** — `acks: -1`, `idempotent: true` by default
+- **Lamport Clock deduplication** — every outgoing message is stamped with a monotonically increasing `x-lamport-clock` header; the consumer tracks the last processed value per `topic:partition` and silently drops (or routes to DLQ / a dedicated topic) any message whose clock is not strictly greater than the last seen value
 - **Retry + DLQ** — exponential backoff with full jitter; dead letter queue with error metadata headers (original topic, error message, stack, attempt count)
 - **Batch sending** — send multiple messages in a single request
 - **Batch consuming** — `startBatchConsumer()` for high-throughput `eachBatch` processing
@@ -441,11 +443,14 @@ await kafka.startConsumer(['orders'], auditHandler, { groupId: 'orders-audit' })
 async auditOrders(envelope) { ... }
 ```
 
-**Important:** You cannot mix `eachMessage` and `eachBatch` consumers on the same `groupId`. The library throws a clear error if you try:
+**Important:** You cannot mix `eachMessage` and `eachBatch` consumers on the same `groupId`, and you cannot call `startConsumer` (or `startBatchConsumer`) twice on the same `groupId` without stopping it first. The library throws a clear error in both cases:
 
 ```text
 Cannot use eachBatch on consumer group "my-group" — it is already running with eachMessage.
 Use a different groupId for this consumer.
+
+startConsumer("my-group") called twice — this group is already consuming.
+Call stopConsumer("my-group") first or pass a different groupId.
 ```
 
 ### Named clients
@@ -583,7 +588,7 @@ await this.kafka.startBatchConsumer(
 );
 ```
 
-> **Note:** If your handler calls `resolveOffset()` or `commitOffsetsIfNecessary()` without setting `autoCommit: false`, a `warn` is logged at consumer-start time — mixing autoCommit with manual offset control causes offset conflicts. Set `autoCommit: false` to suppress the warning and take full control of offset management.
+> **Note:** If your handler calls `resolveOffset()` or `commitOffsetsIfNecessary()` without setting `autoCommit: false`, a `debug` message is logged at consumer-start time — mixing autoCommit with manual offset control causes offset conflicts. Set `autoCommit: false` to suppress the message and take full control of offset management.
 
 With `@SubscribeTo()`:
 
@@ -769,6 +774,8 @@ Options for `sendMessage()` — the third argument:
 | `interceptors` | `[]` | Array of before/after/onError hooks |
 | `retryTopicAssignmentTimeoutMs` | `10000` | Timeout (ms) to wait for each retry level consumer to receive partition assignments after connecting; increase for slow brokers |
 | `handlerTimeoutMs` | — | Log a warning if the handler hasn't resolved within this window (ms) — does not cancel the handler |
+| `deduplication.strategy` | `'drop'` | What to do with duplicate messages: `'drop'` silently discards, `'dlq'` forwards to `{topic}.dlq` (requires `dlq: true`), `'topic'` forwards to `{topic}.duplicates` |
+| `deduplication.duplicatesTopic` | `{topic}.duplicates` | Custom destination for `strategy: 'topic'` |
 | `batch` | `false` | (decorator only) Use `startBatchConsumer` instead of `startConsumer` |
 | `subscribeRetry.retries` | `5` | Max attempts for `consumer.subscribe()` when topic doesn't exist yet |
 | `subscribeRetry.backoffMs` | `5000` | Delay between subscribe retry attempts (ms) |
@@ -877,6 +884,81 @@ const interceptor: ConsumerInterceptor<MyTopics> = {
 };
 ```
 
+## Deduplication (Lamport Clock)
+
+Every outgoing message produced by this library is stamped with a monotonically increasing logical clock — the `x-lamport-clock` header. The counter lives in the `KafkaClient` instance and increments by one per message (including individual messages inside `sendBatch` and `transaction`).
+
+On the consumer side, enable deduplication by passing `deduplication` to `startConsumer` or `startBatchConsumer`. The library checks the incoming clock against the last processed value for that `topic:partition` combination and skips any message whose clock is not strictly greater.
+
+```typescript
+await kafka.startConsumer(['orders.created'], handler, {
+  deduplication: {}, // 'drop' strategy — silently discard duplicates
+});
+```
+
+### How duplicates happen
+
+The most common scenario: a producer service restarts. Its in-memory clock resets to `0`. The consumer already processed messages with clocks `1…N`. All new messages from the restarted producer (clocks `1`, `2`, `3`, …) have clocks ≤ `N` and are treated as duplicates.
+
+```text
+Producer A (running): sends clock 1, 2, 3, 4, 5  → consumer processes all 5
+Producer A (restarts): sends clock 1, 2, 3         → consumer sees 1 ≤ 5 — duplicate!
+```
+
+### Strategies
+
+| Strategy | Behaviour |
+| -------- | --------- |
+| `'drop'` *(default)* | Log a warning and silently discard the message |
+| `'dlq'` | Forward to `{topic}.dlq` with reason metadata headers (`x-dlq-reason`, `x-dlq-duplicate-incoming-clock`, `x-dlq-duplicate-last-processed-clock`). Requires `dlq: true` |
+| `'topic'` | Forward to `{topic}.duplicates` (or `duplicatesTopic` if set) with reason metadata headers (`x-duplicate-reason`, `x-duplicate-incoming-clock`, `x-duplicate-last-processed-clock`, `x-duplicate-detected-at`) |
+
+```typescript
+// Strategy: drop (default)
+await kafka.startConsumer(['orders'], handler, {
+  deduplication: {},
+});
+
+// Strategy: DLQ — inspect duplicates from {topic}.dlq
+await kafka.startConsumer(['orders'], handler, {
+  dlq: true,
+  deduplication: { strategy: 'dlq' },
+});
+
+// Strategy: dedicated topic — consume from {topic}.duplicates
+await kafka.startConsumer(['orders'], handler, {
+  deduplication: { strategy: 'topic' },
+});
+
+// Strategy: custom topic name
+await kafka.startConsumer(['orders'], handler, {
+  deduplication: {
+    strategy: 'topic',
+    duplicatesTopic: 'ops.orders.duplicates',
+  },
+});
+```
+
+### Startup validation
+
+When `autoCreateTopics: false` and `strategy: 'topic'`, `startConsumer` / `startBatchConsumer` validates that the destination topic (`{topic}.duplicates` or `duplicatesTopic`) exists before starting the consumer. A clear error is thrown at startup listing every missing topic, rather than silently failing on the first duplicate.
+
+With `autoCreateTopics: true` the check is skipped — the topic is created automatically instead.
+
+### Backwards compatibility
+
+Messages without an `x-lamport-clock` header pass through unchanged. Producers not using this library are unaffected.
+
+### Limitations
+
+Deduplication state is **in-memory and per-consumer-instance**. Understand what that means:
+
+- **Consumer restart** — state is cleared on restart. The first batch of messages after restart is accepted regardless of their clock values, so duplicates spanning a restart window are not caught.
+- **Multiple consumer instances** (same group, different machines) — each instance tracks its own partition subset. Partitions are reassigned on rebalance, so a rebalance can reset the state for moved partitions.
+- **Cross-session duplicates** — this guards against duplicates from a **producer that restarted within the same consumer session**. For durable, cross-restart deduplication, persist the clock state externally (Redis, database) and implement idempotent handlers.
+
+Use this feature as a lightweight first line of defence — not as a substitute for idempotent business logic.
+
 ## Retry topic chain
 
 > **tl;dr — recommended production setup:**

package/dist/{chunk-RGRKN4E5.mjs → chunk-KCUKXR6B.mjs}

@@ -9,6 +9,7 @@ var HEADER_CORRELATION_ID = "x-correlation-id";
 var HEADER_TIMESTAMP = "x-timestamp";
 var HEADER_SCHEMA_VERSION = "x-schema-version";
 var HEADER_TRACEPARENT = "traceparent";
+var HEADER_LAMPORT_CLOCK = "x-lamport-clock";
 var envelopeStorage = new AsyncLocalStorage();
 function getEnvelopeContext() {
   return envelopeStorage.getStore();
@@ -149,6 +150,9 @@ async function buildSendPayload(topicOrDesc, messages, deps) {
         eventId: m.eventId,
         headers: m.headers
       });
+      if (deps.nextLamportClock) {
+        envelopeHeaders[HEADER_LAMPORT_CLOCK] = String(deps.nextLamportClock());
+      }
       for (const inst of deps.instrumentation) {
         inst.beforeSend?.(topic2, envelopeHeaders);
       }
@@ -286,6 +290,9 @@ async function validateWithSchema(message, raw, topic2, schemaMap, interceptors,
       -1,
       ""
     );
+    for (const inst of deps.instrumentation ?? []) {
+      inst.onConsumeError?.(errorEnvelope, validationError);
+    }
     for (const interceptor of interceptors) {
       await interceptor.onError?.(errorEnvelope, validationError);
     }
@@ -380,6 +387,29 @@ async function sendToRetryTopic(originalTopic, rawMessages, attempt, maxRetries,
     });
   }
 }
+function buildDuplicateTopicPayload(sourceTopic, rawMessage, destinationTopic, meta) {
+  const headers = {
+    ...meta?.originalHeaders ?? {},
+    "x-duplicate-original-topic": sourceTopic,
+    "x-duplicate-detected-at": (/* @__PURE__ */ new Date()).toISOString(),
+    "x-duplicate-reason": "lamport-clock-duplicate",
+    "x-duplicate-incoming-clock": String(meta?.incomingClock ?? 0),
+    "x-duplicate-last-processed-clock": String(meta?.lastProcessedClock ?? 0)
+  };
+  return { topic: destinationTopic, messages: [{ value: rawMessage, headers }] };
+}
+async function sendToDuplicatesTopic(sourceTopic, rawMessage, destinationTopic, deps, meta) {
+  const payload = buildDuplicateTopicPayload(sourceTopic, rawMessage, destinationTopic, meta);
+  try {
+    await deps.producer.send(payload);
+    deps.logger.warn(`Duplicate message forwarded to ${destinationTopic}`);
+  } catch (error) {
+    deps.logger.error(
+      `Failed to forward duplicate to ${destinationTopic}:`,
+      toError(error).stack
+    );
+  }
+}
 async function broadcastToInterceptors(envelopes, interceptors, cb) {
   for (const env of envelopes) {
     for (const interceptor of interceptors) {
@@ -488,13 +518,12 @@ async function executeWithRetry(fn, ctx, deps) {
       );
     } else if (isLastAttempt) {
       if (dlq) {
-        const dlqMeta = {
-          error,
-          attempt,
-          originalHeaders: envelopes[0]?.headers
-        };
-        for (const raw of rawMessages) {
-          await sendToDlq(topic2, raw, deps, dlqMeta);
+        for (let i = 0; i < rawMessages.length; i++) {
+          await sendToDlq(topic2, rawMessages[i], deps, {
+            error,
+            attempt,
+            originalHeaders: envelopes[i]?.headers
+          });
         }
       } else {
         await deps.onMessageLost?.({
@@ -506,12 +535,50 @@ async function executeWithRetry(fn, ctx, deps) {
       }
     } else {
       const cap = Math.min(backoffMs * 2 ** (attempt - 1), maxBackoffMs);
-      await sleep(Math.random() * cap);
+      await sleep(Math.floor(Math.random() * cap));
     }
   }
 }
 
 // src/client/kafka.client/message-handler.ts
+async function applyDeduplication(envelope, raw, dedup, dlq, deps) {
+  const clockRaw = envelope.headers[HEADER_LAMPORT_CLOCK];
+  if (clockRaw === void 0) return false;
+  const incomingClock = Number(clockRaw);
+  if (Number.isNaN(incomingClock)) return false;
+  const stateKey = `${envelope.topic}:${envelope.partition}`;
+  const lastProcessedClock = dedup.state.get(stateKey) ?? -1;
+  if (incomingClock <= lastProcessedClock) {
+    const meta = {
+      incomingClock,
+      lastProcessedClock,
+      originalHeaders: envelope.headers
+    };
+    const strategy = dedup.options.strategy ?? "drop";
+    deps.logger.warn(
+      `Duplicate message on ${envelope.topic}[${envelope.partition}]: clock=${incomingClock} <= last=${lastProcessedClock} \u2014 strategy=${strategy}`
+    );
+    if (strategy === "dlq" && dlq) {
+      const augmentedHeaders = {
+        ...envelope.headers,
+        "x-dlq-reason": "lamport-clock-duplicate",
+        "x-dlq-duplicate-incoming-clock": String(incomingClock),
+        "x-dlq-duplicate-last-processed-clock": String(lastProcessedClock)
+      };
+      await sendToDlq(envelope.topic, raw, deps, {
+        error: new Error("Lamport Clock duplicate detected"),
+        attempt: 0,
+        originalHeaders: augmentedHeaders
+      });
+    } else if (strategy === "topic") {
+      const destination = dedup.options.duplicatesTopic ?? `${envelope.topic}.duplicates`;
+      await sendToDuplicatesTopic(envelope.topic, raw, destination, deps, meta);
+    }
+    return true;
+  }
+  dedup.state.set(stateKey, incomingClock);
+  return false;
+}
 async function parseSingleMessage(message, topic2, partition, schemaMap, interceptors, dlq, deps) {
   if (!message.value) {
     deps.logger.warn(`Received empty message from topic ${topic2}`);
@@ -555,6 +622,16 @@ async function handleEachMessage(payload, opts, deps) {
     deps
   );
   if (envelope === null) return;
+  if (opts.deduplication) {
+    const isDuplicate = await applyDeduplication(
+      envelope,
+      message.value.toString(),
+      opts.deduplication,
+      dlq,
+      deps
+    );
+    if (isDuplicate) return;
+  }
   await executeWithRetry(
     () => {
       const fn = () => runWithEnvelopeContext(
@@ -602,6 +679,17 @@ async function handleEachBatch(payload, opts, deps) {
       deps
     );
     if (envelope === null) continue;
+    if (opts.deduplication) {
+      const raw = message.value.toString();
+      const isDuplicate = await applyDeduplication(
+        envelope,
+        raw,
+        opts.deduplication,
+        dlq,
+        deps
+      );
+      if (isDuplicate) continue;
+    }
     envelopes.push(envelope);
     rawMessages.push(message.value.toString());
   }
@@ -880,7 +968,9 @@ var KafkaClient = class {
   kafka;
   producer;
   txProducer;
-  retryTxProducers = /* @__PURE__ */ new Set();
+  txProducerInitPromise;
+  /** Maps transactionalId → Producer for each active retry level consumer. */
+  retryTxProducers = /* @__PURE__ */ new Map();
   consumers = /* @__PURE__ */ new Map();
   admin;
   logger;
@@ -888,6 +978,8 @@ var KafkaClient = class {
   strictSchemasEnabled;
   numPartitions;
   ensuredTopics = /* @__PURE__ */ new Set();
+  /** Pending topic-creation promises keyed by topic name. Prevents duplicate createTopics calls. */
+  ensureTopicPromises = /* @__PURE__ */ new Map();
   defaultGroupId;
   schemaRegistry = /* @__PURE__ */ new Map();
   runningConsumers = /* @__PURE__ */ new Map();
@@ -897,6 +989,10 @@ var KafkaClient = class {
   instrumentation;
   onMessageLost;
   onRebalance;
+  /** Monotonically increasing Lamport clock stamped on every outgoing message. */
+  _lamportClock = 0;
+  /** Per-groupId deduplication state: `"topic:partition"` → last processed clock. */
+  dedupStates = /* @__PURE__ */ new Map();
   isAdminConnected = false;
   inFlightTotal = 0;
   drainResolvers = [];
@@ -951,18 +1047,25 @@ var KafkaClient = class {
   }
   /** Execute multiple sends atomically. Commits on success, aborts on error. */
   async transaction(fn) {
-    if (!this.txProducer) {
-      const p = this.kafka.producer({
-        kafkaJS: {
-          acks: -1,
-          idempotent: true,
-          transactionalId: `${this.clientId}-tx`,
-          maxInFlightRequests: 1
-        }
+    if (!this.txProducerInitPromise) {
+      const initPromise = (async () => {
+        const p = this.kafka.producer({
+          kafkaJS: {
+            acks: -1,
+            idempotent: true,
+            transactionalId: `${this.clientId}-tx`,
+            maxInFlightRequests: 1
+          }
+        });
+        await p.connect();
+        return p;
+      })();
+      this.txProducerInitPromise = initPromise.catch((err) => {
+        this.txProducerInitPromise = void 0;
+        throw err;
       });
-      await p.connect();
-      this.txProducer = p;
     }
+    this.txProducer = await this.txProducerInitPromise;
     const tx = await this.txProducer.transaction();
     try {
       const ctx = {
@@ -1001,11 +1104,17 @@ var KafkaClient = class {
     }
   }
   // ── Producer lifecycle ───────────────────────────────────────────
-  /** Connect the idempotent producer. Called automatically by `KafkaModule.register()`. */
+  /**
+   * Connect the idempotent producer. Called automatically by `KafkaModule.register()`.
+   * @internal Not part of `IKafkaClient` — use `disconnect()` for full teardown.
+   */
   async connectProducer() {
     await this.producer.connect();
     this.logger.log("Producer connected");
   }
+  /**
+   * @internal Not part of `IKafkaClient` — use `disconnect()` for full teardown.
+   */
   async disconnectProducer() {
     await this.producer.disconnect();
     this.logger.log("Producer disconnected");
@@ -1019,6 +1128,7 @@ var KafkaClient = class {
     const { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachMessage", options);
     const deps = this.messageDeps;
     const timeoutMs = options.handlerTimeoutMs;
+    const deduplication = this.resolveDeduplicationContext(gid, options.deduplication);
     await consumer.run({
       eachMessage: (payload) => this.trackInFlight(
         () => handleEachMessage(
@@ -1031,7 +1141,8 @@ var KafkaClient = class {
             retry,
             retryTopics: options.retryTopics,
             timeoutMs,
-            wrapWithTimeout: this.wrapWithTimeoutWarning.bind(this)
+            wrapWithTimeout: this.wrapWithTimeoutWarning.bind(this),
+            deduplication
           },
           deps
         )
@@ -1071,6 +1182,7 @@ var KafkaClient = class {
     const { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachBatch", options);
     const deps = this.messageDeps;
     const timeoutMs = options.handlerTimeoutMs;
+    const deduplication = this.resolveDeduplicationContext(gid, options.deduplication);
     await consumer.run({
       eachBatch: (payload) => this.trackInFlight(
         () => handleEachBatch(
@@ -1083,7 +1195,8 @@ var KafkaClient = class {
             retry,
             retryTopics: options.retryTopics,
             timeoutMs,
-            wrapWithTimeout: this.wrapWithTimeoutWarning.bind(this)
+            wrapWithTimeout: this.wrapWithTimeoutWarning.bind(this),
+            deduplication
           },
           deps
         )
@@ -1129,35 +1242,63 @@ var KafkaClient = class {
         );
         return;
       }
-      await consumer.disconnect().catch(() => {
-      });
+      await consumer.disconnect().catch(
+        (e) => this.logger.warn(
+          `Error disconnecting consumer "${groupId}":`,
+          toError(e).message
+        )
+      );
       this.consumers.delete(groupId);
       this.runningConsumers.delete(groupId);
       this.consumerCreationOptions.delete(groupId);
+      this.dedupStates.delete(groupId);
       this.logger.log(`Consumer disconnected: group "${groupId}"`);
       const companions = this.companionGroupIds.get(groupId) ?? [];
       for (const cGroupId of companions) {
         const cConsumer = this.consumers.get(cGroupId);
         if (cConsumer) {
-          await cConsumer.disconnect().catch(() => {
-          });
+          await cConsumer.disconnect().catch(
+            (e) => this.logger.warn(
+              `Error disconnecting retry consumer "${cGroupId}":`,
+              toError(e).message
+            )
+          );
           this.consumers.delete(cGroupId);
           this.runningConsumers.delete(cGroupId);
           this.consumerCreationOptions.delete(cGroupId);
           this.logger.log(`Retry consumer disconnected: group "${cGroupId}"`);
         }
+        const txId = `${cGroupId}-tx`;
+        const txProducer = this.retryTxProducers.get(txId);
+        if (txProducer) {
+          await txProducer.disconnect().catch(
+            (e) => this.logger.warn(
+              `Error disconnecting retry tx producer "${txId}":`,
+              toError(e).message
+            )
+          );
+          this.retryTxProducers.delete(txId);
+        }
       }
       this.companionGroupIds.delete(groupId);
     } else {
-      const tasks = Array.from(this.consumers.values()).map(
-        (c) => c.disconnect().catch(() => {
-        })
-      );
+      const tasks = [
+        ...Array.from(this.consumers.values()).map(
+          (c) => c.disconnect().catch(() => {
+          })
+        ),
+        ...Array.from(this.retryTxProducers.values()).map(
+          (p) => p.disconnect().catch(() => {
+          })
+        )
+      ];
       await Promise.allSettled(tasks);
       this.consumers.clear();
       this.runningConsumers.clear();
       this.consumerCreationOptions.clear();
       this.companionGroupIds.clear();
+      this.retryTxProducers.clear();
+      this.dedupStates.clear();
       this.logger.log("All consumers disconnected");
     }
   }
@@ -1165,6 +1306,12 @@ var KafkaClient = class {
    * Query consumer group lag per partition.
    * Lag = broker high-watermark − last committed offset.
    * A committed offset of -1 (nothing committed yet) counts as full lag.
+   *
+   * Returns an empty array when the consumer group has never committed any
+   * offsets (freshly created group, `autoCommit: false` with no manual commits,
+   * or group not yet assigned). This is a Kafka protocol limitation:
+   * `fetchOffsets` only returns data for topic-partitions that have at least one
+   * committed offset. Use `checkStatus()` to verify broker connectivity in that case.
    */
   async getConsumerLag(groupId) {
     const gid = groupId ?? this.defaultGroupId;
@@ -1212,8 +1359,9 @@ var KafkaClient = class {
     if (this.txProducer) {
       tasks.push(this.txProducer.disconnect());
       this.txProducer = void 0;
+      this.txProducerInitPromise = void 0;
     }
-    for (const p of this.retryTxProducers) {
+    for (const p of this.retryTxProducers.values()) {
       tasks.push(p.disconnect());
     }
     this.retryTxProducers.clear();
@@ -1232,6 +1380,14 @@ var KafkaClient = class {
     this.logger.log("All connections closed");
   }
   // ── Graceful shutdown ────────────────────────────────────────────
+  /**
+   * NestJS lifecycle hook — called automatically when the host module is torn down.
+   * Drains in-flight handlers and disconnects all producers, consumers, and admin.
+   * `KafkaModule` relies on this method; no separate destroy provider is needed.
+   */
+  async onModuleDestroy() {
+    await this.disconnect();
+  }
   /**
    * Register SIGTERM / SIGINT handlers that drain in-flight messages before
    * disconnecting. Call this once after constructing the client in non-NestJS apps.
@@ -1352,6 +1508,22 @@ var KafkaClient = class {
       );
     }
   }
+  /**
+   * When `deduplication.strategy: 'topic'` and `autoCreateTopics: false`, verify
+   * that every `<topic>.duplicates` destination topic already exists. Throws a
+   * clear error at startup rather than silently dropping duplicates on first hit.
+   */
+  async validateDuplicatesTopicsExist(topicNames, customDestination) {
+    await this.ensureAdminConnected();
+    const existing = new Set(await this.admin.listTopics());
+    const toCheck = customDestination ? [customDestination] : topicNames.map((t) => `${t}.duplicates`);
+    const missing = toCheck.filter((t) => !existing.has(t));
+    if (missing.length > 0) {
+      throw new Error(
+        `deduplication.strategy: 'topic' but the following duplicate-routing topics do not exist: ${missing.join(", ")}. Create them manually or set autoCreateTopics: true.`
+      );
+    }
+  }
   /**
    * Connect the admin client if not already connected.
    * The flag is only set to `true` after a successful connect — if `admin.connect()`
@@ -1382,16 +1554,23 @@ var KafkaClient = class {
       }
     });
     await p.connect();
-    this.retryTxProducers.add(p);
+    this.retryTxProducers.set(transactionalId, p);
     return p;
   }
   async ensureTopic(topic2) {
     if (!this.autoCreateTopicsEnabled || this.ensuredTopics.has(topic2)) return;
-    await this.ensureAdminConnected();
-    await this.admin.createTopics({
-      topics: [{ topic: topic2, numPartitions: this.numPartitions }]
-    });
-    this.ensuredTopics.add(topic2);
+    let p = this.ensureTopicPromises.get(topic2);
+    if (!p) {
+      p = (async () => {
+        await this.ensureAdminConnected();
+        await this.admin.createTopics({
+          topics: [{ topic: topic2, numPartitions: this.numPartitions }]
+        });
+        this.ensuredTopics.add(topic2);
+      })().finally(() => this.ensureTopicPromises.delete(topic2));
+      this.ensureTopicPromises.set(topic2, p);
+    }
+    await p;
   }
   /** Shared consumer setup: groupId check, schema map, connect, subscribe. */
   async setupConsumer(topics, mode, options) {
@@ -1411,6 +1590,12 @@ var KafkaClient = class {
         `Cannot use ${mode} on consumer group "${gid}" \u2014 it is already running with ${oppositeMode}. Use a different groupId for this consumer.`
       );
     }
+    if (existingMode === mode) {
+      const callerName = mode === "eachMessage" ? "startConsumer" : "startBatchConsumer";
+      throw new Error(
+        `${callerName}("${gid}") called twice \u2014 this group is already consuming. Call stopConsumer("${gid}") first or pass a different groupId.`
+      );
+    }
     const consumer = getOrCreateConsumer(
       gid,
       fromBeginning,
@@ -1435,6 +1620,16 @@ var KafkaClient = class {
         await this.validateDlqTopicsExist(topicNames);
       }
     }
+    if (options.deduplication?.strategy === "topic") {
+      const dest = options.deduplication.duplicatesTopic;
+      if (this.autoCreateTopicsEnabled) {
+        for (const t of topicNames) {
+          await this.ensureTopic(dest ?? `${t}.duplicates`);
+        }
+      } else {
+        await this.validateDuplicatesTopicsExist(topicNames, dest);
+      }
+    }
     await consumer.connect();
     await subscribeWithRetry(
       consumer,
@@ -1447,13 +1642,22 @@ var KafkaClient = class {
     );
     return { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry };
   }
+  /** Create or retrieve the deduplication context for a consumer group. */
+  resolveDeduplicationContext(groupId, options) {
+    if (!options) return void 0;
+    if (!this.dedupStates.has(groupId)) {
+      this.dedupStates.set(groupId, /* @__PURE__ */ new Map());
+    }
+    return { options, state: this.dedupStates.get(groupId) };
+  }
   // ── Deps object getters ──────────────────────────────────────────
   get producerOpsDeps() {
     return {
       schemaRegistry: this.schemaRegistry,
       strictSchemasEnabled: this.strictSchemasEnabled,
       instrumentation: this.instrumentation,
-      logger: this.logger
+      logger: this.logger,
+      nextLamportClock: () => ++this._lamportClock
     };
   }
   get consumerOpsDeps() {
@@ -1509,6 +1713,7 @@ export {
   HEADER_TIMESTAMP,
   HEADER_SCHEMA_VERSION,
   HEADER_TRACEPARENT,
+  HEADER_LAMPORT_CLOCK,
   getEnvelopeContext,
   runWithEnvelopeContext,
   buildEnvelopeHeaders,
@@ -1520,4 +1725,4 @@ export {
   KafkaClient,
   topic
 };
-//# sourceMappingURL=chunk-RGRKN4E5.mjs.map
+//# sourceMappingURL=chunk-KCUKXR6B.mjs.map