@drarzter/kafka-client 0.5.6 → 0.5.7

package/README.md

@@ -112,7 +112,7 @@ For standalone usage (Express, Fastify, raw Node), no extra dependencies needed
 ```typescript
 import { KafkaClient, topic } from '@drarzter/kafka-client/core';
 
-const OrderCreated = topic('order.created')<{ orderId: string; amount: number }>();
+const OrderCreated = topic('order.created').type<{ orderId: string; amount: number }>();
 
 const kafka = new KafkaClient('my-app', 'my-group', ['localhost:9092']);
 await kafka.connectProducer();
@@ -245,13 +245,13 @@ Instead of a centralized topic map, define each topic as a standalone typed obje
 ```typescript
 import { topic, TopicsFrom } from '@drarzter/kafka-client';
 
-export const OrderCreated = topic('order.created')<{
+export const OrderCreated = topic('order.created').type<{
   orderId: string;
   userId: string;
   amount: number;
 }>();
 
-export const OrderCompleted = topic('order.completed')<{
+export const OrderCompleted = topic('order.completed').type<{
   orderId: string;
   completedAt: string;
 }>();
@@ -713,8 +713,9 @@ Options for `sendMessage()` — the third argument:
 | `retry.backoffMs` | `1000` | Base delay for exponential backoff in ms |
 | `retry.maxBackoffMs` | `30000` | Maximum delay cap for exponential backoff in ms |
 | `dlq` | `false` | Send to `{topic}.dlq` after all retries exhausted — message carries `x-dlq-*` metadata headers |
-| `retryTopics` | `false` | Route failed messages through `{topic}.retry` instead of sleeping in-process (see [Retry topic chain](#retry-topic-chain)) |
+| `retryTopics` | `false` | Route failed messages through per-level topics (`{topic}.retry.1`, `{topic}.retry.2`, …) instead of sleeping in-process; at-least-once semantics; requires `retry` (see [Retry topic chain](#retry-topic-chain)) |
 | `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 |
 | `batch` | `false` | (decorator only) Use `startBatchConsumer` instead of `startConsumer` |
 | `subscribeRetry.retries` | `5` | Max attempts for `consumer.subscribe()` when topic doesn't exist yet |
@@ -826,12 +827,13 @@ const interceptor: ConsumerInterceptor<MyTopics> = {
 
 ## Retry topic chain
 
-By default, retry is handled in-process: the consumer sleeps between attempts while holding the partition. With `retryTopics: true`, failed messages are routed to a `<topic>.retry` Kafka topic instead. A companion consumer auto-starts on `<topic>.retry` (group `<groupId>-retry`), waits until the scheduled retry time, then calls the same handler.
+By default, retry is handled in-process: the consumer sleeps between attempts while holding the partition. With `retryTopics: true`, failed messages are routed through a chain of Kafka topics instead — one topic per retry level. A companion consumer auto-starts per level, waits for the scheduled delay using partition pause/resume, then calls the same handler.
 
 Benefits over in-process retry:
 
-- **Durable** — retry messages survive a consumer restart
-- **Non-blocking** — the original consumer is free immediately; the retry consumer pauses only the specific partition being delayed, so other partitions continue processing
+- **Durable** — retry messages survive a consumer restart (at-least-once semantics)
+- **Non-blocking** — the original consumer is free immediately; each level consumer only pauses its specific partition during the delay window, so other partitions continue processing
+- **Isolated** — each retry level has its own consumer group, so a slow level 3 consumer never blocks a level 1 consumer
 
 ```typescript
 await kafka.startConsumer(['orders.created'], handler, {
@@ -841,18 +843,32 @@ await kafka.startConsumer(['orders.created'], handler, {
 });
 ```
 
-Message flow with `maxRetries: 2`:
+With `maxRetries: 3`, this creates three dedicated topics and three companion consumers:
 
 ```text
-orders.created  →  handler fails  →  orders.created.retry  (attempt 1, delay ~1 s)
-                                   →  handler fails  →  orders.created.retry  (attempt 2, delay ~2 s)
-                                                      →  handler fails  →  orders.created.dlq
+orders.created.retry.1  →  consumer group: my-group-retry.1  (delay ~1 s)
+orders.created.retry.2  →  consumer group: my-group-retry.2  (delay ~2 s)
+orders.created.retry.3  →  consumer group: my-group-retry.3  (delay ~4 s)
 ```
 
-The retry topic messages carry scheduling headers (`x-retry-attempt`, `x-retry-after`, `x-retry-original-topic`, `x-retry-max-retries`) that the companion consumer reads automatically — no manual configuration needed.
+Message flow with `maxRetries: 2` and `dlq: true`:
 
+```text
+orders.created       →  handler fails  →  orders.created.retry.1  (attempt 1, delay ~1 s)
+orders.created.retry.1  →  handler fails  →  orders.created.retry.2  (attempt 2, delay ~2 s)
+orders.created.retry.2  →  handler fails  →  orders.created.dlq
+```
+
+Each level consumer uses `consumer.pause → sleep(remaining) → consumer.resume` so the partition offset is never committed before the message is processed. On a process crash during sleep or handler execution, the message is redelivered on restart.
+
+The retry topic messages carry scheduling headers (`x-retry-attempt`, `x-retry-after`, `x-retry-original-topic`, `x-retry-max-retries`) that each level consumer reads automatically — no manual configuration needed.
+
+> **Delivery guarantee:** retry messages are at-least-once. A duplicate can occur in the rare case where a process crashes after routing to the next level but before committing the offset — the message appears twice in the next level topic. Design handlers to be idempotent if duplicates are unacceptable.
+>
 > **Note:** `retryTopics` requires `retry` to be set — an error is thrown at startup if `retry` is missing. Currently only applies to `startConsumer`; batch consumers (`startBatchConsumer`) use in-process retry regardless.
 
+`stopConsumer(groupId)` automatically stops all companion retry level consumers started for that group.
+
 ## stopConsumer
 
 Stop all consumers or a specific group:
@@ -977,18 +993,18 @@ export const OrderCreated = topic('order.created').schema(z.object({
   amount: z.number().positive(),
 }));
 
-// Without schema — explicit generic (still works)
-export const OrderAudit = topic('order.audit')<{ orderId: string; action: string }>();
+// Without schema — explicit type via .type<T>()
+export const OrderAudit = topic('order.audit').type<{ orderId: string; action: string }>();
 
 export type MyTopics = TopicsFrom<typeof OrderCreated | typeof OrderAudit>;
 ```
 
 ### How it works
 
-**On send** — `sendMessage`, `sendBatch`, and `transaction` call `schema.parse(message)` before serializing. Invalid messages throw immediately (the schema library's error, e.g. `ZodError`):
+**On send** — `sendMessage`, `sendBatch`, and `transaction` call `schema.parse(message)` before serializing. Invalid messages throw immediately as `KafkaValidationError` (the original schema error is available as `cause`):
 
 ```typescript
-// This throws ZodError — amount must be positive
+// This throws KafkaValidationError — amount must be positive
 await kafka.sendMessage(OrderCreated, { orderId: '1', userId: '2', amount: -5 });
 ```
 
@@ -1100,7 +1116,7 @@ expect(kafka.sendMessage).toHaveBeenCalledWith(
 );
 
 // Override return values
-kafka.checkStatus.mockResolvedValueOnce({ topics: ['order.created'] });
+kafka.checkStatus.mockResolvedValueOnce({ status: 'up', clientId: 'mock-client', topics: ['order.created'] });
 
 // Mock rejections
 kafka.sendMessage.mockRejectedValueOnce(new Error('broker down'));

package/dist/{chunk-6B72MJPU.mjs → chunk-TD2AE774.mjs}

@@ -61,6 +61,38 @@ function extractEnvelope(payload, headers, topic2, partition, offset) {
   };
 }
 
+// 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/kafka.client/producer-ops.ts
 function resolveTopicName(topicOrDescriptor) {
   if (typeof topicOrDescriptor === "string") return topicOrDescriptor;
@@ -76,17 +108,31 @@ function registerSchema(topicOrDesc, schemaRegistry) {
   }
 }
 async function validateMessage(topicOrDesc, message, deps) {
+  const topicName = resolveTopicName(topicOrDesc);
   if (topicOrDesc?.__schema) {
-    return await topicOrDesc.__schema.parse(message);
+    try {
+      return await topicOrDesc.__schema.parse(message);
+    } catch (error) {
+      throw new KafkaValidationError(topicName, message, {
+        cause: error instanceof Error ? error : new Error(String(error))
+      });
+    }
   }
   if (deps.strictSchemasEnabled && typeof topicOrDesc === "string") {
     const schema = deps.schemaRegistry.get(topicOrDesc);
-    if (schema) return await schema.parse(message);
+    if (schema) {
+      try {
+        return await schema.parse(message);
+      } catch (error) {
+        throw new KafkaValidationError(topicName, message, {
+          cause: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
   }
   return message;
 }
 async function buildSendPayload(topicOrDesc, messages, deps) {
-  registerSchema(topicOrDesc, deps.schemaRegistry);
   const topic2 = resolveTopicName(topicOrDesc);
   const builtMessages = await Promise.all(
     messages.map(async (m) => {
@@ -163,38 +209,6 @@ function buildSchemaMap(topics, schemaRegistry, optionSchemas) {
   return schemaMap;
 }
 
-// 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));
@@ -282,7 +296,7 @@ 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 retryTopic = `${originalTopic}.retry.${attempt}`;
   const {
     [RETRY_HEADER_ATTEMPT]: _a,
     [RETRY_HEADER_AFTER]: _b,
@@ -586,7 +600,7 @@ async function waitForPartitionAssignment(consumer, topics, logger, timeoutMs =
     `Retry consumer did not receive partition assignments for [${topics.join(", ")}] within ${timeoutMs}ms`
   );
 }
-async function startRetryTopicConsumers(originalTopics, originalGroupId, handleMessage, retry, dlq, interceptors, schemaMap, deps) {
+async function startLevelConsumer(level, levelTopics, levelGroupId, originalTopics, handleMessage, retry, dlq, interceptors, schemaMap, deps, assignmentTimeoutMs) {
   const {
     logger,
     producer,
@@ -596,43 +610,48 @@ async function startRetryTopicConsumers(originalTopics, originalGroupId, handleM
     getOrCreateConsumer: getOrCreateConsumer2,
     runningConsumers
   } = deps;
-  const retryTopicNames = originalTopics.map((t) => `${t}.retry`);
-  const retryGroupId = `${originalGroupId}-retry`;
   const backoffMs = retry.backoffMs ?? 1e3;
   const maxBackoffMs = retry.maxBackoffMs ?? 3e4;
   const pipelineDeps = { logger, producer, instrumentation, onMessageLost };
-  for (const rt of retryTopicNames) {
-    await ensureTopic(rt);
+  for (const lt of levelTopics) {
+    await ensureTopic(lt);
   }
-  const consumer = getOrCreateConsumer2(retryGroupId, false, true);
+  const consumer = getOrCreateConsumer2(levelGroupId, false, false);
   await consumer.connect();
-  await subscribeWithRetry(consumer, retryTopicNames, logger);
+  await subscribeWithRetry(consumer, levelTopics, logger);
   await consumer.run({
-    eachMessage: async ({ topic: retryTopic, partition, message }) => {
-      if (!message.value) return;
-      const raw = message.value.toString();
-      const parsed = parseJsonMessage(raw, retryTopic, logger);
-      if (parsed === null) return;
+    eachMessage: async ({ topic: levelTopic, partition, message }) => {
+      const nextOffset = {
+        topic: levelTopic,
+        partition,
+        offset: (parseInt(message.offset, 10) + 1).toString()
+      };
+      if (!message.value) {
+        await consumer.commitOffsets([nextOffset]);
+        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] }]);
+        consumer.pause([{ topic: levelTopic, partitions: [partition] }]);
         await sleep(remaining);
-        consumer.resume([{ topic: retryTopic, partitions: [partition] }]);
+        consumer.resume([{ topic: levelTopic, partitions: [partition] }]);
+      }
+      const raw = message.value.toString();
+      const parsed = parseJsonMessage(raw, levelTopic, logger);
+      if (parsed === null) {
+        await consumer.commitOffsets([nextOffset]);
+        return;
       }
+      const currentMaxRetries = parseInt(
+        headers[RETRY_HEADER_MAX_RETRIES] ?? String(retry.maxRetries),
+        10
+      );
+      const originalTopic = headers[RETRY_HEADER_ORIGINAL_TOPIC] ?? levelTopic.replace(/\.retry\.\d+$/, "");
       const validated = await validateWithSchema(
         parsed,
         raw,
@@ -642,7 +661,10 @@ async function startRetryTopicConsumers(originalTopics, originalGroupId, handleM
         dlq,
         { ...pipelineDeps, originalHeaders: headers }
       );
-      if (validated === null) return;
+      if (validated === null) {
+        await consumer.commitOffsets([nextOffset]);
+        return;
+      }
       const envelope = extractEnvelope(
         validated,
         headers,
@@ -662,62 +684,81 @@ async function startRetryTopicConsumers(originalTopics, originalGroupId, handleM
         interceptors,
         instrumentation
       );
-      if (error) {
-        const nextAttempt = currentAttempt + 1;
-        const exhausted = currentAttempt >= maxRetries;
-        const reportedError = exhausted && maxRetries > 1 ? new KafkaRetryExhaustedError(
+      if (!error) {
+        await consumer.commitOffsets([nextOffset]);
+        return;
+      }
+      const exhausted = level >= currentMaxRetries;
+      const reportedError = exhausted && currentMaxRetries > 1 ? new KafkaRetryExhaustedError(
+        originalTopic,
+        [envelope.payload],
+        currentMaxRetries,
+        { cause: error }
+      ) : error;
+      await notifyInterceptorsOnError([envelope], interceptors, reportedError);
+      logger.error(
+        `Retry consumer error for ${originalTopic} (level ${level}/${currentMaxRetries}):`,
+        error.stack
+      );
+      if (!exhausted) {
+        const nextLevel = level + 1;
+        const cap = Math.min(backoffMs * 2 ** level, maxBackoffMs);
+        const delay = Math.floor(Math.random() * cap);
+        await sendToRetryTopic(
           originalTopic,
-          [envelope.payload],
-          maxRetries,
-          { cause: error }
-        ) : error;
-        await notifyInterceptorsOnError(
-          [envelope],
-          interceptors,
-          reportedError
-        );
-        logger.error(
-          `Retry consumer error for ${originalTopic} (attempt ${currentAttempt}/${maxRetries}):`,
-          error.stack
+          [raw],
+          nextLevel,
+          currentMaxRetries,
+          delay,
+          headers,
+          pipelineDeps
         );
-        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,
-            pipelineDeps
-          );
-        } else if (dlq) {
-          await sendToDlq(originalTopic, raw, pipelineDeps, {
-            error,
-            // +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 onMessageLost?.({
-            topic: originalTopic,
-            error,
-            attempt: currentAttempt,
-            headers
-          });
-        }
+      } else if (dlq) {
+        await sendToDlq(originalTopic, raw, pipelineDeps, {
+          error,
+          // +1 to account for the main consumer's initial attempt before routing.
+          attempt: level + 1,
+          originalHeaders: headers
+        });
+      } else {
+        await onMessageLost?.({
+          topic: originalTopic,
+          error,
+          attempt: level,
+          headers
+        });
       }
+      await consumer.commitOffsets([nextOffset]);
     }
   });
-  runningConsumers.set(retryGroupId, "eachMessage");
-  await waitForPartitionAssignment(consumer, retryTopicNames, logger);
+  runningConsumers.set(levelGroupId, "eachMessage");
+  await waitForPartitionAssignment(consumer, levelTopics, logger, assignmentTimeoutMs);
   logger.log(
-    `Retry topic consumers started for: ${originalTopics.join(", ")} (group: ${retryGroupId})`
+    `Retry level ${level}/${retry.maxRetries} consumer started for: ${originalTopics.join(", ")} (group: ${levelGroupId})`
   );
 }
+async function startRetryTopicConsumers(originalTopics, originalGroupId, handleMessage, retry, dlq, interceptors, schemaMap, deps, assignmentTimeoutMs) {
+  const levelGroupIds = [];
+  for (let level = 1; level <= retry.maxRetries; level++) {
+    const levelTopics = originalTopics.map((t) => `${t}.retry.${level}`);
+    const levelGroupId = `${originalGroupId}-retry.${level}`;
+    await startLevelConsumer(
+      level,
+      levelTopics,
+      levelGroupId,
+      originalTopics,
+      handleMessage,
+      retry,
+      dlq,
+      interceptors,
+      schemaMap,
+      deps,
+      assignmentTimeoutMs
+    );
+    levelGroupIds.push(levelGroupId);
+  }
+  return levelGroupIds;
+}
 
 // src/client/kafka.client/index.ts
 var { Kafka: KafkaClass, logLevel: KafkaLogLevel } = KafkaJS;
@@ -736,6 +777,8 @@ var KafkaClient = class {
   schemaRegistry = /* @__PURE__ */ new Map();
   runningConsumers = /* @__PURE__ */ new Map();
   consumerCreationOptions = /* @__PURE__ */ new Map();
+  /** Maps each main consumer groupId to its companion retry level groupIds. */
+  companionGroupIds = /* @__PURE__ */ new Map();
   instrumentation;
   onMessageLost;
   onRebalance;
@@ -872,7 +915,7 @@ var KafkaClient = class {
     });
     this.runningConsumers.set(gid, "eachMessage");
     if (options.retryTopics && retry) {
-      await startRetryTopicConsumers(
+      const companions = await startRetryTopicConsumers(
         topicNames,
         gid,
         handleMessage,
@@ -880,8 +923,10 @@ var KafkaClient = class {
         dlq,
         interceptors,
         schemaMap,
-        this.retryTopicDeps
+        this.retryTopicDeps,
+        options.retryTopicAssignmentTimeoutMs
       );
+      this.companionGroupIds.set(gid, companions);
     }
     return { groupId: gid, stop: () => this.stopConsumer(gid) };
   }
@@ -923,6 +968,19 @@ var KafkaClient = class {
       this.runningConsumers.delete(groupId);
       this.consumerCreationOptions.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(() => {
+          });
+          this.consumers.delete(cGroupId);
+          this.runningConsumers.delete(cGroupId);
+          this.consumerCreationOptions.delete(cGroupId);
+          this.logger.log(`Retry consumer disconnected: group "${cGroupId}"`);
+        }
+      }
+      this.companionGroupIds.delete(groupId);
     } else {
       const tasks = Array.from(this.consumers.values()).map(
         (c) => c.disconnect().catch(() => {
@@ -932,6 +990,7 @@ var KafkaClient = class {
       this.consumers.clear();
       this.runningConsumers.clear();
       this.consumerCreationOptions.clear();
+      this.companionGroupIds.clear();
       this.logger.log("All consumers disconnected");
     }
   }
@@ -961,14 +1020,22 @@ var KafkaClient = class {
     }
     return result;
   }
-  /** Check broker connectivity and return status, clientId, and available topics. */
+  /** Check broker connectivity. Never throws — returns a discriminated union. */
   async checkStatus() {
-    if (!this.isAdminConnected) {
-      await this.admin.connect();
-      this.isAdminConnected = true;
+    try {
+      if (!this.isAdminConnected) {
+        await this.admin.connect();
+        this.isAdminConnected = true;
+      }
+      const topics = await this.admin.listTopics();
+      return { status: "up", clientId: this.clientId, topics };
+    } catch (error) {
+      return {
+        status: "down",
+        clientId: this.clientId,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    const topics = await this.admin.listTopics();
-    return { status: "up", clientId: this.clientId, topics };
   }
   getClientId() {
     return this.clientId;
@@ -991,10 +1058,12 @@ var KafkaClient = class {
     this.consumers.clear();
     this.runningConsumers.clear();
     this.consumerCreationOptions.clear();
+    this.companionGroupIds.clear();
     this.logger.log("All connections closed");
   }
   // ── Private helpers ──────────────────────────────────────────────
   async preparePayload(topicOrDesc, messages) {
+    registerSchema(topicOrDesc, this.schemaRegistry);
     const payload = await buildSendPayload(
       topicOrDesc,
       messages,
@@ -1128,16 +1197,18 @@ var KafkaClient = class {
 
 // src/client/message/topic.ts
 function topic(name) {
-  const fn = () => ({
-    __topic: name,
-    __type: void 0
-  });
-  fn.schema = (schema) => ({
-    __topic: name,
-    __type: void 0,
-    __schema: schema
-  });
-  return fn;
+  return {
+    /** Provide an explicit message type without a runtime schema. */
+    type: () => ({
+      __topic: name,
+      __type: void 0
+    }),
+    schema: (schema) => ({
+      __topic: name,
+      __type: void 0,
+      __schema: schema
+    })
+  };
 }
 
 export {
@@ -1157,4 +1228,4 @@ export {
   KafkaClient,
   topic
 };
-//# sourceMappingURL=chunk-6B72MJPU.mjs.map
+//# sourceMappingURL=chunk-TD2AE774.mjs.map