@horizon-republic/nestjs-jetstream 2.3.0 → 2.3.2

package/README.md

@@ -16,24 +16,25 @@ A production-grade NestJS transport for NATS JetStream with built-in support for
   - [forRoot / forRootAsync](#forroot--forrootasync)
   - [forFeature](#forfeature)
   - [Full Options Reference](#full-options-reference)
-- [RPC (Request/Reply)](#rpc-requestreply)
-  - [Core Mode (Default)](#core-mode-default)
-  - [JetStream Mode](#jetstream-mode)
-- [Events](#events)
-  - [Workqueue Events](#workqueue-events)
-  - [Broadcast Events](#broadcast-events)
-- [JetstreamRecord Builder](#jetstreamrecord-builder)
-- [Custom Codec](#custom-codec)
-- [RpcContext](#rpccontext)
-- [Lifecycle Hooks](#lifecycle-hooks)
-- [Health Checks](#health-checks)
-- [Graceful Shutdown](#graceful-shutdown)
-- [Edge Cases & Important Notes](#edge-cases--important-notes)
-- [NATS Naming Conventions](#nats-naming-conventions)
-- [Default Stream & Consumer Configs](#default-stream--consumer-configs)
-- [API Reference](#api-reference)
-- [Testing](#testing)
-- [Contributing](#contributing)
+- [Messaging Patterns](#messaging-patterns)
+  - [RPC (Request/Reply)](#rpc-requestreply)
+  - [Events](#events)
+  - [JetstreamRecord Builder](#jetstreamrecord-builder)
+- [Handler Context & Serialization](#handler-context--serialization)
+  - [RpcContext](#rpccontext)
+  - [Custom Codec](#custom-codec)
+- [Operations](#operations)
+  - [Lifecycle Hooks](#lifecycle-hooks)
+  - [Health Checks](#health-checks)
+  - [Graceful Shutdown](#graceful-shutdown)
+- [Reference](#reference)
+  - [Edge Cases & Important Notes](#edge-cases--important-notes)
+  - [NATS Naming Conventions](#nats-naming-conventions)
+  - [Default Stream & Consumer Configs](#default-stream--consumer-configs)
+  - [API Reference](#api-reference)
+- [Development](#development)
+  - [Testing](#testing)
+  - [Contributing](#contributing)
 - [License](#license)
 - [Links](#links)
 
@@ -317,9 +318,11 @@ rpc: {
 }
 ```
 
-## RPC (Request/Reply)
+## Messaging Patterns
 
-### Core Mode (Default)
+### RPC (Request/Reply)
+
+#### Core Mode (Default)
 
 Uses NATS native `request/reply` for the lowest possible latency.
 
@@ -348,7 +351,7 @@ JetstreamModule.forRoot({
 | No handler running | Client times out |
 | Decode error | Error response returned to caller |
 
-### JetStream Mode
+#### JetStream Mode
 
 Commands are persisted in a JetStream stream. Responses flow back via NATS Core inbox.
 
@@ -379,9 +382,9 @@ JetstreamModule.forRoot({
 
 > **Why `term` instead of `nak` for RPC errors?** Redelivering a failed command could cause duplicate side effects. The caller is responsible for retrying.
 
-## Events
+### Events
 
-### Workqueue Events
+#### Workqueue Events
 
 Each event is delivered to **one** handler instance (load-balanced). Messages are acked **after** the handler completes successfully.
 
@@ -429,7 +432,7 @@ JetstreamModule.forRoot({
 })
 ```
 
-### Broadcast Events
+#### Broadcast Events
 
 Broadcast events are delivered to **all** subscribing services. Each service gets its own durable consumer on a shared `broadcast-stream`.
 
@@ -469,7 +472,7 @@ JetstreamModule.forRoot({
 
 > **Note:** The broadcast stream is shared across all services — stream-level settings (e.g., `max_age`, `max_bytes`) affect everyone. Consumer-level settings are per-service.
 
-## JetstreamRecord Builder
+### JetstreamRecord Builder
 
 Attach custom headers and per-request timeouts using the builder pattern:
 
@@ -507,7 +510,41 @@ Attempting to set a reserved header throws an error at build time.
 | `x-trace-id`    | Available for distributed tracing           |
 | `x-span-id`     | Available for distributed tracing           |
 
-## Custom Codec
+## Handler Context & Serialization
+
+### RpcContext
+
+Execution context available in all handlers via `@Ctx()`:
+
+```typescript
+import { Ctx, Payload, MessagePattern } from '@nestjs/microservices';
+import { RpcContext } from '@horizon-republic/nestjs-jetstream';
+
+@MessagePattern('user.get')
+getUser(@Payload() data: GetUserDto, @Ctx() ctx: RpcContext) {
+  const subject = ctx.getSubject();            // Full NATS subject
+  const traceId = ctx.getHeader('x-trace-id'); // Single header value
+  const headers = ctx.getHeaders();            // All headers (MsgHdrs)
+  const isJs = ctx.isJetStream();              // true for JetStream messages
+  const msg = ctx.getMessage();                // Raw JsMsg | Msg (escape hatch)
+
+  return this.userService.findOne(data.id);
+}
+```
+
+**Available methods:**
+
+| Method           | Returns                | Description                               |
+|------------------|------------------------|-------------------------------------------|
+| `getSubject()`   | `string`               | NATS subject the message was published to |
+| `getHeader(key)` | `string \| undefined`  | Single header value by key                |
+| `getHeaders()`   | `MsgHdrs \| undefined` | All NATS message headers                  |
+| `isJetStream()`  | `boolean`              | Whether the message supports ack/nak/term |
+| `getMessage()`   | `JsMsg \| Msg`         | Raw NATS message (escape hatch)           |
+
+Available on both `@EventPattern` and `@MessagePattern` handlers.
+
+### Custom Codec
 
 The library uses JSON by default. Implement the `Codec` interface for any serialization format:
 
@@ -543,39 +580,9 @@ JetstreamModule.forFeature({
 
 > All services communicating with each other **must use the same codec**. A codec mismatch results in decode errors (`term`, no redelivery).
 
-## RpcContext
+## Operations
 
-Execution context available in all handlers via `@Ctx()`:
-
-```typescript
-import { Ctx, Payload, MessagePattern } from '@nestjs/microservices';
-import { RpcContext } from '@horizon-republic/nestjs-jetstream';
-
-@MessagePattern('user.get')
-getUser(@Payload() data: GetUserDto, @Ctx() ctx: RpcContext) {
-  const subject = ctx.getSubject();            // Full NATS subject
-  const traceId = ctx.getHeader('x-trace-id'); // Single header value
-  const headers = ctx.getHeaders();            // All headers (MsgHdrs)
-  const isJs = ctx.isJetStream();              // true for JetStream messages
-  const msg = ctx.getMessage();                // Raw JsMsg | Msg (escape hatch)
-
-  return this.userService.findOne(data.id);
-}
-```
-
-**Available methods:**
-
-| Method           | Returns                | Description                               |
-|------------------|------------------------|-------------------------------------------|
-| `getSubject()`   | `string`               | NATS subject the message was published to |
-| `getHeader(key)` | `string \| undefined`  | Single header value by key                |
-| `getHeaders()`   | `MsgHdrs \| undefined` | All NATS message headers                  |
-| `isJetStream()`  | `boolean`              | Whether the message supports ack/nak/term |
-| `getMessage()`   | `JsMsg \| Msg`         | Raw NATS message (escape hatch)           |
-
-Available on both `@EventPattern` and `@MessagePattern` handlers.
-
-## Lifecycle Hooks
+### Lifecycle Hooks
 
 Subscribe to transport events for monitoring, alerting, or custom logic:
 
@@ -616,7 +623,7 @@ JetstreamModule.forRoot({
 | `shutdownComplete` | `()`                                        | `Logger.log`      |
 | `deadLetter`       | `(info: DeadLetterInfo)`                    | `Logger.warn`     |
 
-### Dead Letter Queue (DLQ)
+#### Dead Letter Queue (DLQ)
 
 When an event handler fails on every delivery attempt (`max_deliver`), the message becomes a "dead letter." By default, NATS terminates it silently. Configure `onDeadLetter` to intercept these messages:
 
@@ -662,7 +669,7 @@ JetstreamModule.forRootAsync({
 });
 ```
 
-## Health Checks
+### 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.
 
@@ -702,7 +709,7 @@ const status = await this.jetstream.check();
 | `check()`         | `JetstreamHealthStatus`            | Never                              |
 | `isHealthy(key?)` | `{ [key]: { status: 'up', ... } }` | On unhealthy (Terminus convention) |
 
-## Graceful Shutdown
+### Graceful Shutdown
 
 The transport shuts down automatically via NestJS `onApplicationShutdown()`:
 
@@ -720,13 +727,15 @@ JetstreamModule.forRoot({
 
 No manual shutdown code needed.
 
-## Edge Cases & Important Notes
+## Reference
 
-### Event handlers must be idempotent
+### Edge Cases & Important Notes
+
+#### Event handlers must be idempotent
 
 Events use at-least-once delivery. If your handler throws, the message is `nak`'d and NATS redelivers it (up to `max_deliver` times, default 3). Design handlers to be safe for repeated execution.
 
-### RPC error handling
+#### RPC error handling
 
 The transport fully supports NestJS `RpcException` and custom exception filters. Throw `RpcException` with any payload — it will be delivered to the caller as-is:
 
@@ -751,11 +760,11 @@ this.client.send('user.update', data).subscribe({
 
 In JetStream mode, failed RPC messages are `term`'d (not `nak`'d) to prevent duplicate side effects. The caller is responsible for implementing retry logic.
 
-### Fire-and-forget events
+#### Fire-and-forget events
 
 This library focuses on **reliable, persistent** event delivery via JetStream. If you need fire-and-forget (no persistence, no ack) for high-throughput scenarios, use the standard [NestJS NATS transport](https://docs.nestjs.com/microservices/nats) — it works perfectly alongside this library on the same NATS server.
 
-### Publisher-only mode
+#### Publisher-only mode
 
 For services that only send messages (e.g., API gateways), disable consumer infrastructure:
 
@@ -767,17 +776,17 @@ JetstreamModule.forRoot({
 })
 ```
 
-### Broadcast stream is shared
+#### Broadcast stream is shared
 
 All services share a single `broadcast-stream`. Each service creates its own durable consumer with `filter_subjects` matching only its registered broadcast patterns. Stream-level configuration (`broadcast.stream`) affects all services.
 
 Broadcast consumers use the same ack/nak semantics as workqueue consumers. Because each service has an **isolated durable consumer**, a `nak` (retry) from one service only causes redelivery to that specific service — other consumers are unaffected. This gives broadcast **at-least-once delivery per consumer** with independent retry.
 
-### Connection failure behavior
+#### Connection failure behavior
 
-If the initial NATS connection is refused, the module throws a `RuntimeException` immediately (fail fast). For transient disconnects after startup, NATS handles reconnection automatically and the `reconnect` hook fires.
+If the initial NATS connection is refused, the module throws an `Error` immediately (fail fast). For transient disconnects after startup, NATS handles reconnection automatically and the `reconnect` hook fires.
 
-### Observable return values
+#### Observable return values
 
 Handlers can return Observables. The transport takes the **first emitted value** for RPC responses and awaits completion for events:
 
@@ -793,15 +802,15 @@ handleOrder(@Payload() data: OrderDto): Observable<void> {
 }
 ```
 
-### Consumer self-healing
+#### Consumer self-healing
 
-If a JetStream consumer's message iterator ends unexpectedly (e.g., NATS restart), the transport automatically re-establishes consumption after a 100ms delay. This is logged as a warning.
+If a JetStream consumer's message iterator ends unexpectedly (e.g., NATS restart), the transport automatically re-establishes consumption with exponential backoff (100ms up to 30s). This is logged as a warning.
 
-### NATS header size
+#### NATS header size
 
 Custom headers are transmitted as NATS message headers. NATS has a default header size limit. If you're attaching large metadata, consider putting it in the message body instead.
 
-## NATS Naming Conventions
+### NATS Naming Conventions
 
 The transport generates NATS subjects, streams, and consumers based on the service `name`:
 
@@ -818,7 +827,7 @@ The transport generates NATS subjects, streams, and consumers based on the servi
 | Command consumer   | `{internal}_cmd-consumer`       | `orders__microservice_cmd-consumer`       |
 | Broadcast consumer | `{internal}_broadcast-consumer` | `orders__microservice_broadcast-consumer` |
 
-## Default Stream & Consumer Configs
+### Default Stream & Consumer Configs
 
 All defaults can be overridden via `events`, `broadcast`, or `rpc` options.
 
@@ -905,9 +914,9 @@ All defaults can be overridden via `events`, `broadcast`, or `rpc` options.
 
 </details>
 
-## API Reference
+### API Reference
 
-### Exports
+#### Exports
 
 ```typescript
 // Module
@@ -951,7 +960,7 @@ StreamConsumerOverrides
 TransportHooks
 ```
 
-### Helper: `nanos(ms)`
+#### Helper: `nanos(ms)`
 
 Convert milliseconds to nanoseconds (required by NATS JetStream config):
 
@@ -965,9 +974,11 @@ events: {
 }
 ```
 
-## Testing
+## Development
+
+### Testing
 
-The project uses [Jest](https://jestjs.io/) with two test suites configured as [projects](https://jestjs.io/docs/configuration#projects-arraystring--projectconfig):
+The project uses [Vitest](https://vitest.dev/) with two test suites configured as [projects](https://vitest.dev/guide/workspace):
 
 ```bash
 # Unit tests (no external dependencies)
@@ -986,7 +997,7 @@ pnpm test:watch
 pnpm test:cov
 ```
 
-### Running NATS locally
+#### Running NATS locally
 
 Integration tests require a NATS server with JetStream enabled:
 
@@ -994,15 +1005,15 @@ Integration tests require a NATS server with JetStream enabled:
 docker run -d --name nats -p 4222:4222 nats:latest -js
 ```
 
-### Writing tests
+#### Writing tests
 
 - Use `sut` (system under test) for the main instance
-- Use `createMock<T>()` from `@golevelup/ts-jest` for mocking
+- Use `createMock<T>()` from `@golevelup/ts-vitest` for mocking
 - Follow Given-When-Then structure with comments
 - Order: happy path → edge cases → error cases
-- Always include `afterEach(jest.resetAllMocks)`
+- Always include `afterEach(vi.resetAllMocks)`
 
-## Contributing
+### Contributing
 
 Contributions are welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
 
@@ -1017,4 +1028,4 @@ Contributions are welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for
 - [GitHub Repository](https://github.com/HorizonRepublic/nestjs-jetstream)
 - [npm Package](https://www.npmjs.com/package/@horizon-republic/nestjs-jetstream)
 - [Report bugs](https://github.com/HorizonRepublic/nestjs-jetstream/issues)
-- [Discussions](https://github.com/HorizonRepublic/nestjs-jetstream/discussions)
+- [Discussions](https://github.com/HorizonRepublic/nestjs-jetstream/discussions)

package/dist/index.cjs

@@ -291,7 +291,11 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   }
   /** Direct access to the raw NATS connection. */
   unwrap() {
-    return this.connection.unwrap;
+    const nc = this.connection.unwrap;
+    if (!nc) {
+      throw new Error("Not connected \u2014 call connect() before unwrap()");
+    }
+    return nc;
   }
   /**
    * Publish a fire-and-forget event to JetStream.
@@ -304,10 +308,13 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     const { data, hdrs } = this.extractRecordData(packet.data);
     const subject = this.buildEventSubject(packet.pattern);
     const msgHeaders = this.buildHeaders(hdrs, { subject });
-    await nc.jetstream().publish(subject, this.codec.encode(data), {
+    const ack = await nc.jetstream().publish(subject, this.codec.encode(data), {
       headers: msgHeaders,
       msgID: crypto.randomUUID()
     });
+    if (ack.duplicate) {
+      this.logger.warn(`Duplicate event publish detected: ${subject} (seq: ${ack.seq})`);
+    }
     return void 0;
   }
   /**
@@ -571,7 +578,10 @@ var ConnectionProvider = class {
     if (this.connectionPromise) {
       return this.connectionPromise;
     }
-    this.connectionPromise = this.establish();
+    this.connectionPromise = this.establish().catch((err) => {
+      this.connectionPromise = null;
+      throw err;
+    });
     return this.connectionPromise;
   }
   /**
@@ -624,8 +634,7 @@ var ConnectionProvider = class {
       this.monitorStatus(nc);
       return nc;
     } catch (err) {
-      const natsErr = err;
-      if (natsErr.code === "CONNECTION_REFUSED") {
+      if (err instanceof import_nats4.NatsError && err.code === "CONNECTION_REFUSED") {
         throw new Error(`NATS connection refused: ${this.options.servers.join(", ")}`);
       }
       throw err;
@@ -793,12 +802,18 @@ var JetstreamStrategy = class extends import_microservices2.Server {
   transportId = /* @__PURE__ */ Symbol("jetstream-transport");
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   listeners = /* @__PURE__ */ new Map();
+  started = false;
   /**
    * Start the transport: register handlers, create infrastructure, begin consumption.
    *
    * Called by NestJS when `connectMicroservice()` is used, or internally by the module.
    */
   async listen(callback) {
+    if (this.started) {
+      this.logger.warn("listen() called more than once \u2014 ignoring");
+      return;
+    }
+    this.started = true;
     this.patternRegistry.registerHandlers(this.getHandlers());
     const streamKinds = this.resolveStreamKinds();
     if (streamKinds.length > 0) {
@@ -823,11 +838,12 @@ var JetstreamStrategy = class extends import_microservices2.Server {
     this.rpcRouter.destroy();
     this.coreRpcServer.stop();
     this.messageProvider.destroy();
+    this.started = false;
   }
   /**
    * Register event listener (required by Server base class).
    *
-   * Stores callbacks for potential use. Primary lifecycle events
+   * Stores callbacks for client use. Primary lifecycle events
    * are routed through EventBus.
    */
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
@@ -838,7 +854,11 @@ var JetstreamStrategy = class extends import_microservices2.Server {
   }
   /** Unwrap the underlying NATS connection. */
   unwrap() {
-    return this.connection.unwrap;
+    const nc = this.connection.unwrap;
+    if (!nc) {
+      throw new Error("Not connected \u2014 transport has not started");
+    }
+    return nc;
   }
   /** Access the pattern registry (for module-level introspection). */
   getPatternRegistry() {
@@ -1008,6 +1028,7 @@ var CoreRpcServer = class {
 
 // src/server/infrastructure/stream.provider.ts
 var import_common5 = require("@nestjs/common");
+var import_nats6 = require("nats");
 var STREAM_NOT_FOUND = 10059;
 var StreamProvider = class {
   constructor(options, connection) {
@@ -1050,8 +1071,7 @@ var StreamProvider = class {
       this.logger.debug(`Stream exists, updating: ${config.name}`);
       return await jsm.streams.update(config.name, config);
     } catch (err) {
-      const natsErr = err;
-      if (natsErr.api_error?.err_code === STREAM_NOT_FOUND) {
+      if (err instanceof import_nats6.NatsError && err.api_error?.err_code === STREAM_NOT_FOUND) {
         this.logger.log(`Creating stream: ${config.name}`);
         return await jsm.streams.add(config);
       }
@@ -1099,6 +1119,7 @@ var StreamProvider = class {
 
 // src/server/infrastructure/consumer.provider.ts
 var import_common6 = require("@nestjs/common");
+var import_nats7 = require("nats");
 var CONSUMER_NOT_FOUND = 10014;
 var ConsumerProvider = class {
   constructor(options, connection, streamProvider, patternRegistry) {
@@ -1139,8 +1160,7 @@ var ConsumerProvider = class {
       this.logger.debug(`Consumer exists: ${name}`);
       return info;
     } catch (err) {
-      const natsErr = err;
-      if (natsErr.api_error?.err_code === CONSUMER_NOT_FOUND) {
+      if (err instanceof import_nats7.NatsError && err.api_error?.err_code === CONSUMER_NOT_FOUND) {
         this.logger.log(`Creating consumer: ${name}`);
         return await jsm.consumers.add(stream, config);
       }
@@ -1216,6 +1236,7 @@ var MessageProvider = class {
   }
   logger = new import_common7.Logger("Jetstream:Message");
   destroy$ = new import_rxjs3.Subject();
+  activeIterators = /* @__PURE__ */ new Set();
   eventMessages$ = new import_rxjs3.Subject();
   commandMessages$ = new import_rxjs3.Subject();
   broadcastMessages$ = new import_rxjs3.Subject();
@@ -1250,6 +1271,10 @@ var MessageProvider = class {
   destroy() {
     this.destroy$.next();
     this.destroy$.complete();
+    for (const messages of this.activeIterators) {
+      messages.stop();
+    }
+    this.activeIterators.clear();
     this.eventMessages$.complete();
     this.commandMessages$.complete();
     this.broadcastMessages$.complete();
@@ -1257,8 +1282,13 @@ var MessageProvider = class {
   /** Create a self-healing consumer flow for a specific kind. */
   createFlow(kind, info) {
     const target$ = this.getTargetSubject(kind);
+    let consecutiveFailures = 0;
     return (0, import_rxjs3.defer)(() => this.consumeOnce(info, target$)).pipe(
+      (0, import_rxjs3.tap)(() => {
+        consecutiveFailures = 0;
+      }),
       (0, import_rxjs3.catchError)((err) => {
+        consecutiveFailures++;
         this.logger.error(`Consumer ${info.name} error, will restart:`, err);
         this.eventBus.emit(
           "error" /* Error */,
@@ -1269,13 +1299,14 @@ var MessageProvider = class {
       }),
       (0, import_rxjs3.repeat)({
         delay: () => {
-          this.logger.warn(`Consumer ${info.name} stream ended, restarting...`);
+          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)(100);
+          return (0, import_rxjs3.timer)(delay);
         }
       }),
       (0, import_rxjs3.takeUntil)(this.destroy$)
@@ -1286,8 +1317,13 @@ var MessageProvider = class {
     const js = (await this.connection.getConnection()).jetstream();
     const consumer = await js.consumers.get(info.stream_name, info.name);
     const messages = await consumer.consume();
-    for await (const msg of messages) {
-      target$.next(msg);
+    this.activeIterators.add(messages);
+    try {
+      for await (const msg of messages) {
+        target$.next(msg);
+      }
+    } finally {
+      this.activeIterators.delete(messages);
     }
   }
   /** Get the target subject for a consumer kind. */
@@ -1427,11 +1463,14 @@ var EventRouter = class {
   /** Subscribe to a message stream and route each message. */
   subscribeToStream(stream$, label) {
     const subscription = stream$.pipe(
-      (0, import_rxjs4.mergeMap)((msg) => this.handle(msg)),
-      (0, import_rxjs4.catchError)((err, caught) => {
-        this.logger.error(`Unexpected error in ${label} event router`, err);
-        return caught;
-      })
+      (0, import_rxjs4.mergeMap)(
+        (msg) => (0, import_rxjs4.defer)(() => this.handle(msg)).pipe(
+          (0, import_rxjs4.catchError)((err) => {
+            this.logger.error(`Unexpected error in ${label} event router`, err);
+            return import_rxjs4.EMPTY;
+          })
+        )
+      )
     ).subscribe();
     this.subscriptions.push(subscription);
   }
@@ -1505,7 +1544,7 @@ var EventRouter = class {
 
 // src/server/routing/rpc.router.ts
 var import_common10 = require("@nestjs/common");
-var import_nats6 = require("nats");
+var import_nats8 = require("nats");
 var import_rxjs5 = require("rxjs");
 var RpcRouter = class {
   constructor(messageProvider, patternRegistry, connection, codec, eventBus, timeout) {
@@ -1522,11 +1561,14 @@ var RpcRouter = class {
   /** Start routing command messages to handlers. */
   start() {
     this.subscription = this.messageProvider.commands$.pipe(
-      (0, import_rxjs5.mergeMap)((msg) => this.handle(msg)),
-      (0, import_rxjs5.catchError)((err, caught) => {
-        this.logger.error("Unexpected error in RPC router", err);
-        return caught;
-      })
+      (0, import_rxjs5.mergeMap)(
+        (msg) => (0, import_rxjs5.defer)(() => this.handle(msg)).pipe(
+          (0, import_rxjs5.catchError)((err) => {
+            this.logger.error("Unexpected error in RPC router", err);
+            return import_rxjs5.EMPTY;
+          })
+        )
+      )
     ).subscribe();
   }
   /** Stop routing and unsubscribe. */
@@ -1564,7 +1606,7 @@ var RpcRouter = class {
   async executeHandler(handler, data, msg, replyTo, correlationId) {
     const nc = await this.connection.getConnection();
     const ctx = new RpcContext([msg]);
-    const hdrs = (0, import_nats6.headers)();
+    const hdrs = (0, import_nats8.headers)();
     hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
     let settled = false;
     const timeoutId = setTimeout(() => {
@@ -1579,8 +1621,12 @@ var RpcRouter = class {
       if (settled) return;
       settled = true;
       clearTimeout(timeoutId);
-      nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
       msg.ack();
+      try {
+        nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
+      } catch (publishErr) {
+        this.logger.error(`Failed to publish RPC response for ${msg.subject}`, publishErr);
+      }
     } catch (err) {
       if (settled) return;
       settled = true;
@@ -1614,10 +1660,17 @@ var ShutdownManager = class {
     this.eventBus.emit("shutdownStart" /* ShutdownStart */);
     this.logger.log(`Graceful shutdown started (timeout: ${this.timeout}ms)`);
     strategy?.close();
-    await Promise.race([
-      this.connection.shutdown(),
-      new Promise((resolve) => setTimeout(resolve, this.timeout))
-    ]);
+    let timeoutId;
+    try {
+      await Promise.race([
+        this.connection.shutdown(),
+        new Promise((resolve) => {
+          timeoutId = setTimeout(resolve, this.timeout);
+        })
+      ]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
     this.eventBus.emit("shutdownComplete" /* ShutdownComplete */);
     this.logger.log("Graceful shutdown complete");
   }