@horizon-republic/nestjs-jetstream 2.3.2 → 2.3.5

package/README.md

@@ -5,7 +5,7 @@ A production-grade NestJS transport for NATS JetStream with built-in support for
 [![npm version](https://img.shields.io/npm/v/@horizon-republic/nestjs-jetstream.svg)](https://www.npmjs.com/package/@horizon-republic/nestjs-jetstream)
 [![codecov](https://codecov.io/github/HorizonRepublic/nestjs-jetstream/graph/badge.svg?token=40IPSWFMT4)](https://codecov.io/github/HorizonRepublic/nestjs-jetstream)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Socket Badge](https://badge.socket.dev/npm/package/@horizon-republic/nestjs-jetstream)](https://badge.socket.dev/npm/package/@horizon-republic/nestjs-jetstream)
+[![Socket Badge](https://badge.socket.dev/npm/package/@horizon-republic/nestjs-jetstream)](https://socket.dev/npm/package/@horizon-republic/nestjs-jetstream)
 
 ## Table of Contents
 
@@ -63,9 +63,9 @@ yarn add @horizon-republic/nestjs-jetstream
 **Peer dependencies:**
 
 ```
-@nestjs/common        ^11.0.0
-@nestjs/core          ^11.0.0
-@nestjs/microservices ^11.0.0
+@nestjs/common        ^10.2.0 || ^11.0.0
+@nestjs/core          ^10.2.0 || ^11.0.0
+@nestjs/microservices ^10.2.0 || ^11.0.0
 nats                  ^2.0.0
 reflect-metadata      ^0.2.0
 rxjs                  ^7.8.0
@@ -252,7 +252,7 @@ interface JetstreamModuleOptions {
   /** Broadcast event stream/consumer overrides. */
   broadcast?: { stream?: Partial<StreamConfig>; consumer?: Partial<ConsumerConfig> };
 
-  /** Transport lifecycle hook handlers. Unset hooks fall back to NestJS Logger. */
+  /** Transport lifecycle hook handlers. Unset hooks are silently ignored. */
   hooks?: Partial<TransportHooks>;
 
   /** Async callback for dead letter handling. See Dead Letter Queue section below. */
@@ -305,6 +305,8 @@ Discriminated union on `mode`:
 | `'core'`      | 30s             | None             | Low-latency, simple RPC                |
 | `'jetstream'` | 3 min           | JetStream stream | Commands must survive handler downtime |
 
+> **Note:** `timeout` controls both the **client-side wait** (how long the caller waits for a response) and the **server-side handler limit** (how long the handler is allowed to run before being terminated). Both sides use the same value from their own `forRoot()` config.
+
 ```typescript
 // Core mode (default)
 rpc: { mode: 'core', timeout: 10_000 }
@@ -348,7 +350,8 @@ JetstreamModule.forRoot({
 |----------|--------|
 | Handler success | Response returned to caller |
 | Handler throws | Error response returned to caller |
-| No handler running | Client times out |
+| No handler registered | Error response returned to caller |
+| Server not running | Client times out |
 | Decode error | Error response returned to caller |
 
 #### JetStream Mode
@@ -584,7 +587,7 @@ JetstreamModule.forFeature({
 
 ### Lifecycle Hooks
 
-Subscribe to transport events for monitoring, alerting, or custom logic:
+Subscribe to transport events for monitoring, alerting, or custom logic. Events without a registered hook are silently ignored — no default logging:
 
 ```typescript
 import { JetstreamModule, TransportEvent } from '@horizon-republic/nestjs-jetstream';
@@ -611,17 +614,17 @@ JetstreamModule.forRoot({
 
 **Available events:**
 
-| Event              | Arguments                                   | Default (no hook) |
-|--------------------|---------------------------------------------|-------------------|
-| `connect`          | `(server: string)`                          | `Logger.log`      |
-| `disconnect`       | `()`                                        | `Logger.warn`     |
-| `reconnect`        | `(server: string)`                          | `Logger.log`      |
-| `error`            | `(error: Error, context?: string)`          | `Logger.error`    |
-| `rpcTimeout`       | `(subject: string, correlationId: string)`  | `Logger.warn`     |
-| `messageRouted`    | `(subject: string, kind: 'rpc' \| 'event')` | `Logger.debug`    |
-| `shutdownStart`    | `()`                                        | `Logger.log`      |
-| `shutdownComplete` | `()`                                        | `Logger.log`      |
-| `deadLetter`       | `(info: DeadLetterInfo)`                    | `Logger.warn`     |
+| Event              | Arguments                                   |
+|--------------------|---------------------------------------------|
+| `connect`          | `(server: string)`                          |
+| `disconnect`       | `()`                                        |
+| `reconnect`        | `(server: string)`                          |
+| `error`            | `(error: Error, context?: string)`          |
+| `rpcTimeout`       | `(subject: string, correlationId: string)`  |
+| `messageRouted`    | `(subject: string, kind: 'rpc' \| 'event')` |
+| `shutdownStart`    | `()`                                        |
+| `shutdownComplete` | `()`                                        |
+| `deadLetter`       | `(info: DeadLetterInfo)`                    |
 
 #### Dead Letter Queue (DLQ)
 
@@ -671,7 +674,9 @@ JetstreamModule.forRootAsync({
 
 ### Health Checks
 
-`JetstreamHealthIndicator` is automatically registered and exported by `forRoot()`. It checks NATS connection status and measures round-trip latency. `@nestjs/terminus` is **not required** — the indicator follows the Terminus API convention so it works seamlessly when Terminus is present, but can also be used standalone.
+`JetstreamHealthIndicator` is automatically registered and exported by `forRoot()`. It checks NATS connection status and measures round-trip latency. `@nestjs/terminus` is **not required** — the indicator follows the Terminus API convention and can be used standalone.
+
+> **Note:** `isHealthy()` throws a plain `Error` with attached status details rather than Terminus's `HealthCheckError`. Terminus will report the service as unhealthy, but the structured `{ status: 'down', server, latency }` details may not appear in the response body. For full Terminus formatting, use the `check()` method in a custom wrapper.
 
 **With [@nestjs/terminus](https://docs.nestjs.com/recipes/terminus) (zero boilerplate):**
 
@@ -788,7 +793,7 @@ If the initial NATS connection is refused, the module throws an `Error` immediat
 
 #### Observable return values
 
-Handlers can return Observables. The transport takes the **first emitted value** for RPC responses and awaits completion for events:
+Handlers can return Observables. The transport resolves on the **first emitted value** (or on completion if the Observable emits nothing):
 
 ```typescript
 @MessagePattern('user.get')
@@ -798,7 +803,7 @@ getUser(@Payload() data: { id: number }): Observable<UserDto> {
 
 @EventPattern('order.created')
 handleOrder(@Payload() data: OrderDto): Observable<void> {
-  return this.pipeline.process(data); // awaits completion before ack
+  return this.pipeline.process(data); // ack after first emission or completion
 }
 ```
 

package/dist/index.cjs

@@ -203,7 +203,11 @@ var JetstreamRecordBuilder = class {
   constructor(data) {
     this.data = data;
   }
-  /** Set the message payload. */
+  /**
+   * Set the message payload.
+   *
+   * @param data - Payload to serialize via the configured {@link Codec}.
+   */
   setData(data) {
     this.data = data;
     return this;
@@ -211,6 +215,8 @@ var JetstreamRecordBuilder = class {
   /**
    * Set a single custom header.
    *
+   * @param key - Header name (e.g. `'x-tenant'`).
+   * @param value - Header value.
    * @throws Error if the header name is reserved by the transport.
    */
   setHeader(key, value) {
@@ -221,6 +227,7 @@ var JetstreamRecordBuilder = class {
   /**
    * Set multiple custom headers at once.
    *
+   * @param headers - Key-value pairs to set as headers.
    * @throws Error if any header name is reserved by the transport.
    */
   setHeaders(headers2) {
@@ -229,12 +236,20 @@ var JetstreamRecordBuilder = class {
     }
     return this;
   }
-  /** Set RPC request timeout in milliseconds. */
+  /**
+   * Set per-request RPC timeout.
+   *
+   * @param ms - Timeout in milliseconds. Overrides the global RPC timeout for this request only.
+   */
   setTimeout(ms) {
     this.timeout = ms;
     return this;
   }
-  /** Build the immutable JetstreamRecord. */
+  /**
+   * Build the immutable {@link JetstreamRecord}.
+   *
+   * @returns A frozen record ready to pass to `client.send()` or `client.emit()`.
+   */
   build() {
     return new JetstreamRecord(this.data, new Map(this.headers), this.timeout);
   }
@@ -270,7 +285,14 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   pendingTimeouts = /* @__PURE__ */ new Map();
   /** Subscription to connection status events for disconnect handling. */
   statusSubscription = null;
-  /** Establish connection. Called automatically by NestJS on first use. */
+  /**
+   * Establish connection. Called automatically by NestJS on first use.
+   *
+   * Sets up the JetStream RPC inbox (if in JetStream mode) and subscribes
+   * to connection status events for fail-fast disconnect handling.
+   *
+   * @returns The underlying NATS connection.
+   */
   async connect() {
     const nc = await this.connection.getConnection();
     if (this.isJetStreamRpcMode() && !this.inboxSubscription) {
@@ -283,13 +305,17 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     });
     return nc;
   }
-  /** Clean up resources. */
+  /** Clean up resources: reject pending RPCs, unsubscribe from status events. */
   async close() {
     this.statusSubscription?.unsubscribe();
     this.statusSubscription = null;
     this.rejectPendingRpcs(new Error("Client closed"));
   }
-  /** Direct access to the raw NATS connection. */
+  /**
+   * Direct access to the raw NATS connection.
+   *
+   * @throws Error if not connected.
+   */
   unwrap() {
     const nc = this.connection.unwrap;
     if (!nc) {
@@ -566,6 +592,7 @@ var ConnectionProvider = class {
   connection = null;
   connectionPromise = null;
   jsmInstance = null;
+  jsmPromise = null;
   /**
    * Establish NATS connection. Idempotent — returns cached connection on subsequent calls.
    *
@@ -585,16 +612,24 @@ var ConnectionProvider = class {
     return this.connectionPromise;
   }
   /**
-   * Get JetStream manager. Cached after first call.
+   * Get the JetStream manager. Cached after first call.
+   *
+   * @returns The JetStreamManager for stream/consumer administration.
    */
   async getJetStreamManager() {
     if (this.jsmInstance) return this.jsmInstance;
-    const nc = await this.getConnection();
-    this.jsmInstance = await nc.jetstreamManager();
-    this.logger.log("JetStream manager initialized");
-    return this.jsmInstance;
+    if (this.jsmPromise) return this.jsmPromise;
+    this.jsmPromise = (async () => {
+      const nc = await this.getConnection();
+      this.jsmInstance = await nc.jetstreamManager();
+      this.logger.log("JetStream manager initialized");
+      return this.jsmInstance;
+    })().finally(() => {
+      this.jsmPromise = null;
+    });
+    return this.jsmPromise;
   }
-  /** Direct access to the raw NATS connection (assumes already connected). */
+  /** Direct access to the raw NATS connection, or `null` if not yet connected. */
   get unwrap() {
     return this.connection;
   }
@@ -604,6 +639,12 @@ var ConnectionProvider = class {
    * Sequence: drain → wait for close. Falls back to force-close on error.
    */
   async shutdown() {
+    if (this.connectionPromise) {
+      try {
+        await this.connectionPromise;
+      } catch {
+      }
+    }
     if (!this.connection || this.connection.isClosed()) return;
     try {
       await this.connection.drain();
@@ -617,6 +658,7 @@ var ConnectionProvider = class {
       this.connection = null;
       this.connectionPromise = null;
       this.jsmInstance = null;
+      this.jsmPromise = null;
     }
   }
   /** Internal: establish the physical connection with reconnect monitoring. */
@@ -650,6 +692,7 @@ var ConnectionProvider = class {
             break;
           case import_nats4.Events.Reconnect:
             this.jsmInstance = null;
+            this.jsmPromise = null;
             this.eventBus.emit("reconnect" /* Reconnect */, nc.getServer());
             break;
           case import_nats4.Events.Error:
@@ -678,53 +721,28 @@ var EventBus = class {
     this.logger = logger;
     this.hooks = hooks ?? {};
   }
-  /** Emit a lifecycle event. Dispatches to custom hook or Logger fallback. */
+  /**
+   * Emit a lifecycle event. Dispatches to custom hook if registered, otherwise no-op.
+   *
+   * @param event - The {@link TransportEvent} to emit.
+   * @param args - Arguments matching the hook signature for this event.
+   */
   emit(event, ...args) {
     const hook = this.hooks[event];
-    if (hook) {
-      try {
-        hook(...args);
-      } catch (err) {
-        this.logger.error(
-          `Hook "${event}" threw an error: ${err instanceof Error ? err.message : err}`
-        );
-      }
-      return;
-    }
-    this.defaultHandler(event, args);
-  }
-  /** Default Logger-based handlers for each event type. */
-  defaultHandler(event, args) {
-    switch (event) {
-      case "connect" /* Connect */:
-        this.logger.log(`Connected to NATS: ${args[0]}`);
-        break;
-      case "disconnect" /* Disconnect */:
-        this.logger.warn("NATS connection lost");
-        break;
-      case "reconnect" /* Reconnect */:
-        this.logger.log(`Reconnected to NATS: ${args[0]}`);
-        break;
-      case "error" /* Error */:
-        this.logger.error(`Transport error: ${args[0]}`, args[1] ?? "");
-        break;
-      case "rpcTimeout" /* RpcTimeout */:
-        this.logger.warn(`RPC timeout: ${args[0]} (cid: ${args[1]})`);
-        break;
-      case "messageRouted" /* MessageRouted */:
-        this.logger.debug(`Message routed: ${args[0]} [${args[1]}]`);
-        break;
-      case "shutdownStart" /* ShutdownStart */:
-        this.logger.log("Graceful shutdown initiated");
-        break;
-      case "shutdownComplete" /* ShutdownComplete */:
-        this.logger.log("Graceful shutdown complete");
-        break;
-      case "deadLetter" /* DeadLetter */: {
-        const info = args[0];
-        this.logger.warn(`Dead letter: ${info?.subject ?? "unknown"}`);
-        break;
+    if (!hook) return;
+    try {
+      const result = hook(...args);
+      if (result && typeof result.catch === "function") {
+        result.catch((err) => {
+          this.logger.error(
+            `Async hook "${event}" rejected: ${err instanceof Error ? err.message : err}`
+          );
+        });
       }
+    } catch (err) {
+      this.logger.error(
+        `Hook "${event}" threw an error: ${err instanceof Error ? err.message : err}`
+      );
     }
   }
 };
@@ -741,6 +759,8 @@ var JetstreamHealthIndicator = class {
    *
    * Returns the current connection status without throwing.
    * Use this for custom health endpoints or monitoring integrations.
+   *
+   * @returns Connection status with server URL and RTT latency.
    */
   async check() {
     const nc = this.connection.unwrap;
@@ -763,7 +783,9 @@ var JetstreamHealthIndicator = class {
    * Returns `{ [key]: { status: 'up', ... } }` on success.
    * Throws an error with `{ [key]: { status: 'down', ... } }` on failure.
    *
-   * @param key Health indicator key (default: 'jetstream')
+   * @param key - Health indicator key (default: `'jetstream'`).
+   * @returns Object with status, server, and latency under the given key.
+   * @throws Error with `{ [key]: { status: 'down' } }` when disconnected.
    */
   async isHealthy(key = "jetstream") {
     const status = await this.check();
@@ -819,6 +841,7 @@ var JetstreamStrategy = class extends import_microservices2.Server {
     if (streamKinds.length > 0) {
       await this.streamProvider.ensureStreams(streamKinds);
       const consumers = await this.consumerProvider.ensureConsumers(streamKinds);
+      this.eventRouter.updateMaxDeliverMap(this.buildMaxDeliverMap(consumers));
       this.messageProvider.start(consumers);
       if (this.patternRegistry.hasEventHandlers() || this.patternRegistry.hasBroadcastHandlers()) {
         this.eventRouter.start();
@@ -832,7 +855,7 @@ var JetstreamStrategy = class extends import_microservices2.Server {
     }
     callback();
   }
-  /** Gracefully stop the transport. */
+  /** Stop all consumers, routers, and subscriptions. Called during shutdown. */
   close() {
     this.eventRouter.destroy();
     this.rpcRouter.destroy();
@@ -852,7 +875,11 @@ var JetstreamStrategy = class extends import_microservices2.Server {
     existing.push(callback);
     this.listeners.set(event, existing);
   }
-  /** Unwrap the underlying NATS connection. */
+  /**
+   * Unwrap the underlying NATS connection.
+   *
+   * @throws Error if the transport has not started.
+   */
   unwrap() {
     const nc = this.connection.unwrap;
     if (!nc) {
@@ -878,6 +905,18 @@ var JetstreamStrategy = class extends import_microservices2.Server {
     }
     return kinds;
   }
+  /** Build max_deliver map from actual NATS consumer configs (not options). */
+  buildMaxDeliverMap(consumers) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [, info] of consumers) {
+      const stream = info.stream_name;
+      const maxDeliver = info.config.max_deliver;
+      if (stream && maxDeliver !== void 0 && maxDeliver > 0) {
+        map.set(stream, maxDeliver);
+      }
+    }
+    return map;
+  }
   isCoreRpcMode() {
     return !this.options.rpc || this.options.rpc.mode === "core";
   }
@@ -893,23 +932,37 @@ var import_nats5 = require("nats");
 // src/context/rpc.context.ts
 var import_microservices3 = require("@nestjs/microservices");
 var RpcContext = class extends import_microservices3.BaseRpcContext {
-  /** Get the underlying NATS message (JsMsg for JetStream, Msg for Core). */
+  /**
+   * Get the underlying NATS message.
+   *
+   * @returns `JsMsg` for JetStream handlers, `Msg` for Core RPC handlers.
+   */
   getMessage() {
     return this.args[0];
   }
-  /** Get the NATS subject this message was published to. */
+  /** @returns The NATS subject this message was published to. */
   getSubject() {
     return this.args[0].subject;
   }
-  /** Get all NATS message headers, or undefined if none are present. */
+  /** @returns All NATS message headers, or `undefined` if none are present. */
   getHeaders() {
     return this.args[0].headers;
   }
-  /** Get a single header value by key. Returns undefined if the header or headers object is missing. */
+  /**
+   * Get a single header value by key.
+   *
+   * @param key - Header name (e.g. `'x-trace-id'`).
+   * @returns Header value, or `undefined` if the header is missing.
+   */
   getHeader(key) {
     return this.args[0].headers?.get(key);
   }
-  /** Type guard: narrows getMessage() return type to JsMsg when true. */
+  /**
+   * Type guard: returns `true` when the message is a JetStream message.
+   *
+   * Narrows `getMessage()` return type to `JsMsg`, giving access to
+   * `ack()`, `nak()`, `term()`, and delivery metadata.
+   */
   isJetStream() {
     return "ack" in this.args[0];
   }
@@ -937,11 +990,13 @@ var unwrapResult = async (result) => {
 };
 var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
   let done = false;
-  obs.subscribe({
+  let subscription = null;
+  subscription = obs.subscribe({
     next: (val) => {
       if (!done) {
         done = true;
         resolve(val);
+        subscription?.unsubscribe();
       }
     },
     error: reject,
@@ -949,6 +1004,9 @@ var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
       if (!done) resolve(void 0);
     }
   });
+  if (done) {
+    subscription.unsubscribe();
+  }
 });
 
 // src/server/core-rpc.server.ts
@@ -994,6 +1052,7 @@ var CoreRpcServer = class {
     const handler = this.patternRegistry.getHandler(msg.subject);
     if (!handler) {
       this.logger.warn(`No handler for Core RPC: ${msg.subject}`);
+      this.respondWithError(msg, new Error(`No handler for subject: ${msg.subject}`));
       return;
     }
     this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "rpc");
@@ -1156,9 +1215,9 @@ var ConsumerProvider = class {
     const name = config.durable_name;
     this.logger.log(`Ensuring consumer: ${name} on stream: ${stream}`);
     try {
-      const info = await jsm.consumers.info(stream, name);
-      this.logger.debug(`Consumer exists: ${name}`);
-      return info;
+      await jsm.consumers.info(stream, name);
+      this.logger.debug(`Consumer exists, updating: ${name}`);
+      return await jsm.consumers.update(stream, name, config);
     } catch (err) {
       if (err instanceof import_nats7.NatsError && err.api_error?.err_code === CONSUMER_NOT_FOUND) {
         this.logger.log(`Creating consumer: ${name}`);
@@ -1176,6 +1235,9 @@ var ConsumerProvider = class {
     const overrides = this.getOverrides(kind);
     if (kind === "broadcast") {
       const broadcastPatterns = this.patternRegistry.getBroadcastPatterns();
+      if (broadcastPatterns.length === 0) {
+        throw new Error("Broadcast consumer requested but no broadcast patterns are registered");
+      }
       if (broadcastPatterns.length === 1) {
         return {
           ...defaults,
@@ -1235,8 +1297,8 @@ var MessageProvider = class {
     this.eventBus = eventBus;
   }
   logger = new import_common7.Logger("Jetstream:Message");
-  destroy$ = new import_rxjs3.Subject();
   activeIterators = /* @__PURE__ */ new Set();
+  destroy$ = new import_rxjs3.Subject();
   eventMessages$ = new import_rxjs3.Subject();
   commandMessages$ = new import_rxjs3.Subject();
   broadcastMessages$ = new import_rxjs3.Subject();
@@ -1267,7 +1329,7 @@ var MessageProvider = class {
       (0, import_rxjs3.merge)(...flows).pipe((0, import_rxjs3.takeUntil)(this.destroy$)).subscribe();
     }
   }
-  /** Stop all consumer flows and complete all subjects. */
+  /** Stop all consumer flows and reinitialize subjects for potential restart. */
   destroy() {
     this.destroy$.next();
     this.destroy$.complete();
@@ -1278,17 +1340,23 @@ var MessageProvider = class {
     this.eventMessages$.complete();
     this.commandMessages$.complete();
     this.broadcastMessages$.complete();
+    this.destroy$ = new import_rxjs3.Subject();
+    this.eventMessages$ = new import_rxjs3.Subject();
+    this.commandMessages$ = new import_rxjs3.Subject();
+    this.broadcastMessages$ = new import_rxjs3.Subject();
   }
   /** Create a self-healing consumer flow for a specific kind. */
   createFlow(kind, info) {
     const target$ = this.getTargetSubject(kind);
     let consecutiveFailures = 0;
+    let lastRunFailed = false;
     return (0, import_rxjs3.defer)(() => this.consumeOnce(info, target$)).pipe(
       (0, import_rxjs3.tap)(() => {
-        consecutiveFailures = 0;
+        lastRunFailed = false;
       }),
       (0, import_rxjs3.catchError)((err) => {
         consecutiveFailures++;
+        lastRunFailed = true;
         this.logger.error(`Consumer ${info.name} error, will restart:`, err);
         this.eventBus.emit(
           "error" /* Error */,
@@ -1299,13 +1367,11 @@ var MessageProvider = class {
       }),
       (0, import_rxjs3.repeat)({
         delay: () => {
+          if (!lastRunFailed) {
+            consecutiveFailures = 0;
+          }
           const delay = Math.min(100 * Math.pow(2, consecutiveFailures), 3e4);
           this.logger.warn(`Consumer ${info.name} stream ended, restarting in ${delay}ms...`);
-          this.eventBus.emit(
-            "error" /* Error */,
-            new Error(`Consumer ${info.name} stream ended`),
-            "message-provider"
-          );
           return (0, import_rxjs3.timer)(delay);
         }
       }),
@@ -1448,6 +1514,14 @@ var EventRouter = class {
   }
   logger = new import_common9.Logger("Jetstream:EventRouter");
   subscriptions = [];
+  /**
+   * Update the max_deliver thresholds from actual NATS consumer configs.
+   * Called after consumers are ensured so the DLQ map reflects reality.
+   */
+  updateMaxDeliverMap(consumerMaxDelivers) {
+    if (!this.deadLetterConfig) return;
+    this.deadLetterConfig.maxDeliverByStream = consumerMaxDelivers;
+  }
   /** Start routing event and broadcast messages to handlers. */
   start() {
     this.subscribeToStream(this.messageProvider.events$, "workqueue");
@@ -1497,10 +1571,7 @@ var EventRouter = class {
   /** Execute handler, then ack on success or nak/dead-letter on failure. */
   async executeHandler(handler, data, ctx, msg) {
     try {
-      const result = await handler(data, ctx);
-      if ((0, import_rxjs4.isObservable)(result)) {
-        await (0, import_rxjs4.lastValueFrom)(result, { defaultValue: void 0 });
-      }
+      await unwrapResult(handler(data, ctx));
       msg.ack();
     } catch (err) {
       this.logger.error(`Event handler error (${msg.subject}):`, err);
@@ -1515,7 +1586,7 @@ var EventRouter = class {
   isDeadLetter(msg) {
     if (!this.deadLetterConfig) return false;
     const maxDeliver = this.deadLetterConfig.maxDeliverByStream.get(msg.info.stream);
-    if (maxDeliver === void 0) return false;
+    if (maxDeliver === void 0 || maxDeliver <= 0) return false;
     return msg.info.deliveryCount >= maxDeliver;
   }
   /** Handle a dead letter: invoke callback, then term or nak based on result. */
@@ -1773,26 +1844,6 @@ var JetstreamModule = class {
   // -------------------------------------------------------------------
   // Provider factories
   // -------------------------------------------------------------------
-  /** Create all providers for synchronous forRoot(). */
-  /**
-   * Build a map of stream name -> max_deliver for dead letter detection.
-   * Each stream kind (ev, broadcast) has its own consumer config with potentially
-   * different max_deliver values.
-   */
-  static buildMaxDeliverMap(options) {
-    const map = /* @__PURE__ */ new Map();
-    const defaultEventMax = DEFAULT_EVENT_CONSUMER_CONFIG.max_deliver ?? 3;
-    const defaultBroadcastMax = DEFAULT_BROADCAST_CONSUMER_CONFIG.max_deliver ?? 3;
-    map.set(
-      streamName(options.name, "ev"),
-      options.events?.consumer?.max_deliver ?? defaultEventMax
-    );
-    map.set(
-      streamName(options.name, "broadcast"),
-      options.broadcast?.consumer?.max_deliver ?? defaultBroadcastMax
-    );
-    return map;
-  }
   static createCoreProviders(options) {
     return [
       {
@@ -1903,7 +1954,7 @@ var JetstreamModule = class {
         useFactory: (options, messageProvider, patternRegistry, codec, eventBus) => {
           if (options.consumer === false) return null;
           const deadLetterConfig = options.onDeadLetter ? {
-            maxDeliverByStream: JetstreamModule.buildMaxDeliverMap(options),
+            maxDeliverByStream: /* @__PURE__ */ new Map(),
             onDeadLetter: options.onDeadLetter
           } : void 0;
           return new EventRouter(