@horizon-republic/nestjs-jetstream 2.5.1 → 2.7.0

package/dist/index.js

@@ -29,6 +29,11 @@ import {
 } from "nats";
 
 // src/interfaces/hooks.interface.ts
+var MessageKind = /* @__PURE__ */ ((MessageKind2) => {
+  MessageKind2["Event"] = "event";
+  MessageKind2["Rpc"] = "rpc";
+  return MessageKind2;
+})(MessageKind || {});
 var TransportEvent = /* @__PURE__ */ ((TransportEvent2) => {
   TransportEvent2["Connect"] = "connect";
   TransportEvent2["Disconnect"] = "disconnect";
@@ -42,6 +47,15 @@ var TransportEvent = /* @__PURE__ */ ((TransportEvent2) => {
   return TransportEvent2;
 })(TransportEvent || {});
 
+// src/interfaces/stream.interface.ts
+var StreamKind = /* @__PURE__ */ ((StreamKind2) => {
+  StreamKind2["Event"] = "ev";
+  StreamKind2["Command"] = "cmd";
+  StreamKind2["Broadcast"] = "broadcast";
+  StreamKind2["Ordered"] = "ordered";
+  return StreamKind2;
+})(StreamKind || {});
+
 // src/jetstream.constants.ts
 import {
   AckPolicy,
@@ -74,7 +88,7 @@ var baseStreamConfig = {
   num_replicas: 1,
   discard: DiscardPolicy.Old,
   allow_direct: true,
-  compression: StoreCompression.None
+  compression: StoreCompression.S2
 };
 var DEFAULT_EVENT_STREAM_CONFIG = {
   ...baseStreamConfig,
@@ -166,13 +180,20 @@ var internalName = (name) => `${name}__microservice`;
 var buildSubject = (serviceName, kind, pattern) => `${internalName(serviceName)}.${kind}.${pattern}`;
 var buildBroadcastSubject = (pattern) => `broadcast.${pattern}`;
 var streamName = (serviceName, kind) => {
-  if (kind === "broadcast") return "broadcast-stream";
+  if (kind === "broadcast" /* Broadcast */) return "broadcast-stream";
   return `${internalName(serviceName)}_${kind}-stream`;
 };
 var consumerName = (serviceName, kind) => {
-  if (kind === "broadcast") return `${internalName(serviceName)}_broadcast-consumer`;
+  if (kind === "broadcast" /* Broadcast */) return `${internalName(serviceName)}_broadcast-consumer`;
   return `${internalName(serviceName)}_${kind}-consumer`;
 };
+var PatternPrefix = /* @__PURE__ */ ((PatternPrefix2) => {
+  PatternPrefix2["Broadcast"] = "broadcast:";
+  PatternPrefix2["Ordered"] = "ordered:";
+  return PatternPrefix2;
+})(PatternPrefix || {});
+var isJetStreamRpcMode = (rpc) => rpc?.mode === "jetstream";
+var isCoreRpcMode = (rpc) => !rpc || rpc.mode === "core";
 
 // src/client/jetstream.record.ts
 var JetstreamRecord = class {
@@ -287,10 +308,13 @@ var JetstreamClient = class extends ClientProxy {
     this.codec = codec;
     this.eventBus = eventBus;
     this.targetName = targetServiceName;
+    this.callerName = internalName(this.rootOptions.name);
   }
   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;
   /** Shared inbox for JetStream-mode RPC responses. */
   inbox = null;
   inboxSubscription = null;
@@ -310,7 +334,7 @@ var JetstreamClient = class extends ClientProxy {
    */
   async connect() {
     const nc = await this.connection.getConnection();
-    if (this.isJetStreamRpcMode() && !this.inboxSubscription) {
+    if (isJetStreamRpcMode(this.rootOptions.rpc) && !this.inboxSubscription) {
       this.setupInbox(nc);
     }
     this.statusSubscription ??= this.connection.status$.subscribe((status) => {
@@ -345,11 +369,11 @@ var JetstreamClient = class extends ClientProxy {
    * depending on the subject prefix.
    */
   async dispatchEvent(packet) {
-    const nc = await this.connect();
+    await this.connect();
     const { data, hdrs, messageId } = this.extractRecordData(packet.data);
     const subject = this.buildEventSubject(packet.pattern);
     const msgHeaders = this.buildHeaders(hdrs, { subject });
-    const ack = await nc.jetstream().publish(subject, this.codec.encode(data), {
+    const ack = await this.connection.getJetStreamClient().publish(subject, this.codec.encode(data), {
       headers: msgHeaders,
       msgID: messageId ?? crypto.randomUUID()
     });
@@ -365,26 +389,23 @@ var JetstreamClient = class extends ClientProxy {
    * JetStream mode: publishes to stream + waits for inbox response.
    */
   publish(packet, callback) {
-    const subject = buildSubject(this.targetName, "cmd", packet.pattern);
+    const subject = buildSubject(this.targetName, "cmd" /* Command */, packet.pattern);
     const { data, hdrs, timeout, messageId } = this.extractRecordData(packet.data);
     const onUnhandled = (err) => {
       this.logger.error("Unhandled publish error:", err);
       callback({ err: new Error("Internal transport error"), response: null, isDisposed: true });
     };
     let jetStreamCorrelationId = null;
-    if (this.isCoreRpcMode()) {
+    if (isCoreRpcMode(this.rootOptions.rpc)) {
       this.publishCoreRpc(subject, data, hdrs, timeout, callback).catch(onUnhandled);
     } else {
       jetStreamCorrelationId = crypto.randomUUID();
-      this.publishJetStreamRpc(
-        subject,
-        data,
-        hdrs,
+      this.publishJetStreamRpc(subject, data, callback, {
+        headers: hdrs,
         timeout,
-        callback,
-        jetStreamCorrelationId,
+        correlationId: jetStreamCorrelationId,
         messageId
-      ).catch(onUnhandled);
+      }).catch(onUnhandled);
     }
     return () => {
       if (jetStreamCorrelationId) {
@@ -421,35 +442,46 @@ var JetstreamClient = class extends ClientProxy {
     }
   }
   /** JetStream mode: publish to stream + wait for inbox response. */
-  async publishJetStreamRpc(subject, data, customHeaders, timeout, callback, correlationId = crypto.randomUUID(), messageId) {
-    const effectiveTimeout = timeout ?? this.getRpcTimeout();
+  async publishJetStreamRpc(subject, data, callback, options) {
+    const { headers: customHeaders, correlationId, messageId } = options;
+    const effectiveTimeout = options.timeout ?? this.getRpcTimeout();
     this.pendingMessages.set(correlationId, callback);
-    const timeoutId = setTimeout(() => {
-      if (!this.pendingMessages.has(correlationId)) return;
-      this.pendingTimeouts.delete(correlationId);
-      this.pendingMessages.delete(correlationId);
-      this.logger.error(`JetStream RPC timeout (${effectiveTimeout}ms): ${subject}`);
-      this.eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
-      callback({ err: new Error("RPC timeout"), response: null, isDisposed: true });
-    }, effectiveTimeout);
-    this.pendingTimeouts.set(correlationId, timeoutId);
     try {
-      const nc = await this.connect();
+      await this.connect();
+      if (!this.pendingMessages.has(correlationId)) return;
       if (!this.inbox) {
-        throw new Error("Inbox not initialized \u2014 JetStream RPC mode requires a connected inbox");
+        this.pendingMessages.delete(correlationId);
+        callback({
+          err: new Error("Inbox not initialized \u2014 JetStream RPC mode requires a connected inbox"),
+          response: null,
+          isDisposed: true
+        });
+        return;
       }
+      const timeoutId = setTimeout(() => {
+        if (!this.pendingMessages.has(correlationId)) return;
+        this.pendingTimeouts.delete(correlationId);
+        this.pendingMessages.delete(correlationId);
+        this.logger.error(`JetStream RPC timeout (${effectiveTimeout}ms): ${subject}`);
+        this.eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
+        callback({ err: new Error("RPC timeout"), response: null, isDisposed: true });
+      }, effectiveTimeout);
+      this.pendingTimeouts.set(correlationId, timeoutId);
       const hdrs = this.buildHeaders(customHeaders, {
         subject,
         correlationId,
         replyTo: this.inbox
       });
-      await nc.jetstream().publish(subject, this.codec.encode(data), {
+      await this.connection.getJetStreamClient().publish(subject, this.codec.encode(data), {
         headers: hdrs,
         msgID: messageId ?? crypto.randomUUID()
       });
     } catch (err) {
-      clearTimeout(timeoutId);
-      this.pendingTimeouts.delete(correlationId);
+      const existingTimeout = this.pendingTimeouts.get(correlationId);
+      if (existingTimeout) {
+        clearTimeout(existingTimeout);
+        this.pendingTimeouts.delete(correlationId);
+      }
       if (!this.pendingMessages.has(correlationId)) return;
       this.pendingMessages.delete(correlationId);
       const error = err instanceof Error ? err : new Error("Unknown error");
@@ -525,19 +557,23 @@ var JetstreamClient = class extends ClientProxy {
   }
   /** Build event subject — workqueue, broadcast, or ordered. */
   buildEventSubject(pattern) {
-    if (pattern.startsWith("broadcast:")) {
-      return buildBroadcastSubject(pattern.slice("broadcast:".length));
-    }
-    if (pattern.startsWith("ordered:")) {
-      return buildSubject(this.targetName, "ordered", pattern.slice("ordered:".length));
+    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)
+      );
     }
-    return buildSubject(this.targetName, "ev", pattern);
+    return buildSubject(this.targetName, "ev" /* Event */, pattern);
   }
   /** Build NATS headers merging custom headers with transport headers. */
   buildHeaders(customHeaders, transport) {
     const hdrs = natsHeaders();
     hdrs.set("x-subject" /* Subject */, transport.subject);
-    hdrs.set("x-caller-name" /* CallerName */, internalName(this.rootOptions.name));
+    hdrs.set("x-caller-name" /* CallerName */, this.callerName);
     if (transport.correlationId) {
       hdrs.set("x-correlation-id" /* CorrelationId */, transport.correlationId);
     }
@@ -563,15 +599,9 @@ var JetstreamClient = class extends ClientProxy {
     }
     return { data: rawData, hdrs: null, timeout: void 0, messageId: void 0 };
   }
-  isCoreRpcMode() {
-    return !this.rootOptions.rpc || this.rootOptions.rpc.mode === "core";
-  }
-  isJetStreamRpcMode() {
-    return this.rootOptions.rpc?.mode === "jetstream";
-  }
   getRpcTimeout() {
     if (!this.rootOptions.rpc) return DEFAULT_RPC_TIMEOUT;
-    const defaultTimeout = this.isJetStreamRpcMode() ? DEFAULT_JETSTREAM_RPC_TIMEOUT : DEFAULT_RPC_TIMEOUT;
+    const defaultTimeout = isJetStreamRpcMode(this.rootOptions.rpc) ? DEFAULT_JETSTREAM_RPC_TIMEOUT : DEFAULT_RPC_TIMEOUT;
     return this.rootOptions.rpc.timeout ?? defaultTimeout;
   }
 };
@@ -597,6 +627,10 @@ import {
   NatsError
 } from "nats";
 import { defer, from, share, shareReplay, switchMap } from "rxjs";
+var DEFAULT_OPTIONS = {
+  maxReconnectAttempts: -1,
+  reconnectTimeWait: 1e3
+};
 var ConnectionProvider = class {
   constructor(options, eventBus) {
     this.options = options;
@@ -616,6 +650,7 @@ var ConnectionProvider = class {
   logger = new Logger2("Jetstream:Connection");
   connection = null;
   connectionPromise = null;
+  jsClient = null;
   jsmInstance = null;
   jsmPromise = null;
   /**
@@ -654,6 +689,22 @@ var ConnectionProvider = class {
     });
     return this.jsmPromise;
   }
+  /**
+   * Get a cached JetStream client.
+   *
+   * Invalidated automatically on reconnect and shutdown so consumers always
+   * operate against the live connection.
+   *
+   * @returns The cached JetStreamClient.
+   * @throws Error if the connection has not been established yet.
+   */
+  getJetStreamClient() {
+    if (!this.connection || this.connection.isClosed()) {
+      throw new Error("Not connected \u2014 call getConnection() before getJetStreamClient()");
+    }
+    this.jsClient ??= this.connection.jetstream();
+    return this.jsClient;
+  }
   /** Direct access to the raw NATS connection, or `null` if not yet connected. */
   get unwrap() {
     return this.connection;
@@ -682,6 +733,7 @@ var ConnectionProvider = class {
     } finally {
       this.connection = null;
       this.connectionPromise = null;
+      this.jsClient = null;
       this.jsmInstance = null;
       this.jsmPromise = null;
     }
@@ -691,6 +743,7 @@ var ConnectionProvider = class {
     const name = internalName(this.options.name);
     try {
       const nc = await connect({
+        ...DEFAULT_OPTIONS,
         ...this.options.connectionOptions,
         servers: this.options.servers,
         name
@@ -716,6 +769,7 @@ var ConnectionProvider = class {
             this.eventBus.emit("disconnect" /* Disconnect */);
             break;
           case Events2.Reconnect:
+            this.jsClient = null;
             this.jsmInstance = null;
             this.jsmPromise = null;
             this.eventBus.emit("reconnect" /* Reconnect */, nc.getServer());
@@ -755,6 +809,23 @@ var EventBus = class {
   emit(event, ...args) {
     const hook = this.hooks[event];
     if (!hook) return;
+    this.callHook(event, hook, ...args);
+  }
+  /**
+   * Hot-path optimized emit for MessageRouted events.
+   * Avoids rest/spread overhead of the generic `emit()`.
+   */
+  emitMessageRouted(subject, kind) {
+    const hook = this.hooks["messageRouted" /* MessageRouted */];
+    if (!hook) return;
+    this.callHook(
+      "messageRouted" /* MessageRouted */,
+      hook,
+      subject,
+      kind
+    );
+  }
+  callHook(event, hook, ...args) {
     try {
       const result = hook(...args);
       if (result && typeof result.catch === "function") {
@@ -834,7 +905,7 @@ JetstreamHealthIndicator = __decorateClass([
 // src/server/strategy.ts
 import { Server } from "@nestjs/microservices";
 var JetstreamStrategy = class extends Server {
-  constructor(options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer) {
+  constructor(options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer, ackWaitMap = /* @__PURE__ */ new Map()) {
     super();
     this.options = options;
     this.connection = connection;
@@ -845,6 +916,7 @@ var JetstreamStrategy = class extends Server {
     this.eventRouter = eventRouter;
     this.rpcRouter = rpcRouter;
     this.coreRpcServer = coreRpcServer;
+    this.ackWaitMap = ackWaitMap;
   }
   transportId = /* @__PURE__ */ Symbol("jetstream-transport");
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
@@ -862,17 +934,17 @@ var JetstreamStrategy = class extends Server {
     }
     this.started = true;
     this.patternRegistry.registerHandlers(this.getHandlers());
-    const streamKinds = this.resolveStreamKinds();
-    const durableKinds = this.resolveDurableConsumerKinds();
+    const { streams: streamKinds, durableConsumers: durableKinds } = this.resolveRequiredKinds();
     if (streamKinds.length > 0) {
       await this.streamProvider.ensureStreams(streamKinds);
       if (durableKinds.length > 0) {
         const consumers = await this.consumerProvider.ensureConsumers(durableKinds);
+        this.populateAckWaitMap(consumers);
         this.eventRouter.updateMaxDeliverMap(this.buildMaxDeliverMap(consumers));
         this.messageProvider.start(consumers);
       }
       if (this.patternRegistry.hasOrderedHandlers()) {
-        const orderedStreamName = this.streamProvider.getStreamName("ordered");
+        const orderedStreamName = this.streamProvider.getStreamName("ordered" /* Ordered */);
         await this.messageProvider.startOrdered(
           orderedStreamName,
           this.patternRegistry.getOrderedSubjects(),
@@ -882,11 +954,11 @@ var JetstreamStrategy = class extends Server {
       if (this.patternRegistry.hasEventHandlers() || this.patternRegistry.hasBroadcastHandlers() || this.patternRegistry.hasOrderedHandlers()) {
         this.eventRouter.start();
       }
-      if (this.isJetStreamRpcMode() && this.patternRegistry.hasRpcHandlers()) {
-        this.rpcRouter.start();
+      if (isJetStreamRpcMode(this.options.rpc) && this.patternRegistry.hasRpcHandlers()) {
+        await this.rpcRouter.start();
       }
     }
-    if (this.isCoreRpcMode() && this.patternRegistry.hasRpcHandlers()) {
+    if (isCoreRpcMode(this.options.rpc) && this.patternRegistry.hasRpcHandlers()) {
       await this.coreRpcServer.start();
     }
     callback();
@@ -927,36 +999,34 @@ var JetstreamStrategy = class extends Server {
   getPatternRegistry() {
     return this.patternRegistry;
   }
-  /** Determine which JetStream streams are needed. */
-  resolveStreamKinds() {
-    const kinds = [];
+  /** Determine which streams and durable consumers are needed. */
+  resolveRequiredKinds() {
+    const streams = [];
+    const durableConsumers = [];
     if (this.patternRegistry.hasEventHandlers()) {
-      kinds.push("ev");
+      streams.push("ev" /* Event */);
+      durableConsumers.push("ev" /* Event */);
     }
-    if (this.patternRegistry.hasOrderedHandlers()) {
-      kinds.push("ordered");
-    }
-    if (this.isJetStreamRpcMode() && this.patternRegistry.hasRpcHandlers()) {
-      kinds.push("cmd");
+    if (isJetStreamRpcMode(this.options.rpc) && this.patternRegistry.hasRpcHandlers()) {
+      streams.push("cmd" /* Command */);
+      durableConsumers.push("cmd" /* Command */);
     }
     if (this.patternRegistry.hasBroadcastHandlers()) {
-      kinds.push("broadcast");
-    }
-    return kinds;
-  }
-  /** Determine which stream kinds need durable consumers (ordered consumers are ephemeral). */
-  resolveDurableConsumerKinds() {
-    const kinds = [];
-    if (this.patternRegistry.hasEventHandlers()) {
-      kinds.push("ev");
+      streams.push("broadcast" /* Broadcast */);
+      durableConsumers.push("broadcast" /* Broadcast */);
     }
-    if (this.isJetStreamRpcMode() && this.patternRegistry.hasRpcHandlers()) {
-      kinds.push("cmd");
+    if (this.patternRegistry.hasOrderedHandlers()) {
+      streams.push("ordered" /* Ordered */);
     }
-    if (this.patternRegistry.hasBroadcastHandlers()) {
-      kinds.push("broadcast");
+    return { streams, durableConsumers };
+  }
+  /** Populate the shared ack_wait map from actual NATS consumer configs. */
+  populateAckWaitMap(consumers) {
+    for (const [kind, info] of consumers) {
+      if (info.config.ack_wait) {
+        this.ackWaitMap.set(kind, info.config.ack_wait);
+      }
     }
-    return kinds;
   }
   /** Build max_deliver map from actual NATS consumer configs (not options). */
   buildMaxDeliverMap(consumers) {
@@ -970,12 +1040,6 @@ var JetstreamStrategy = class extends Server {
     }
     return map;
   }
-  isCoreRpcMode() {
-    return !this.options.rpc || this.options.rpc.mode === "core";
-  }
-  isJetStreamRpcMode() {
-    return this.options.rpc?.mode === "jetstream";
-  }
 };
 
 // src/server/core-rpc.server.ts
@@ -985,6 +1049,13 @@ import { headers as natsHeaders2 } from "nats";
 // src/context/rpc.context.ts
 import { BaseRpcContext } from "@nestjs/microservices";
 var RpcContext = class extends BaseRpcContext {
+  _shouldRetry = false;
+  _retryDelay;
+  _shouldTerminate = false;
+  _terminateReason;
+  // ---------------------------------------------------------------------------
+  // Message accessors
+  // ---------------------------------------------------------------------------
   /**
    * Get the underlying NATS message.
    *
@@ -1019,6 +1090,122 @@ var RpcContext = class extends BaseRpcContext {
   isJetStream() {
     return "ack" in this.args[0];
   }
+  // ---------------------------------------------------------------------------
+  // JetStream metadata (return undefined for Core NATS messages)
+  // ---------------------------------------------------------------------------
+  /** How many times this message has been delivered. */
+  getDeliveryCount() {
+    return this.asJetStream()?.info.deliveryCount;
+  }
+  /** The JetStream stream this message belongs to. */
+  getStream() {
+    return this.asJetStream()?.info.stream;
+  }
+  /** The stream sequence number. */
+  getSequence() {
+    return this.asJetStream()?.seq;
+  }
+  /** The message timestamp as a `Date` (derived from `info.timestampNanos`). */
+  getTimestamp() {
+    const nanos = this.asJetStream()?.info.timestampNanos;
+    return typeof nanos === "number" ? new Date(nanos / 1e6) : void 0;
+  }
+  /** The name of the service that published this message (from `x-caller-name` header). */
+  getCallerName() {
+    return this.getHeader("x-caller-name" /* CallerName */);
+  }
+  // ---------------------------------------------------------------------------
+  // Handler-controlled settlement
+  // ---------------------------------------------------------------------------
+  /**
+   * Signal the transport to retry (nak) this message instead of acknowledging it.
+   *
+   * Use for business-level retries without throwing errors.
+   * Only affects JetStream event handlers (workqueue/broadcast).
+   *
+   * @param opts - Optional delay in ms before redelivery.
+   * @throws Error if {@link terminate} was already called.
+   */
+  retry(opts) {
+    this.assertJetStream("retry");
+    if (this._shouldTerminate) {
+      throw new Error("Cannot retry \u2014 terminate() was already called");
+    }
+    this._shouldRetry = true;
+    this._retryDelay = opts?.delayMs;
+  }
+  /**
+   * Signal the transport to permanently reject (term) this message.
+   *
+   * Use when a message is no longer relevant and should not be retried or sent to DLQ.
+   * Only affects JetStream event handlers (workqueue/broadcast).
+   *
+   * @param reason - Optional reason for termination (logged by NATS).
+   * @throws Error if {@link retry} was already called.
+   */
+  terminate(reason) {
+    this.assertJetStream("terminate");
+    if (this._shouldRetry) {
+      throw new Error("Cannot terminate \u2014 retry() was already called");
+    }
+    this._shouldTerminate = true;
+    this._terminateReason = reason;
+  }
+  /** Narrow to JsMsg or return null for Core messages. Used by metadata getters. */
+  asJetStream() {
+    return this.isJetStream() ? this.args[0] : null;
+  }
+  /** Ensure the message is JetStream — settlement actions are not available for Core NATS. */
+  assertJetStream(method) {
+    if (!this.isJetStream()) {
+      throw new Error(`${method}() is only available for JetStream messages`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Transport-facing state (read by EventRouter)
+  // ---------------------------------------------------------------------------
+  /** @internal */
+  get shouldRetry() {
+    return this._shouldRetry;
+  }
+  /** @internal */
+  get retryDelay() {
+    return this._retryDelay;
+  }
+  /** @internal */
+  get shouldTerminate() {
+    return this._shouldTerminate;
+  }
+  /** @internal */
+  get terminateReason() {
+    return this._terminateReason;
+  }
+};
+
+// src/utils/ack-extension.ts
+var DEFAULT_ACK_EXTENSION_INTERVAL = 5e3;
+var MIN_ACK_EXTENSION_INTERVAL = 500;
+var resolveAckExtensionInterval = (config, ackWaitNanos) => {
+  if (config === false || config === void 0) return null;
+  if (typeof config === "number") {
+    if (!Number.isFinite(config) || config <= 0) return null;
+    return Math.floor(config);
+  }
+  if (!ackWaitNanos) return DEFAULT_ACK_EXTENSION_INTERVAL;
+  const interval = Math.floor(ackWaitNanos / 1e6 / 2);
+  return Math.max(interval, MIN_ACK_EXTENSION_INTERVAL);
+};
+var startAckExtensionTimer = (msg, interval) => {
+  if (interval === null || interval <= 0) return null;
+  const timer2 = setInterval(() => {
+    try {
+      msg.working();
+    } catch {
+    }
+  }, interval);
+  return () => {
+    clearInterval(timer2);
+  };
 };
 
 // src/utils/serialize-error.ts
@@ -1031,15 +1218,20 @@ var serializeError = (err) => {
 
 // src/utils/unwrap-result.ts
 import { isObservable } from "rxjs";
-var unwrapResult = async (result) => {
+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 (isObservable(result)) {
     return subscribeToFirst(result);
   }
-  const resolved = await result;
-  if (isObservable(resolved)) {
-    return subscribeToFirst(resolved);
+  if (typeof result.then === "function") {
+    return result.then(
+      (resolved) => isObservable(resolved) ? subscribeToFirst(resolved) : resolved
+    );
   }
-  return resolved;
+  return Promise.resolve(result);
 };
 var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
   let done = false;
@@ -1107,13 +1299,17 @@ var CoreRpcServer = class {
   }
   /** Handle an incoming Core NATS request. */
   async handleRequest(msg) {
+    if (!msg.reply) {
+      this.logger.warn(`Ignoring fire-and-forget message on RPC subject: ${msg.subject}`);
+      return;
+    }
     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");
+    this.eventBus.emitMessageRouted(msg.subject, "rpc" /* Rpc */);
     let data;
     try {
       data = this.codec.decode(msg.data);
@@ -1171,14 +1367,14 @@ var StreamProvider = class {
   getSubjects(kind) {
     const name = internalName(this.options.name);
     switch (kind) {
-      case "ev":
-        return [`${name}.ev.>`];
-      case "cmd":
-        return [`${name}.cmd.>`];
-      case "broadcast":
+      case "ev" /* Event */:
+        return [`${name}.${"ev" /* Event */}.>`];
+      case "cmd" /* Command */:
+        return [`${name}.${"cmd" /* Command */}.>`];
+      case "broadcast" /* Broadcast */:
         return ["broadcast.>"];
-      case "ordered":
-        return [`${name}.ordered.>`];
+      case "ordered" /* Ordered */:
+        return [`${name}.${"ordered" /* Ordered */}.>`];
     }
   }
   /** Ensure a single stream exists, creating or updating as needed. */
@@ -1215,26 +1411,26 @@ var StreamProvider = class {
   /** Get default config for a stream kind. */
   getDefaults(kind) {
     switch (kind) {
-      case "ev":
+      case "ev" /* Event */:
         return DEFAULT_EVENT_STREAM_CONFIG;
-      case "cmd":
+      case "cmd" /* Command */:
         return DEFAULT_COMMAND_STREAM_CONFIG;
-      case "broadcast":
+      case "broadcast" /* Broadcast */:
         return DEFAULT_BROADCAST_STREAM_CONFIG;
-      case "ordered":
+      case "ordered" /* Ordered */:
         return DEFAULT_ORDERED_STREAM_CONFIG;
     }
   }
   /** Get user-provided overrides for a stream kind. */
   getOverrides(kind) {
     switch (kind) {
-      case "ev":
+      case "ev" /* Event */:
         return this.options.events?.stream ?? {};
-      case "cmd":
+      case "cmd" /* Command */:
         return this.options.rpc?.mode === "jetstream" ? this.options.rpc.stream ?? {} : {};
-      case "broadcast":
+      case "broadcast" /* Broadcast */:
         return this.options.broadcast?.stream ?? {};
-      case "ordered":
+      case "ordered" /* Ordered */:
         return this.options.ordered?.stream ?? {};
     }
   }
@@ -1297,7 +1493,7 @@ var ConsumerProvider = class {
     const serviceName = internalName(this.options.name);
     const defaults = this.getDefaults(kind);
     const overrides = this.getOverrides(kind);
-    if (kind === "broadcast") {
+    if (kind === "broadcast" /* Broadcast */) {
       const broadcastPatterns = this.patternRegistry.getBroadcastPatterns();
       if (broadcastPatterns.length === 0) {
         throw new Error("Broadcast consumer requested but no broadcast patterns are registered");
@@ -1319,7 +1515,10 @@ var ConsumerProvider = class {
         filter_subjects: broadcastPatterns
       };
     }
-    const filter_subject = kind === "ev" ? `${serviceName}.ev.>` : `${serviceName}.cmd.>`;
+    if (kind !== "ev" /* Event */ && kind !== "cmd" /* Command */) {
+      throw new Error(`Unexpected durable consumer kind: ${kind}`);
+    }
+    const filter_subject = `${serviceName}.${kind}.>`;
     return {
       ...defaults,
       ...overrides,
@@ -1331,26 +1530,26 @@ var ConsumerProvider = class {
   /** Get default config for a consumer kind. */
   getDefaults(kind) {
     switch (kind) {
-      case "ev":
+      case "ev" /* Event */:
         return DEFAULT_EVENT_CONSUMER_CONFIG;
-      case "cmd":
+      case "cmd" /* Command */:
         return DEFAULT_COMMAND_CONSUMER_CONFIG;
-      case "broadcast":
+      case "broadcast" /* Broadcast */:
         return DEFAULT_BROADCAST_CONSUMER_CONFIG;
-      case "ordered":
+      case "ordered" /* Ordered */:
         throw new Error("Ordered consumers are ephemeral and should not use durable config");
     }
   }
   /** Get user-provided overrides for a consumer kind. */
   getOverrides(kind) {
     switch (kind) {
-      case "ev":
+      case "ev" /* Event */:
         return this.options.events?.consumer ?? {};
-      case "cmd":
+      case "cmd" /* Command */:
         return this.options.rpc?.mode === "jetstream" ? this.options.rpc.consumer ?? {} : {};
-      case "broadcast":
+      case "broadcast" /* Broadcast */:
         return this.options.broadcast?.consumer ?? {};
-      case "ordered":
+      case "ordered" /* Ordered */:
         throw new Error("Ordered consumers are ephemeral and should not use durable config");
     }
   }
@@ -1358,7 +1557,10 @@ var ConsumerProvider = class {
 
 // src/server/infrastructure/message.provider.ts
 import { Logger as Logger7 } from "@nestjs/common";
-import { DeliverPolicy as DeliverPolicy2 } from "nats";
+import {
+  ConsumerEvents,
+  DeliverPolicy as DeliverPolicy2
+} from "nats";
 import {
   catchError,
   defer as defer2,
@@ -1371,9 +1573,10 @@ import {
   timer
 } from "rxjs";
 var MessageProvider = class {
-  constructor(connection, eventBus) {
+  constructor(connection, eventBus, consumeOptionsMap = /* @__PURE__ */ new Map()) {
     this.connection = connection;
     this.eventBus = eventBus;
+    this.consumeOptionsMap = consumeOptionsMap;
   }
   logger = new Logger7("Jetstream:Message");
   activeIterators = /* @__PURE__ */ new Set();
@@ -1423,6 +1626,7 @@ var MessageProvider = class {
    *
    * @param streamName - JetStream stream to consume from.
    * @param filterSubjects - NATS subjects to filter on.
+   * @param orderedConfig - Optional overrides for ordered consumer options.
    */
   async startOrdered(streamName2, filterSubjects, orderedConfig) {
     const consumerOpts = { filterSubjects };
@@ -1448,6 +1652,11 @@ var MessageProvider = class {
   }
   /** Stop all consumer flows and reinitialize subjects for potential restart. */
   destroy() {
+    if (this.orderedReadyReject) {
+      this.orderedReadyReject(new Error("Destroyed before ordered consumer connected"));
+      this.orderedReadyResolve = null;
+      this.orderedReadyReject = null;
+    }
     this.destroy$.next();
     this.destroy$.complete();
     for (const messages of this.activeIterators) {
@@ -1467,42 +1676,17 @@ var MessageProvider = class {
   /** 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 defer2(() => this.consumeOnce(info, target$)).pipe(
-      tap(() => {
-        lastRunFailed = false;
-      }),
-      catchError((err) => {
-        consecutiveFailures++;
-        lastRunFailed = true;
-        this.logger.error(`Consumer ${info.name} error, will restart:`, err);
-        this.eventBus.emit(
-          "error" /* Error */,
-          err instanceof Error ? err : new Error(String(err)),
-          "message-provider"
-        );
-        return EMPTY;
-      }),
-      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...`);
-          return timer(delay);
-        }
-      }),
-      takeUntil(this.destroy$)
-    );
+    return this.createSelfHealingFlow(() => this.consumeOnce(kind, info, target$), info.name);
   }
   /** Single iteration: get consumer -> pull messages -> emit to subject. */
-  async consumeOnce(info, target$) {
-    const js = (await this.connection.getConnection()).jetstream();
+  async consumeOnce(kind, info, target$) {
+    const js = this.connection.getJetStreamClient();
     const consumer = await js.consumers.get(info.stream_name, info.name);
-    const messages = await consumer.consume();
+    const defaults = { idle_heartbeat: 5e3 };
+    const userOptions = this.consumeOptionsMap.get(kind) ?? {};
+    const messages = await consumer.consume({ ...defaults, ...userOptions });
     this.activeIterators.add(messages);
+    this.monitorConsumerHealth(messages, info.name);
     try {
       for await (const msg of messages) {
         target$.next(msg);
@@ -1514,47 +1698,73 @@ var MessageProvider = class {
   /** Get the target subject for a consumer kind. */
   getTargetSubject(kind) {
     switch (kind) {
-      case "ev":
+      case "ev" /* Event */:
         return this.eventMessages$;
-      case "cmd":
+      case "cmd" /* Command */:
         return this.commandMessages$;
-      case "broadcast":
+      case "broadcast" /* Broadcast */:
         return this.broadcastMessages$;
-      case "ordered":
+      case "ordered" /* Ordered */:
         return this.orderedMessages$;
+      default: {
+        const _exhaustive = kind;
+        throw new Error(`Unknown stream kind: ${_exhaustive}`);
+      }
     }
   }
+  /** Monitor heartbeats and restart the consumer iterator on prolonged silence. */
+  monitorConsumerHealth(messages, name) {
+    (async () => {
+      for await (const status of await messages.status()) {
+        if (status.type === ConsumerEvents.HeartbeatsMissed && status.data >= 2) {
+          this.logger.warn(`Consumer ${name}: ${status.data} heartbeats missed, restarting`);
+          messages.stop();
+          break;
+        }
+      }
+    })().catch((err) => {
+      if (err) {
+        this.logger.debug(`Consumer ${name} health monitor ended:`, err);
+      }
+    });
+  }
   /** Create a self-healing ordered consumer flow. */
   createOrderedFlow(streamName2, consumerOpts) {
+    return this.createSelfHealingFlow(
+      () => this.consumeOrderedOnce(streamName2, consumerOpts),
+      "ordered" /* Ordered */,
+      (err) => {
+        if (this.orderedReadyReject) {
+          this.orderedReadyReject(err);
+          this.orderedReadyReject = null;
+          this.orderedReadyResolve = null;
+        }
+      }
+    );
+  }
+  /** Shared self-healing flow: defer -> retry with exponential backoff on error/completion. */
+  createSelfHealingFlow(source, label, onFirstError) {
     let consecutiveFailures = 0;
-    let lastRunFailed = false;
-    return defer2(() => this.consumeOrderedOnce(streamName2, consumerOpts)).pipe(
+    return defer2(source).pipe(
       tap(() => {
-        lastRunFailed = false;
+        consecutiveFailures = 0;
       }),
       catchError((err) => {
         consecutiveFailures++;
-        lastRunFailed = true;
-        this.logger.error("Ordered consumer error, will restart:", err);
+        this.logger.error(`Consumer ${label} error, will restart:`, err);
         this.eventBus.emit(
           "error" /* Error */,
           err instanceof Error ? err : new Error(String(err)),
           "message-provider"
         );
-        if (this.orderedReadyReject) {
-          this.orderedReadyReject(err);
-          this.orderedReadyReject = null;
-          this.orderedReadyResolve = null;
-        }
+        onFirstError?.(err);
+        onFirstError = void 0;
         return EMPTY;
       }),
       repeat({
         delay: () => {
-          if (!lastRunFailed) {
-            consecutiveFailures = 0;
-          }
           const delay = Math.min(100 * Math.pow(2, consecutiveFailures), 3e4);
-          this.logger.warn(`Ordered consumer stream ended, restarting in ${delay}ms...`);
+          this.logger.warn(`Consumer ${label} stream ended, restarting in ${delay}ms...`);
           return timer(delay);
         }
       })
@@ -1562,7 +1772,7 @@ var MessageProvider = class {
   }
   /** Single iteration: create ordered consumer -> iterate messages. */
   async consumeOrderedOnce(streamName2, consumerOpts) {
-    const js = (await this.connection.getConnection()).jetstream();
+    const js = this.connection.getJetStreamClient();
     const consumer = await js.consumers.get(streamName2, consumerOpts);
     const messages = await consumer.consume();
     if (this.orderedReadyResolve) {
@@ -1583,12 +1793,24 @@ var MessageProvider = class {
 
 // src/server/routing/pattern-registry.ts
 import { Logger as Logger8 } from "@nestjs/common";
+var HANDLER_LABELS = {
+  ["broadcast" /* Broadcast */]: "broadcast" /* Broadcast */,
+  ["ordered" /* Ordered */]: "ordered" /* Ordered */,
+  ["ev" /* Event */]: "event" /* Event */,
+  ["cmd" /* Command */]: "rpc" /* Rpc */
+};
 var PatternRegistry = class {
   constructor(options) {
     this.options = options;
   }
   logger = new Logger8("Jetstream:PatternRegistry");
   registry = /* @__PURE__ */ new Map();
+  // Cached after registerHandlers() — the registry is immutable from that point
+  cachedPatterns = null;
+  _hasEvents = false;
+  _hasCommands = false;
+  _hasBroadcasts = false;
+  _hasOrdered = false;
   /**
    * Register all handlers from the NestJS strategy.
    *
@@ -1606,16 +1828,12 @@ var PatternRegistry = class {
           `Handler "${pattern}" cannot be both broadcast and ordered. Use one or the other.`
         );
       }
-      let fullSubject;
-      if (isBroadcast) {
-        fullSubject = buildBroadcastSubject(pattern);
-      } else if (isOrdered) {
-        fullSubject = buildSubject(serviceName, "ordered", pattern);
-      } else if (isEvent) {
-        fullSubject = buildSubject(serviceName, "ev", pattern);
-      } else {
-        fullSubject = buildSubject(serviceName, "cmd", pattern);
-      }
+      let kind;
+      if (isBroadcast) kind = "broadcast" /* Broadcast */;
+      else if (isOrdered) kind = "ordered" /* Ordered */;
+      else if (isEvent) kind = "ev" /* Event */;
+      else kind = "cmd" /* Command */;
+      const fullSubject = kind === "broadcast" /* Broadcast */ ? buildBroadcastSubject(pattern) : buildSubject(serviceName, kind, pattern);
       this.registry.set(fullSubject, {
         handler,
         pattern,
@@ -1623,18 +1841,13 @@ var PatternRegistry = class {
         isBroadcast,
         isOrdered
       });
-      let kind;
-      if (isBroadcast) {
-        kind = "broadcast";
-      } else if (isOrdered) {
-        kind = "ordered";
-      } else if (isEvent) {
-        kind = "event";
-      } else {
-        kind = "rpc";
-      }
-      this.logger.debug(`Registered ${kind}: ${pattern} -> ${fullSubject}`);
+      this.logger.debug(`Registered ${HANDLER_LABELS[kind]}: ${pattern} -> ${fullSubject}`);
     }
+    this.cachedPatterns = this.buildPatternsByKind();
+    this._hasEvents = this.cachedPatterns.events.length > 0;
+    this._hasCommands = this.cachedPatterns.commands.length > 0;
+    this._hasBroadcasts = this.cachedPatterns.broadcasts.length > 0;
+    this._hasOrdered = this.cachedPatterns.ordered.length > 0;
     this.logSummary();
   }
   /** Find handler for a full NATS subject. */
@@ -1643,33 +1856,53 @@ var PatternRegistry = class {
   }
   /** Get all registered broadcast patterns (for consumer filter_subject setup). */
   getBroadcastPatterns() {
-    return Array.from(this.registry.values()).filter((r) => r.isBroadcast).map((r) => `broadcast.${r.pattern}`);
+    return this.getPatternsByKind().broadcasts.map((p) => buildBroadcastSubject(p));
   }
-  /** Check if any broadcast handlers are registered. */
   hasBroadcastHandlers() {
-    return Array.from(this.registry.values()).some((r) => r.isBroadcast);
+    return this._hasBroadcasts;
   }
-  /** Check if any RPC (command) handlers are registered. */
   hasRpcHandlers() {
-    return Array.from(this.registry.values()).some(
-      (r) => !r.isEvent && !r.isBroadcast && !r.isOrdered
-    );
+    return this._hasCommands;
   }
-  /** Check if any workqueue event handlers are registered. */
   hasEventHandlers() {
-    return Array.from(this.registry.values()).some((r) => r.isEvent && !r.isBroadcast);
+    return this._hasEvents;
   }
-  /** Check if any ordered event handlers are registered. */
   hasOrderedHandlers() {
-    return Array.from(this.registry.values()).some((r) => r.isOrdered);
+    return this._hasOrdered;
   }
   /** Get fully-qualified NATS subjects for ordered handlers. */
   getOrderedSubjects() {
-    const name = internalName(this.options.name);
-    return Array.from(this.registry.values()).filter((r) => r.isOrdered).map((r) => `${name}.ordered.${r.pattern}`);
+    return this.getPatternsByKind().ordered.map(
+      (p) => buildSubject(this.options.name, "ordered" /* Ordered */, p)
+    );
   }
-  /** Get patterns grouped by kind. */
+  /** Get patterns grouped by kind (cached after registration). */
   getPatternsByKind() {
+    const patterns = this.cachedPatterns ?? this.buildPatternsByKind();
+    return {
+      events: [...patterns.events],
+      commands: [...patterns.commands],
+      broadcasts: [...patterns.broadcasts],
+      ordered: [...patterns.ordered]
+    };
+  }
+  /** Normalize a full NATS subject back to the user-facing pattern. */
+  normalizeSubject(subject) {
+    const name = internalName(this.options.name);
+    const prefixes = [
+      `${name}.${"cmd" /* Command */}.`,
+      `${name}.${"ev" /* Event */}.`,
+      `${name}.${"ordered" /* Ordered */}.`,
+      `${"broadcast" /* Broadcast */}.`
+    ];
+    for (const prefix of prefixes) {
+      if (subject.startsWith(prefix)) {
+        return subject.slice(prefix.length);
+      }
+    }
+    return subject;
+  }
+  buildPatternsByKind() {
     const events = [];
     const commands = [];
     const broadcasts = [];
@@ -1682,18 +1915,6 @@ var PatternRegistry = class {
     }
     return { events, commands, broadcasts, ordered };
   }
-  /** Normalize a full NATS subject back to the user-facing pattern. */
-  normalizeSubject(subject) {
-    const name = internalName(this.options.name);
-    const prefixes = [`${name}.cmd.`, `${name}.ev.`, `${name}.ordered.`, "broadcast."];
-    for (const prefix of prefixes) {
-      if (subject.startsWith(prefix)) {
-        return subject.slice(prefix.length);
-      }
-    }
-    return subject;
-  }
-  /** Log a summary of all registered handlers. */
   logSummary() {
     const { events, commands, broadcasts, ordered } = this.getPatternsByKind();
     const parts = [
@@ -1710,21 +1931,16 @@ var PatternRegistry = class {
 
 // src/server/routing/event.router.ts
 import { Logger as Logger9 } from "@nestjs/common";
-import {
-  catchError as catchError2,
-  concatMap,
-  defer as defer3,
-  EMPTY as EMPTY2,
-  from as from2,
-  mergeMap
-} from "rxjs";
+import { concatMap, from as from2, mergeMap } from "rxjs";
 var EventRouter = class {
-  constructor(messageProvider, patternRegistry, codec, eventBus, deadLetterConfig) {
+  constructor(messageProvider, patternRegistry, codec, eventBus, deadLetterConfig, processingConfig, ackWaitMap) {
     this.messageProvider = messageProvider;
     this.patternRegistry = patternRegistry;
     this.codec = codec;
     this.eventBus = eventBus;
     this.deadLetterConfig = deadLetterConfig;
+    this.processingConfig = processingConfig;
+    this.ackWaitMap = ackWaitMap;
   }
   logger = new Logger9("Jetstream:EventRouter");
   subscriptions = [];
@@ -1738,10 +1954,10 @@ var EventRouter = class {
   }
   /** Start routing event, broadcast, and ordered messages to handlers. */
   start() {
-    this.subscribeToStream(this.messageProvider.events$, "workqueue");
-    this.subscribeToStream(this.messageProvider.broadcasts$, "broadcast");
+    this.subscribeToStream(this.messageProvider.events$, "ev" /* Event */);
+    this.subscribeToStream(this.messageProvider.broadcasts$, "broadcast" /* Broadcast */);
     if (this.patternRegistry.hasOrderedHandlers()) {
-      this.subscribeToStream(this.messageProvider.ordered$, "ordered", true);
+      this.subscribeToStream(this.messageProvider.ordered$, "ordered" /* Ordered */);
     }
   }
   /** Stop routing and unsubscribe from all streams. */
@@ -1752,41 +1968,88 @@ var EventRouter = class {
     this.subscriptions.length = 0;
   }
   /** Subscribe to a message stream and route each message. */
-  subscribeToStream(stream$, label, isOrdered = false) {
-    const route = (msg) => defer3(() => isOrdered ? this.handleOrdered(msg) : this.handle(msg)).pipe(
-      catchError2((err) => {
-        this.logger.error(`Unexpected error in ${label} event router`, err);
-        return EMPTY2;
-      })
+  subscribeToStream(stream$, kind) {
+    const isOrdered = kind === "ordered" /* Ordered */;
+    const ackExtensionInterval = isOrdered ? null : resolveAckExtensionInterval(this.getAckExtensionConfig(kind), this.ackWaitMap?.get(kind));
+    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)).subscribe();
+    const subscription = stream$.pipe(isOrdered ? concatMap(route) : mergeMap(route, concurrency)).subscribe();
     this.subscriptions.push(subscription);
   }
-  /** Handle a single event message: decode -> execute handler -> ack/nak. */
-  handle(msg) {
+  getConcurrency(kind) {
+    if (kind === "ev" /* Event */) return this.processingConfig?.events?.concurrency;
+    if (kind === "broadcast" /* Broadcast */) return this.processingConfig?.broadcast?.concurrency;
+    return void 0;
+  }
+  getAckExtensionConfig(kind) {
+    if (kind === "ev" /* Event */) return this.processingConfig?.events?.ackExtension;
+    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) {
-      msg.term(`No handler for event: ${msg.subject}`);
-      this.logger.error(`No handler for event subject: ${msg.subject}`);
-      return EMPTY2;
+      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) {
-      msg.term("Decode error");
+      if (!isOrdered) msg.term("Decode error");
       this.logger.error(`Decode error for ${msg.subject}:`, err);
-      return EMPTY2;
+      return null;
     }
-    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "event");
-    const ctx = new RpcContext([msg]);
-    return from2(this.executeHandler(handler, data, ctx, msg));
+    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) {
+  async executeHandler(handler, data, ctx, msg, ackExtensionInterval) {
+    const stopAckExtension = startAckExtensionTimer(msg, ackExtensionInterval);
     try {
       await unwrapResult(handler(data, ctx));
-      msg.ack();
+      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)) {
@@ -1794,30 +2057,10 @@ var EventRouter = class {
       } else {
         msg.nak();
       }
+    } finally {
+      stopAckExtension?.();
     }
   }
-  /** Handle an ordered message: decode -> execute handler -> no ack/nak. */
-  handleOrdered(msg) {
-    const handler = this.patternRegistry.getHandler(msg.subject);
-    if (!handler) {
-      this.logger.error(`No handler for ordered subject: ${msg.subject}`);
-      return EMPTY2;
-    }
-    let data;
-    try {
-      data = this.codec.decode(msg.data);
-    } catch (err) {
-      this.logger.error(`Decode error for ordered ${msg.subject}:`, err);
-      return EMPTY2;
-    }
-    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "event");
-    const ctx = new RpcContext([msg]);
-    return from2(
-      unwrapResult(handler(data, ctx)).catch((err) => {
-        this.logger.error(`Ordered handler error (${msg.subject}):`, err);
-      })
-    );
-  }
   /** Check if the message has exhausted all delivery attempts. */
   isDeadLetter(msg) {
     if (!this.deadLetterConfig) return false;
@@ -1838,7 +2081,10 @@ var EventRouter = class {
       timestamp: new Date(msg.info.timestampNanos / 1e6).toISOString()
     };
     this.eventBus.emit("deadLetter" /* DeadLetter */, info);
-    if (!this.deadLetterConfig) return;
+    if (!this.deadLetterConfig) {
+      msg.term("Dead letter config unavailable");
+      return;
+    }
     try {
       await this.deadLetterConfig.onDeadLetter(info);
       msg.term("Dead letter processed");
@@ -1852,73 +2098,85 @@ var EventRouter = class {
 // src/server/routing/rpc.router.ts
 import { Logger as Logger10 } from "@nestjs/common";
 import { headers } from "nats";
-import { catchError as catchError3, defer as defer4, EMPTY as EMPTY3, from as from3, mergeMap as mergeMap2 } from "rxjs";
+import { from as from3, mergeMap as mergeMap2 } from "rxjs";
 var RpcRouter = class {
-  constructor(messageProvider, patternRegistry, connection, codec, eventBus, timeout) {
+  constructor(messageProvider, patternRegistry, connection, codec, eventBus, rpcOptions, ackWaitMap) {
     this.messageProvider = messageProvider;
     this.patternRegistry = patternRegistry;
     this.connection = connection;
     this.codec = codec;
     this.eventBus = eventBus;
-    this.timeout = timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT;
+    this.rpcOptions = rpcOptions;
+    this.ackWaitMap = ackWaitMap;
+    this.timeout = rpcOptions?.timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT;
+    this.concurrency = rpcOptions?.concurrency;
   }
   logger = new Logger10("Jetstream:RpcRouter");
   timeout;
+  concurrency;
+  resolvedAckExtensionInterval;
   subscription = null;
+  cachedNc = null;
+  /** Lazily resolve the ack extension interval (needs ackWaitMap populated at runtime). */
+  get ackExtensionInterval() {
+    if (this.resolvedAckExtensionInterval !== void 0) return this.resolvedAckExtensionInterval;
+    this.resolvedAckExtensionInterval = resolveAckExtensionInterval(
+      this.rpcOptions?.ackExtension,
+      this.ackWaitMap?.get("cmd" /* Command */)
+    );
+    return this.resolvedAckExtensionInterval;
+  }
   /** Start routing command messages to handlers. */
-  start() {
-    this.subscription = this.messageProvider.commands$.pipe(
-      mergeMap2(
-        (msg) => defer4(() => this.handle(msg)).pipe(
-          catchError3((err) => {
-            this.logger.error("Unexpected error in RPC router", err);
-            return EMPTY3;
-          })
-        )
-      )
-    ).subscribe();
+  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. */
-  handle(msg) {
-    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 EMPTY3;
-    }
-    const replyTo = msg.headers?.get("x-reply-to" /* ReplyTo */);
-    const correlationId = msg.headers?.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 EMPTY3;
-    }
-    let data;
+  /** Handle a single RPC command message with error isolation. */
+  async handleSafe(msg) {
     try {
-      data = this.codec.decode(msg.data);
+      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) {
-      msg.term("Decode error");
-      this.logger.error(`Decode error for RPC ${msg.subject}:`, err);
-      return EMPTY3;
+      this.logger.error("Unexpected error in RPC router", err);
     }
-    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "rpc");
-    return from3(this.executeHandler(handler, data, msg, replyTo, correlationId));
   }
   /** Execute handler, publish response, settle message. */
   async executeHandler(handler, data, msg, replyTo, correlationId) {
-    const nc = await this.connection.getConnection();
+    const nc = this.cachedNc ?? await this.connection.getConnection();
     const ctx = new RpcContext([msg]);
-    const hdrs = headers();
-    hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
     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");
@@ -1928,8 +2186,11 @@ var RpcRouter = class {
       if (settled) return;
       settled = true;
       clearTimeout(timeoutId);
+      stopAckExtension?.();
       msg.ack();
       try {
+        const hdrs = headers();
+        hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
         nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
       } catch (publishErr) {
         this.logger.error(`Failed to publish RPC response for ${msg.subject}`, publishErr);
@@ -1938,7 +2199,10 @@ var RpcRouter = class {
       if (settled) return;
       settled = true;
       clearTimeout(timeoutId);
+      stopAckExtension?.();
       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 });
       } catch (encodeErr) {
@@ -1961,7 +2225,7 @@ var ShutdownManager = class {
   /**
    * Execute the full shutdown sequence.
    *
-   * @param strategy Optional strategy to close (stops consumers and subscriptions).
+   * @param strategy Optional stoppable to close (stops consumers and subscriptions).
    */
   async shutdown(strategy) {
     this.eventBus.emit("shutdownStart" /* ShutdownStart */);
@@ -1984,6 +2248,7 @@ var ShutdownManager = class {
 };
 
 // src/jetstream.module.ts
+var JETSTREAM_ACK_WAIT_MAP = /* @__PURE__ */ Symbol("JETSTREAM_ACK_WAIT_MAP");
 var JetstreamModule = class {
   constructor(shutdownManager, strategy) {
     this.shutdownManager = shutdownManager;
@@ -2168,13 +2433,26 @@ var JetstreamModule = class {
           return new ConsumerProvider(options, connection, streamProvider, patternRegistry);
         }
       },
+      // Shared ack_wait map — populated by strategy after ensureConsumers()
+      {
+        provide: JETSTREAM_ACK_WAIT_MAP,
+        useFactory: () => /* @__PURE__ */ new Map()
+      },
       // MessageProvider — pull-based message consumption
       {
         provide: MessageProvider,
         inject: [JETSTREAM_OPTIONS, JETSTREAM_CONNECTION, JETSTREAM_EVENT_BUS],
         useFactory: (options, connection, eventBus) => {
           if (options.consumer === false) return null;
-          return new MessageProvider(connection, eventBus);
+          const consumeOptionsMap = /* @__PURE__ */ new Map();
+          if (options.events?.consume)
+            consumeOptionsMap.set("ev" /* Event */, options.events.consume);
+          if (options.broadcast?.consume)
+            consumeOptionsMap.set("broadcast" /* Broadcast */, options.broadcast.consume);
+          if (options.rpc?.mode === "jetstream" && options.rpc.consume) {
+            consumeOptionsMap.set("cmd" /* Command */, options.rpc.consume);
+          }
+          return new MessageProvider(connection, eventBus, consumeOptionsMap);
         }
       },
       // EventRouter — routes event and broadcast messages to handlers
@@ -2185,20 +2463,33 @@ var JetstreamModule = class {
           MessageProvider,
           PatternRegistry,
           JETSTREAM_CODEC,
-          JETSTREAM_EVENT_BUS
+          JETSTREAM_EVENT_BUS,
+          JETSTREAM_ACK_WAIT_MAP
         ],
-        useFactory: (options, messageProvider, patternRegistry, codec, eventBus) => {
+        useFactory: (options, messageProvider, patternRegistry, codec, eventBus, ackWaitMap) => {
           if (options.consumer === false) return null;
           const deadLetterConfig = options.onDeadLetter ? {
             maxDeliverByStream: /* @__PURE__ */ new Map(),
             onDeadLetter: options.onDeadLetter
           } : void 0;
+          const processingConfig = {
+            events: {
+              concurrency: options.events?.concurrency,
+              ackExtension: options.events?.ackExtension
+            },
+            broadcast: {
+              concurrency: options.broadcast?.concurrency,
+              ackExtension: options.broadcast?.ackExtension
+            }
+          };
           return new EventRouter(
             messageProvider,
             patternRegistry,
             codec,
             eventBus,
-            deadLetterConfig
+            deadLetterConfig,
+            processingConfig,
+            ackWaitMap
           );
         }
       },
@@ -2211,18 +2502,24 @@ var JetstreamModule = class {
           PatternRegistry,
           JETSTREAM_CONNECTION,
           JETSTREAM_CODEC,
-          JETSTREAM_EVENT_BUS
+          JETSTREAM_EVENT_BUS,
+          JETSTREAM_ACK_WAIT_MAP
         ],
-        useFactory: (options, messageProvider, patternRegistry, connection, codec, eventBus) => {
+        useFactory: (options, messageProvider, patternRegistry, connection, codec, eventBus, ackWaitMap) => {
           if (options.consumer === false) return null;
-          const timeout = options.rpc?.mode === "jetstream" ? options.rpc.timeout : void 0;
+          const rpcOptions = options.rpc?.mode === "jetstream" ? {
+            timeout: options.rpc.timeout,
+            concurrency: options.rpc.concurrency,
+            ackExtension: options.rpc.ackExtension
+          } : void 0;
           return new RpcRouter(
             messageProvider,
             patternRegistry,
             connection,
             codec,
             eventBus,
-            timeout
+            rpcOptions,
+            ackWaitMap
           );
         }
       },
@@ -2253,9 +2550,10 @@ var JetstreamModule = class {
           MessageProvider,
           EventRouter,
           RpcRouter,
-          CoreRpcServer
+          CoreRpcServer,
+          JETSTREAM_ACK_WAIT_MAP
         ],
-        useFactory: (options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer) => {
+        useFactory: (options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer, ackWaitMap) => {
           if (options.consumer === false) return null;
           return new JetstreamStrategy(
             options,
@@ -2266,7 +2564,8 @@ var JetstreamModule = class {
             messageProvider,
             eventRouter,
             rpcRouter,
-            coreRpcServer
+            coreRpcServer,
+            ackWaitMap
           );
         }
       }
@@ -2346,8 +2645,13 @@ export {
   JetstreamRecordBuilder,
   JetstreamStrategy,
   JsonCodec,
+  MessageKind,
+  PatternPrefix,
   RpcContext,
+  StreamKind,
   TransportEvent,
   getClientToken,
+  isCoreRpcMode,
+  isJetStreamRpcMode,
   toNanos
 };