@horizon-republic/nestjs-jetstream 2.9.0 → 2.9.1

package/dist/index.js

@@ -398,6 +398,7 @@ var nanosToGoDuration = (nanos) => {
 };
 
 // src/client/jetstream.client.ts
+var BROADCAST_SUBJECT_PREFIX = "broadcast.";
 var JetstreamClient = class extends ClientProxy {
   constructor(rootOptions, targetServiceName, connection, codec, eventBus) {
     super();
@@ -407,12 +408,33 @@ var JetstreamClient = class extends ClientProxy {
     this.eventBus = eventBus;
     this.targetName = targetServiceName;
     this.callerName = internalName(this.rootOptions.name);
+    const targetInternal = internalName(targetServiceName);
+    this.eventSubjectPrefix = `${targetInternal}.${"ev" /* Event */}.`;
+    this.commandSubjectPrefix = `${targetInternal}.${"cmd" /* Command */}.`;
+    this.orderedSubjectPrefix = `${targetInternal}.${"ordered" /* Ordered */}.`;
+    this.isCoreMode = isCoreRpcMode(this.rootOptions.rpc);
+    this.defaultRpcTimeout = isJetStreamRpcMode(this.rootOptions.rpc) ? this.rootOptions.rpc?.timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT : this.rootOptions.rpc?.timeout ?? DEFAULT_RPC_TIMEOUT;
   }
   logger = new Logger("Jetstream:Client");
   /** Target service name this client sends messages to. */
   targetName;
   /** Pre-cached caller name derived from rootOptions.name, computed once in constructor. */
   callerName;
+  /**
+   * Subject prefixes of the form `{serviceName}__microservice.{kind}.` — one
+   * per stream kind this client may publish to. Built once in the constructor
+   * so producing a full subject is a single string concat with the user pattern.
+   */
+  eventSubjectPrefix;
+  commandSubjectPrefix;
+  orderedSubjectPrefix;
+  /**
+   * RPC configuration snapshots. The values are derived from rootOptions at
+   * construction time so the publish hot path never has to re-run
+   * isCoreRpcMode / getRpcTimeout on every call.
+   */
+  isCoreMode;
+  defaultRpcTimeout;
   /** Shared inbox for JetStream-mode RPC responses. */
   inbox = null;
   inboxSubscription = null;
@@ -422,6 +444,12 @@ var JetstreamClient = class extends ClientProxy {
   pendingTimeouts = /* @__PURE__ */ new Map();
   /** Subscription to connection status events for disconnect handling. */
   statusSubscription = null;
+  /**
+   * Cached readiness flag. Once `connect()` has wired the inbox and status
+   * subscription, subsequent publishes skip the `await connect()` microtask
+   * and reach for the underlying connection synchronously instead.
+   */
+  readyForPublish = false;
   /**
    * Establish connection. Called automatically by NestJS on first use.
    *
@@ -432,7 +460,7 @@ var JetstreamClient = class extends ClientProxy {
    */
   async connect() {
     const nc = await this.connection.getConnection();
-    if (isJetStreamRpcMode(this.rootOptions.rpc) && !this.inboxSubscription) {
+    if (!this.isCoreMode && !this.inboxSubscription) {
       this.setupInbox(nc);
     }
     this.statusSubscription ??= this.connection.status$.subscribe((status) => {
@@ -440,12 +468,14 @@ var JetstreamClient = class extends ClientProxy {
         this.handleDisconnect();
       }
     });
+    this.readyForPublish = true;
     return nc;
   }
   /** Clean up resources: reject pending RPCs, unsubscribe from status events. */
   async close() {
     this.statusSubscription?.unsubscribe();
     this.statusSubscription = null;
+    this.readyForPublish = false;
     this.rejectPendingRpcs(new Error("Client closed"));
   }
   /**
@@ -469,7 +499,7 @@ var JetstreamClient = class extends ClientProxy {
    * set to the original event subject.
    */
   async dispatchEvent(packet) {
-    await this.connect();
+    if (!this.readyForPublish) await this.connect();
     const { data, hdrs, messageId, schedule, ttl } = this.extractRecordData(packet.data);
     const eventSubject = this.buildEventSubject(packet.pattern);
     const msgHeaders = this.buildHeaders(hdrs, { subject: eventSubject });
@@ -508,7 +538,7 @@ var JetstreamClient = class extends ClientProxy {
    * JetStream mode: publishes to stream + waits for inbox response.
    */
   publish(packet, callback) {
-    const subject = buildSubject(this.targetName, "cmd" /* Command */, packet.pattern);
+    const subject = this.commandSubjectPrefix + packet.pattern;
     const { data, hdrs, timeout, messageId, schedule, ttl } = this.extractRecordData(packet.data);
     if (schedule) {
       this.logger.warn(
@@ -525,7 +555,7 @@ var JetstreamClient = class extends ClientProxy {
       callback({ err: new Error("Internal transport error"), response: null, isDisposed: true });
     };
     let jetStreamCorrelationId = null;
-    if (isCoreRpcMode(this.rootOptions.rpc)) {
+    if (this.isCoreMode) {
       this.publishCoreRpc(subject, data, hdrs, timeout, callback).catch(onUnhandled);
     } else {
       jetStreamCorrelationId = nuid.next();
@@ -550,8 +580,8 @@ var JetstreamClient = class extends ClientProxy {
   /** Core mode: nc.request() with timeout. */
   async publishCoreRpc(subject, data, customHeaders, timeout, callback) {
     try {
-      const nc = await this.connect();
-      const effectiveTimeout = timeout ?? this.getRpcTimeout();
+      const nc = this.readyForPublish ? this.connection.unwrap : await this.connect();
+      const effectiveTimeout = timeout ?? this.defaultRpcTimeout;
       const hdrs = this.buildHeaders(customHeaders, { subject });
       const response = await nc.request(subject, this.codec.encode(data), {
         timeout: effectiveTimeout,
@@ -573,10 +603,10 @@ var JetstreamClient = class extends ClientProxy {
   /** JetStream mode: publish to stream + wait for inbox response. */
   async publishJetStreamRpc(subject, data, callback, options) {
     const { headers: customHeaders, correlationId, messageId } = options;
-    const effectiveTimeout = options.timeout ?? this.getRpcTimeout();
+    const effectiveTimeout = options.timeout ?? this.defaultRpcTimeout;
     this.pendingMessages.set(correlationId, callback);
     try {
-      await this.connect();
+      if (!this.readyForPublish) await this.connect();
       if (!this.pendingMessages.has(correlationId)) return;
       if (!this.inbox) {
         this.pendingMessages.delete(correlationId);
@@ -622,6 +652,7 @@ var JetstreamClient = class extends ClientProxy {
   handleDisconnect() {
     this.rejectPendingRpcs(new Error("Connection lost"));
     this.inbox = null;
+    this.readyForPublish = false;
   }
   /** Reject all pending RPC callbacks, clear timeouts, and tear down inbox. */
   rejectPendingRpcs(error) {
@@ -685,19 +716,22 @@ var JetstreamClient = class extends ClientProxy {
       this.pendingMessages.delete(correlationId);
     }
   }
-  /** Build event subject — workqueue, broadcast, or ordered. */
+  /**
+   * Resolve a user pattern to a fully-qualified NATS subject, dispatching
+   * between the event, broadcast, and ordered prefixes.
+   *
+   * The leading-char check short-circuits the `startsWith` comparisons for
+   * patterns that cannot possibly carry a broadcast/ordered marker, which is
+   * the overwhelmingly common case.
+   */
   buildEventSubject(pattern) {
-    if (pattern.startsWith("broadcast:" /* Broadcast */)) {
-      return buildBroadcastSubject(pattern.slice("broadcast:" /* Broadcast */.length));
-    }
-    if (pattern.startsWith("ordered:" /* Ordered */)) {
-      return buildSubject(
-        this.targetName,
-        "ordered" /* Ordered */,
-        pattern.slice("ordered:" /* Ordered */.length)
-      );
+    if (pattern.charCodeAt(0) === 98 && pattern.startsWith("broadcast:" /* Broadcast */)) {
+      return BROADCAST_SUBJECT_PREFIX + pattern.slice("broadcast:" /* Broadcast */.length);
     }
-    return buildSubject(this.targetName, "ev" /* Event */, pattern);
+    if (pattern.charCodeAt(0) === 111 && pattern.startsWith("ordered:" /* Ordered */)) {
+      return this.orderedSubjectPrefix + pattern.slice("ordered:" /* Ordered */.length);
+    }
+    return this.eventSubjectPrefix + pattern;
   }
   /** Build NATS headers merging custom headers with transport headers. */
   buildHeaders(customHeaders, transport) {
@@ -722,7 +756,7 @@ var JetstreamClient = class extends ClientProxy {
     if (rawData instanceof JetstreamRecord) {
       return {
         data: rawData.data,
-        hdrs: rawData.headers.size > 0 ? new Map(rawData.headers) : null,
+        hdrs: rawData.headers.size > 0 ? rawData.headers : null,
         timeout: rawData.timeout,
         messageId: rawData.messageId,
         schedule: rawData.schedule,
@@ -765,11 +799,6 @@ var JetstreamClient = class extends ClientProxy {
     const pattern = withoutPrefix.slice(dotIndex + 1);
     return `${targetPrefix}_sch.${pattern}`;
   }
-  getRpcTimeout() {
-    if (!this.rootOptions.rpc) return DEFAULT_RPC_TIMEOUT;
-    const defaultTimeout = isJetStreamRpcMode(this.rootOptions.rpc) ? DEFAULT_JETSTREAM_RPC_TIMEOUT : DEFAULT_RPC_TIMEOUT;
-    return this.rootOptions.rpc.timeout ?? defaultTimeout;
-  }
 };
 
 // src/codec/json.codec.ts
@@ -784,6 +813,19 @@ var JsonCodec = class {
   }
 };
 
+// src/codec/msgpack.codec.ts
+var MsgpackCodec = class {
+  constructor(packr) {
+    this.packr = packr;
+  }
+  encode(data) {
+    return this.packr.pack(data);
+  }
+  decode(data) {
+    return this.packr.unpack(data);
+  }
+};
+
 // src/connection/connection.provider.ts
 import { Logger as Logger2 } from "@nestjs/common";
 import {
@@ -1001,6 +1043,15 @@ var EventBus = class {
       kind
     );
   }
+  /**
+   * Check whether a hook is registered for the given event.
+   *
+   * Used by the routing hot path to elide the emit call entirely when the
+   * transport owner did not register a listener.
+   */
+  hasHook(event) {
+    return this.hooks[event] !== void 0;
+  }
   callHook(event, hook, ...args) {
     try {
       const result = hook(...args);
@@ -1383,16 +1434,71 @@ var resolveAckExtensionInterval = (config, ackWaitNanos) => {
   const interval = Math.floor(ackWaitNanos / 1e6 / 2);
   return Math.max(interval, MIN_ACK_EXTENSION_INTERVAL);
 };
+var AckExtensionPool = class {
+  entries = /* @__PURE__ */ new Set();
+  handle = null;
+  handleFireAt = 0;
+  schedule(msg, interval) {
+    const entry = {
+      msg,
+      interval,
+      nextFireAt: Date.now() + interval,
+      active: true
+    };
+    this.entries.add(entry);
+    this.ensureWake(entry.nextFireAt);
+    return entry;
+  }
+  cancel(entry) {
+    if (!entry.active) return;
+    entry.active = false;
+    this.entries.delete(entry);
+    if (this.entries.size === 0 && this.handle !== null) {
+      clearTimeout(this.handle);
+      this.handle = null;
+      this.handleFireAt = 0;
+    }
+  }
+  /**
+   * Ensure the shared timer will fire no later than `dueAt`. If an earlier
+   * wake is already scheduled, leave it; otherwise replace it with a tighter one.
+   */
+  ensureWake(dueAt) {
+    if (this.handle !== null && this.handleFireAt <= dueAt) return;
+    if (this.handle !== null) clearTimeout(this.handle);
+    const delay = Math.max(0, dueAt - Date.now());
+    const handle = setTimeout(() => {
+      this.tick();
+    }, delay);
+    if (typeof handle.unref === "function") handle.unref();
+    this.handle = handle;
+    this.handleFireAt = dueAt;
+  }
+  tick() {
+    this.handle = null;
+    this.handleFireAt = 0;
+    const now = Date.now();
+    let earliest = Infinity;
+    for (const entry of this.entries) {
+      if (!entry.active) continue;
+      if (entry.nextFireAt <= now) {
+        try {
+          entry.msg.working();
+        } catch {
+        }
+        entry.nextFireAt = now + entry.interval;
+      }
+      if (entry.nextFireAt < earliest) earliest = entry.nextFireAt;
+    }
+    if (earliest !== Infinity) this.ensureWake(earliest);
+  }
+};
+var pool = new AckExtensionPool();
 var startAckExtensionTimer = (msg, interval) => {
   if (interval === null || interval <= 0) return null;
-  const timer2 = setInterval(() => {
-    try {
-      msg.working();
-    } catch {
-    }
-  }, interval);
+  const entry = pool.schedule(msg, interval);
   return () => {
-    clearInterval(timer2);
+    pool.cancel(entry);
   };
 };
 
@@ -1406,11 +1512,8 @@ var serializeError = (err) => {
 
 // src/utils/unwrap-result.ts
 import { isObservable } from "rxjs";
-var RESOLVED_VOID = Promise.resolve(void 0);
-var RESOLVED_NULL = Promise.resolve(null);
 var unwrapResult = (result) => {
-  if (result === void 0) return RESOLVED_VOID;
-  if (result === null) return RESOLVED_NULL;
+  if (result === void 0 || result === null) return result;
   if (isObservable(result)) {
     return subscribeToFirst(result);
   }
@@ -1419,8 +1522,9 @@ var unwrapResult = (result) => {
       (resolved) => isObservable(resolved) ? subscribeToFirst(resolved) : resolved
     );
   }
-  return Promise.resolve(result);
+  return result;
 };
+var isPromiseLike = (value) => value !== null && typeof value === "object" && typeof value.then === "function";
 var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
   let done = false;
   let subscription = null;
@@ -1508,7 +1612,8 @@ var CoreRpcServer = class {
     }
     const ctx = new RpcContext([msg]);
     try {
-      const result = await unwrapResult(handler(data, ctx));
+      const raw = unwrapResult(handler(data, ctx));
+      const result = isPromiseLike(raw) ? await raw : raw;
       msg.respond(this.codec.encode(result));
     } catch (err) {
       this.logger.error(`Handler error for Core RPC ${msg.subject}:`, err);
@@ -1531,6 +1636,14 @@ var CoreRpcServer = class {
 import { Logger as Logger6 } from "@nestjs/common";
 import { JetStreamApiError as JetStreamApiError2 } from "@nats-io/jetstream";
 
+// src/server/infrastructure/nats-error-codes.ts
+var NatsErrorCode = /* @__PURE__ */ ((NatsErrorCode2) => {
+  NatsErrorCode2[NatsErrorCode2["ConsumerNotFound"] = 10014] = "ConsumerNotFound";
+  NatsErrorCode2[NatsErrorCode2["ConsumerAlreadyExists"] = 10148] = "ConsumerAlreadyExists";
+  NatsErrorCode2[NatsErrorCode2["StreamNotFound"] = 10059] = "StreamNotFound";
+  return NatsErrorCode2;
+})(NatsErrorCode || {});
+
 // src/server/infrastructure/stream-config-diff.ts
 var TRANSPORT_CONTROLLED_PROPERTIES = /* @__PURE__ */ new Set([
   "retention"
@@ -2229,13 +2342,17 @@ var MessageProvider = class {
     }
     const defaults = { idle_heartbeat: 5e3 };
     const userOptions = this.consumeOptionsMap.get(kind) ?? {};
-    const messages = await consumer.consume({ ...defaults, ...userOptions });
+    const messages = await consumer.consume({
+      ...defaults,
+      ...userOptions,
+      callback: (msg) => {
+        target$.next(msg);
+      }
+    });
     this.activeIterators.add(messages);
     this.monitorConsumerHealth(messages, consumerName2);
     try {
-      for await (const msg of messages) {
-        target$.next(msg);
-      }
+      await messages.closed();
     } finally {
       this.activeIterators.delete(messages);
     }
@@ -2327,11 +2444,16 @@ var MessageProvider = class {
       })
     );
   }
-  /** Single iteration: create ordered consumer -> iterate messages. */
+  /** Single iteration: create ordered consumer -> push messages into the subject. */
   async consumeOrderedOnce(streamName2, consumerOpts) {
     const js = this.connection.getJetStreamClient();
     const consumer = await js.consumers.get(streamName2, consumerOpts);
-    const messages = await consumer.consume();
+    const orderedMessages$ = this.orderedMessages$;
+    const messages = await consumer.consume({
+      callback: (msg) => {
+        orderedMessages$.next(msg);
+      }
+    });
     if (this.orderedReadyResolve) {
       this.orderedReadyResolve();
       this.orderedReadyResolve = null;
@@ -2339,9 +2461,7 @@ var MessageProvider = class {
     }
     this.activeIterators.add(messages);
     try {
-      for await (const msg of messages) {
-        this.orderedMessages$.next(msg);
-      }
+      await messages.closed();
     } finally {
       this.activeIterators.delete(messages);
     }
@@ -2620,7 +2740,6 @@ var PatternRegistry = class {
 
 // src/server/routing/event.router.ts
 import { Logger as Logger11 } from "@nestjs/common";
-import { concatMap, from as from2, mergeMap } from "rxjs";
 import { headers as natsHeaders3 } from "@nats-io/transport-node";
 var EventRouter = class {
   constructor(messageProvider, patternRegistry, codec, eventBus, deadLetterConfig, processingConfig, ackWaitMap, connection, options) {
@@ -2659,15 +2778,194 @@ var EventRouter = class {
     }
     this.subscriptions.length = 0;
   }
-  /** Subscribe to a message stream and route each message. */
+  /** Subscribe to a message stream and route each message to its handler. */
   subscribeToStream(stream$, kind) {
     const isOrdered = kind === "ordered" /* Ordered */;
+    const patternRegistry = this.patternRegistry;
+    const codec = this.codec;
+    const eventBus = this.eventBus;
+    const logger = this.logger;
+    const deadLetterConfig = this.deadLetterConfig;
     const ackExtensionInterval = isOrdered ? null : resolveAckExtensionInterval(this.getAckExtensionConfig(kind), this.ackWaitMap?.get(kind));
+    const hasAckExtension = ackExtensionInterval !== null && ackExtensionInterval > 0;
     const concurrency = this.getConcurrency(kind);
-    const route = (msg) => from2(
-      isOrdered ? this.handleOrderedSafe(msg) : this.handleSafe(msg, ackExtensionInterval, kind)
-    );
-    const subscription = stream$.pipe(isOrdered ? concatMap(route) : mergeMap(route, concurrency)).subscribe();
+    const hasDlqCheck = deadLetterConfig !== void 0;
+    const emitRouted = eventBus.hasHook("messageRouted" /* MessageRouted */);
+    const isDeadLetter = (msg) => {
+      if (!hasDlqCheck) return false;
+      const maxDeliver = deadLetterConfig.maxDeliverByStream?.get(msg.info.stream);
+      if (maxDeliver === void 0 || maxDeliver <= 0) return false;
+      return msg.info.deliveryCount >= maxDeliver;
+    };
+    const handleDeadLetter = hasDlqCheck ? (msg, data, err) => this.handleDeadLetter(msg, data, err) : null;
+    const settleSuccess = (msg, ctx) => {
+      if (ctx.shouldTerminate) msg.term(ctx.terminateReason);
+      else if (ctx.shouldRetry) msg.nak(ctx.retryDelay);
+      else msg.ack();
+    };
+    const settleFailure = async (msg, data, err) => {
+      if (handleDeadLetter !== null && isDeadLetter(msg)) {
+        await handleDeadLetter(msg, data, err);
+        return;
+      }
+      msg.nak();
+    };
+    const resolveEvent = (msg) => {
+      const subject = msg.subject;
+      try {
+        const handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          msg.term(`No handler for event: ${subject}`);
+          logger.error(`No handler for subject: ${subject}`);
+          return null;
+        }
+        let data;
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          msg.term("Decode error");
+          logger.error(`Decode error for ${subject}:`, err);
+          return null;
+        }
+        if (emitRouted) eventBus.emitMessageRouted(subject, "event" /* Event */);
+        return { handler, data };
+      } catch (err) {
+        logger.error(`Unexpected error in ${kind} event router`, err);
+        try {
+          msg.term("Unexpected router error");
+        } catch (termErr) {
+          logger.error(`Failed to terminate message ${subject}:`, termErr);
+        }
+        return null;
+      }
+    };
+    const handleSafe = (msg) => {
+      const resolved = resolveEvent(msg);
+      if (resolved === null) return void 0;
+      const { handler, data } = resolved;
+      const ctx = new RpcContext([msg]);
+      const stopAckExtension = hasAckExtension ? startAckExtensionTimer(msg, ackExtensionInterval) : null;
+      let pending;
+      try {
+        pending = unwrapResult(handler(data, ctx));
+      } catch (err) {
+        logger.error(`Event handler error (${msg.subject}) in ${kind} router:`, err);
+        if (stopAckExtension !== null) stopAckExtension();
+        return settleFailure(msg, data, err);
+      }
+      if (!isPromiseLike(pending)) {
+        settleSuccess(msg, ctx);
+        if (stopAckExtension !== null) stopAckExtension();
+        return void 0;
+      }
+      return pending.then(
+        () => {
+          settleSuccess(msg, ctx);
+          if (stopAckExtension !== null) stopAckExtension();
+        },
+        async (err) => {
+          logger.error(`Event handler error (${msg.subject}) in ${kind} router:`, err);
+          try {
+            await settleFailure(msg, data, err);
+          } finally {
+            if (stopAckExtension !== null) stopAckExtension();
+          }
+        }
+      );
+    };
+    const handleOrderedSafe = (msg) => {
+      const subject = msg.subject;
+      let handler;
+      let data;
+      try {
+        handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          logger.error(`No handler for subject: ${subject}`);
+          return void 0;
+        }
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          logger.error(`Decode error for ${subject}:`, err);
+          return void 0;
+        }
+        if (emitRouted) eventBus.emitMessageRouted(subject, "event" /* Event */);
+      } catch (err) {
+        logger.error(`Ordered handler error (${subject}):`, err);
+        return void 0;
+      }
+      const ctx = new RpcContext([msg]);
+      const warnIfSettlementAttempted = () => {
+        if (ctx.shouldRetry || ctx.shouldTerminate) {
+          logger.warn(
+            `retry()/terminate() ignored for ordered message ${subject} \u2014 ordered consumers auto-acknowledge`
+          );
+        }
+      };
+      let pending;
+      try {
+        pending = unwrapResult(handler(data, ctx));
+      } catch (err) {
+        logger.error(`Ordered handler error (${subject}):`, err);
+        return void 0;
+      }
+      if (!isPromiseLike(pending)) {
+        warnIfSettlementAttempted();
+        return void 0;
+      }
+      return pending.then(warnIfSettlementAttempted, (err) => {
+        logger.error(`Ordered handler error (${subject}):`, err);
+      });
+    };
+    const route = isOrdered ? handleOrderedSafe : handleSafe;
+    const maxActive = isOrdered ? 1 : concurrency ?? Number.POSITIVE_INFINITY;
+    const backlogWarnThreshold = 1e3;
+    let active = 0;
+    let backlogWarned = false;
+    const backlog = [];
+    const onAsyncDone = () => {
+      active--;
+      drainBacklog();
+    };
+    const drainBacklog = () => {
+      while (active < maxActive) {
+        const next = backlog.shift();
+        if (next === void 0) return;
+        active++;
+        const result = route(next);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+        }
+      }
+      if (backlog.length < backlogWarnThreshold) backlogWarned = false;
+    };
+    const subscription = stream$.subscribe({
+      next: (msg) => {
+        if (active >= maxActive) {
+          backlog.push(msg);
+          if (!backlogWarned && backlog.length >= backlogWarnThreshold) {
+            backlogWarned = true;
+            logger.warn(
+              `${kind} backlog reached ${backlog.length} messages \u2014 consumer may be falling behind`
+            );
+          }
+          return;
+        }
+        active++;
+        const result = route(msg);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+          if (backlog.length > 0) drainBacklog();
+        }
+      },
+      error: (err) => {
+        logger.error(`Stream error in ${kind} router`, err);
+      }
+    });
     this.subscriptions.push(subscription);
   }
   getConcurrency(kind) {
@@ -2680,86 +2978,6 @@ var EventRouter = class {
     if (kind === "broadcast" /* Broadcast */) return this.processingConfig?.broadcast?.ackExtension;
     return void 0;
   }
-  /** Handle a single event message with error isolation. */
-  async handleSafe(msg, ackExtensionInterval, kind) {
-    try {
-      const resolved = this.decodeMessage(msg);
-      if (!resolved) return;
-      await this.executeHandler(
-        resolved.handler,
-        resolved.data,
-        resolved.ctx,
-        msg,
-        ackExtensionInterval
-      );
-    } catch (err) {
-      this.logger.error(`Unexpected error in ${kind} event router`, err);
-    }
-  }
-  /** Handle an ordered message with error isolation. */
-  async handleOrderedSafe(msg) {
-    try {
-      const resolved = this.decodeMessage(msg, true);
-      if (!resolved) return;
-      await unwrapResult(resolved.handler(resolved.data, resolved.ctx));
-      if (resolved.ctx.shouldRetry || resolved.ctx.shouldTerminate) {
-        this.logger.warn(
-          `retry()/terminate() ignored for ordered message ${msg.subject} \u2014 ordered consumers auto-acknowledge`
-        );
-      }
-    } catch (err) {
-      this.logger.error(`Ordered handler error (${msg.subject}):`, err);
-    }
-  }
-  /** Resolve handler, decode payload, and build context. Returns null on failure. */
-  decodeMessage(msg, isOrdered = false) {
-    const handler = this.patternRegistry.getHandler(msg.subject);
-    if (!handler) {
-      if (!isOrdered) msg.term(`No handler for event: ${msg.subject}`);
-      this.logger.error(`No handler for subject: ${msg.subject}`);
-      return null;
-    }
-    let data;
-    try {
-      data = this.codec.decode(msg.data);
-    } catch (err) {
-      if (!isOrdered) msg.term("Decode error");
-      this.logger.error(`Decode error for ${msg.subject}:`, err);
-      return null;
-    }
-    this.eventBus.emitMessageRouted(msg.subject, "event" /* Event */);
-    return { handler, data, ctx: new RpcContext([msg]) };
-  }
-  /** Execute handler, then ack on success or nak/dead-letter on failure. */
-  async executeHandler(handler, data, ctx, msg, ackExtensionInterval) {
-    const stopAckExtension = startAckExtensionTimer(msg, ackExtensionInterval);
-    try {
-      await unwrapResult(handler(data, ctx));
-      if (ctx.shouldTerminate) {
-        msg.term(ctx.terminateReason);
-      } else if (ctx.shouldRetry) {
-        msg.nak(ctx.retryDelay);
-      } else {
-        msg.ack();
-      }
-    } catch (err) {
-      this.logger.error(`Event handler error (${msg.subject}):`, err);
-      if (this.isDeadLetter(msg)) {
-        await this.handleDeadLetter(msg, data, err);
-      } else {
-        msg.nak();
-      }
-    } finally {
-      stopAckExtension?.();
-    }
-  }
-  /** Check if the message has exhausted all delivery attempts. */
-  isDeadLetter(msg) {
-    if (!this.deadLetterConfig) return false;
-    const maxDeliver = this.deadLetterConfig.maxDeliverByStream.get(msg.info.stream);
-    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. */
   /**
    * Fallback execution for a dead letter when DLQ is disabled, or when
@@ -2871,7 +3089,6 @@ var EventRouter = class {
 // src/server/routing/rpc.router.ts
 import { Logger as Logger12 } from "@nestjs/common";
 import { headers } from "@nats-io/transport-node";
-import { from as from3, mergeMap as mergeMap2 } from "rxjs";
 var RpcRouter = class {
   constructor(messageProvider, patternRegistry, connection, codec, eventBus, rpcOptions, ackWaitMap) {
     this.messageProvider = messageProvider;
@@ -2902,87 +3119,178 @@ var RpcRouter = class {
   /** Start routing command messages to handlers. */
   async start() {
     this.cachedNc = await this.connection.getConnection();
-    this.subscription = this.messageProvider.commands$.pipe(mergeMap2((msg) => from3(this.handleSafe(msg)), this.concurrency)).subscribe();
-  }
-  /** Stop routing and unsubscribe. */
-  destroy() {
-    this.subscription?.unsubscribe();
-    this.subscription = null;
-  }
-  /** Handle a single RPC command message with error isolation. */
-  async handleSafe(msg) {
-    try {
-      const handler = this.patternRegistry.getHandler(msg.subject);
-      if (!handler) {
-        msg.term(`No handler for RPC: ${msg.subject}`);
-        this.logger.error(`No handler for RPC subject: ${msg.subject}`);
-        return;
-      }
-      const { headers: msgHeaders } = msg;
-      const replyTo = msgHeaders?.get("x-reply-to" /* ReplyTo */);
-      const correlationId = msgHeaders?.get("x-correlation-id" /* CorrelationId */);
-      if (!replyTo || !correlationId) {
-        msg.term("Missing required headers (reply-to or correlation-id)");
-        this.logger.error(`Missing headers for RPC: ${msg.subject}`);
-        return;
-      }
-      let data;
-      try {
-        data = this.codec.decode(msg.data);
-      } catch (err) {
-        msg.term("Decode error");
-        this.logger.error(`Decode error for RPC ${msg.subject}:`, err);
-        return;
-      }
-      this.eventBus.emitMessageRouted(msg.subject, "rpc" /* Rpc */);
-      await this.executeHandler(handler, data, msg, replyTo, correlationId);
-    } catch (err) {
-      this.logger.error("Unexpected error in RPC router", err);
-    }
-  }
-  /** Execute handler, publish response, settle message. */
-  async executeHandler(handler, data, msg, replyTo, correlationId) {
-    const nc = this.cachedNc ?? await this.connection.getConnection();
-    const ctx = new RpcContext([msg]);
-    let settled = false;
-    const stopAckExtension = startAckExtensionTimer(msg, this.ackExtensionInterval);
-    const timeoutId = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      stopAckExtension?.();
-      this.logger.error(`RPC timeout (${this.timeout}ms): ${msg.subject}`);
-      this.eventBus.emit("rpcTimeout" /* RpcTimeout */, msg.subject, correlationId);
-      msg.term("Handler timeout");
-    }, this.timeout);
-    try {
-      const result = await unwrapResult(handler(data, ctx));
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeoutId);
-      stopAckExtension?.();
-      msg.ack();
+    const nc = this.cachedNc;
+    const patternRegistry = this.patternRegistry;
+    const codec = this.codec;
+    const eventBus = this.eventBus;
+    const logger = this.logger;
+    const timeout = this.timeout;
+    const ackExtensionInterval = this.ackExtensionInterval;
+    const hasAckExtension = ackExtensionInterval !== null && ackExtensionInterval > 0;
+    const maxActive = this.concurrency ?? Number.POSITIVE_INFINITY;
+    const emitRpcTimeout = (subject, correlationId) => {
+      eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
+    };
+    const publishReply = (replyTo, correlationId, payload) => {
       try {
         const hdrs = headers();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
-        nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
+        nc.publish(replyTo, codec.encode(payload), { headers: hdrs });
       } catch (publishErr) {
-        this.logger.error(`Failed to publish RPC response for ${msg.subject}`, publishErr);
+        logger.error(`Failed to publish RPC response`, publishErr);
       }
-    } catch (err) {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeoutId);
-      stopAckExtension?.();
+    };
+    const publishErrorReply = (replyTo, correlationId, subject, err) => {
       try {
         const hdrs = headers();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
         hdrs.set("x-error" /* Error */, "true");
-        nc.publish(replyTo, this.codec.encode(serializeError(err)), { headers: hdrs });
+        nc.publish(replyTo, codec.encode(serializeError(err)), { headers: hdrs });
       } catch (encodeErr) {
-        this.logger.error(`Failed to encode RPC error for ${msg.subject}`, encodeErr);
+        logger.error(`Failed to encode RPC error for ${subject}`, encodeErr);
       }
-      msg.term(`Handler error: ${msg.subject}`);
-    }
+    };
+    const resolveCommand = (msg) => {
+      const subject = msg.subject;
+      try {
+        const handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          msg.term(`No handler for RPC: ${subject}`);
+          logger.error(`No handler for RPC subject: ${subject}`);
+          return null;
+        }
+        const msgHeaders = msg.headers;
+        const replyTo = msgHeaders?.get("x-reply-to" /* ReplyTo */);
+        const correlationId = msgHeaders?.get("x-correlation-id" /* CorrelationId */);
+        if (!replyTo || !correlationId) {
+          msg.term("Missing required headers (reply-to or correlation-id)");
+          logger.error(`Missing headers for RPC: ${subject}`);
+          return null;
+        }
+        let data;
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          msg.term("Decode error");
+          logger.error(`Decode error for RPC ${subject}:`, err);
+          return null;
+        }
+        eventBus.emitMessageRouted(subject, "rpc" /* Rpc */);
+        return { handler, data, replyTo, correlationId };
+      } catch (err) {
+        logger.error("Unexpected error in RPC router", err);
+        try {
+          msg.term("Unexpected router error");
+        } catch (termErr) {
+          logger.error(`Failed to terminate RPC message ${subject}:`, termErr);
+        }
+        return null;
+      }
+    };
+    const handleSafe = (msg) => {
+      const resolved = resolveCommand(msg);
+      if (resolved === null) return void 0;
+      const { handler, data, replyTo, correlationId } = resolved;
+      const subject = msg.subject;
+      const ctx = new RpcContext([msg]);
+      const stopAckExtension = hasAckExtension ? startAckExtensionTimer(msg, ackExtensionInterval) : null;
+      let pending;
+      try {
+        pending = unwrapResult(handler(data, ctx));
+      } catch (err) {
+        if (stopAckExtension !== null) stopAckExtension();
+        logger.error(`RPC handler error (${subject}):`, err);
+        publishErrorReply(replyTo, correlationId, subject, err);
+        msg.term(`Handler error: ${subject}`);
+        return void 0;
+      }
+      if (!isPromiseLike(pending)) {
+        if (stopAckExtension !== null) stopAckExtension();
+        msg.ack();
+        publishReply(replyTo, correlationId, pending);
+        return void 0;
+      }
+      let settled = false;
+      const timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        if (stopAckExtension !== null) stopAckExtension();
+        logger.error(`RPC timeout (${timeout}ms): ${subject}`);
+        emitRpcTimeout(subject, correlationId);
+        msg.term("Handler timeout");
+      }, timeout);
+      return pending.then(
+        (result) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeoutId);
+          if (stopAckExtension !== null) stopAckExtension();
+          msg.ack();
+          publishReply(replyTo, correlationId, result);
+        },
+        (err) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeoutId);
+          if (stopAckExtension !== null) stopAckExtension();
+          logger.error(`RPC handler error (${subject}):`, err);
+          publishErrorReply(replyTo, correlationId, subject, err);
+          msg.term(`Handler error: ${subject}`);
+        }
+      );
+    };
+    const backlogWarnThreshold = 1e3;
+    let active = 0;
+    let backlogWarned = false;
+    const backlog = [];
+    const onAsyncDone = () => {
+      active--;
+      drainBacklog();
+    };
+    const drainBacklog = () => {
+      while (active < maxActive) {
+        const next = backlog.shift();
+        if (next === void 0) return;
+        active++;
+        const result = handleSafe(next);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+        }
+      }
+      if (backlog.length < backlogWarnThreshold) backlogWarned = false;
+    };
+    this.subscription = this.messageProvider.commands$.subscribe({
+      next: (msg) => {
+        if (active >= maxActive) {
+          backlog.push(msg);
+          if (!backlogWarned && backlog.length >= backlogWarnThreshold) {
+            backlogWarned = true;
+            logger.warn(
+              `RPC backlog reached ${backlog.length} messages \u2014 consumer may be falling behind`
+            );
+          }
+          return;
+        }
+        active++;
+        const result = handleSafe(msg);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+          if (backlog.length > 0) drainBacklog();
+        }
+      },
+      error: (err) => {
+        logger.error("Stream error in RPC router", err);
+      }
+    });
+  }
+  /** Stop routing and unsubscribe. */
+  destroy() {
+    this.subscription?.unsubscribe();
+    this.subscription = null;
   }
 };
 
@@ -3430,14 +3738,23 @@ JetstreamModule = __decorateClass([
   __decorateParam(1, Inject(JetstreamStrategy))
 ], JetstreamModule);
 export {
+  DEFAULT_BROADCAST_CONSUMER_CONFIG,
+  DEFAULT_BROADCAST_STREAM_CONFIG,
+  DEFAULT_COMMAND_CONSUMER_CONFIG,
+  DEFAULT_COMMAND_STREAM_CONFIG,
+  DEFAULT_DLQ_STREAM_CONFIG,
+  DEFAULT_EVENT_CONSUMER_CONFIG,
+  DEFAULT_EVENT_STREAM_CONFIG,
+  DEFAULT_JETSTREAM_RPC_TIMEOUT,
   DEFAULT_METADATA_BUCKET,
   DEFAULT_METADATA_HISTORY,
   DEFAULT_METADATA_REPLICAS,
   DEFAULT_METADATA_TTL,
-  EventBus,
+  DEFAULT_ORDERED_STREAM_CONFIG,
+  DEFAULT_RPC_TIMEOUT,
+  DEFAULT_SHUTDOWN_TIMEOUT,
   JETSTREAM_CODEC,
   JETSTREAM_CONNECTION,
-  JETSTREAM_EVENT_BUS,
   JETSTREAM_OPTIONS,
   JetstreamClient,
   JetstreamDlqHeader,
@@ -3450,7 +3767,10 @@ export {
   JsonCodec,
   MIN_METADATA_TTL,
   MessageKind,
+  MsgpackCodec,
+  NatsErrorCode,
   PatternPrefix,
+  RESERVED_HEADERS,
   RpcContext,
   StreamKind,
   TransportEvent,