@horizon-republic/nestjs-jetstream 2.7.0 → 2.8.0

package/dist/index.cjs

@@ -47,9 +47,13 @@ __export(index_exports, {
   RpcContext: () => RpcContext,
   StreamKind: () => StreamKind,
   TransportEvent: () => TransportEvent,
+  buildSubject: () => buildSubject,
+  consumerName: () => consumerName,
   getClientToken: () => getClientToken,
+  internalName: () => internalName,
   isCoreRpcMode: () => isCoreRpcMode,
   isJetStreamRpcMode: () => isJetStreamRpcMode,
+  streamName: () => streamName,
   toNanos: () => toNanos
 });
 module.exports = __toCommonJS(index_exports);
@@ -60,7 +64,8 @@ var import_common12 = require("@nestjs/common");
 // src/client/jetstream.client.ts
 var import_common = require("@nestjs/common");
 var import_microservices = require("@nestjs/microservices");
-var import_nats2 = require("nats");
+var import_transport_node = require("@nats-io/transport-node");
+var import_nuid = require("@nats-io/nuid");
 
 // src/interfaces/hooks.interface.ts
 var MessageKind = /* @__PURE__ */ ((MessageKind2) => {
@@ -91,7 +96,7 @@ var StreamKind = /* @__PURE__ */ ((StreamKind2) => {
 })(StreamKind || {});
 
 // src/jetstream.constants.ts
-var import_nats = require("nats");
+var import_jetstream = require("@nats-io/jetstream");
 var JETSTREAM_OPTIONS = /* @__PURE__ */ Symbol("JETSTREAM_OPTIONS");
 var JETSTREAM_CONNECTION = /* @__PURE__ */ Symbol("JETSTREAM_CONNECTION");
 var JETSTREAM_CODEC = /* @__PURE__ */ Symbol("JETSTREAM_CODEC");
@@ -109,12 +114,12 @@ var NANOS_PER = {
 };
 var toNanos = (value, unit) => value * NANOS_PER[unit];
 var baseStreamConfig = {
-  retention: import_nats.RetentionPolicy.Workqueue,
-  storage: import_nats.StorageType.File,
+  retention: import_jetstream.RetentionPolicy.Workqueue,
+  storage: import_jetstream.StorageType.File,
   num_replicas: 1,
-  discard: import_nats.DiscardPolicy.Old,
+  discard: import_jetstream.DiscardPolicy.Old,
   allow_direct: true,
-  compression: import_nats.StoreCompression.S2
+  compression: import_jetstream.StoreCompression.S2
 };
 var DEFAULT_EVENT_STREAM_CONFIG = {
   ...baseStreamConfig,
@@ -140,7 +145,7 @@ var DEFAULT_COMMAND_STREAM_CONFIG = {
 };
 var DEFAULT_BROADCAST_STREAM_CONFIG = {
   ...baseStreamConfig,
-  retention: import_nats.RetentionPolicy.Limits,
+  retention: import_jetstream.RetentionPolicy.Limits,
   allow_rollup_hdrs: true,
   max_consumers: 200,
   max_msg_size: 10 * MB,
@@ -152,7 +157,7 @@ var DEFAULT_BROADCAST_STREAM_CONFIG = {
 };
 var DEFAULT_ORDERED_STREAM_CONFIG = {
   ...baseStreamConfig,
-  retention: import_nats.RetentionPolicy.Limits,
+  retention: import_jetstream.RetentionPolicy.Limits,
   allow_rollup_hdrs: false,
   max_consumers: 100,
   max_msg_size: 10 * MB,
@@ -166,25 +171,25 @@ var DEFAULT_EVENT_CONSUMER_CONFIG = {
   ack_wait: toNanos(10, "seconds"),
   max_deliver: 3,
   max_ack_pending: 100,
-  ack_policy: import_nats.AckPolicy.Explicit,
-  deliver_policy: import_nats.DeliverPolicy.All,
-  replay_policy: import_nats.ReplayPolicy.Instant
+  ack_policy: import_jetstream.AckPolicy.Explicit,
+  deliver_policy: import_jetstream.DeliverPolicy.All,
+  replay_policy: import_jetstream.ReplayPolicy.Instant
 };
 var DEFAULT_COMMAND_CONSUMER_CONFIG = {
   ack_wait: toNanos(5, "minutes"),
   max_deliver: 1,
   max_ack_pending: 100,
-  ack_policy: import_nats.AckPolicy.Explicit,
-  deliver_policy: import_nats.DeliverPolicy.All,
-  replay_policy: import_nats.ReplayPolicy.Instant
+  ack_policy: import_jetstream.AckPolicy.Explicit,
+  deliver_policy: import_jetstream.DeliverPolicy.All,
+  replay_policy: import_jetstream.ReplayPolicy.Instant
 };
 var DEFAULT_BROADCAST_CONSUMER_CONFIG = {
   ack_wait: toNanos(10, "seconds"),
   max_deliver: 3,
   max_ack_pending: 100,
-  ack_policy: import_nats.AckPolicy.Explicit,
-  deliver_policy: import_nats.DeliverPolicy.All,
-  replay_policy: import_nats.ReplayPolicy.Instant
+  ack_policy: import_jetstream.AckPolicy.Explicit,
+  deliver_policy: import_jetstream.DeliverPolicy.All,
+  replay_policy: import_jetstream.ReplayPolicy.Instant
 };
 var DEFAULT_RPC_TIMEOUT = 3e4;
 var DEFAULT_JETSTREAM_RPC_TIMEOUT = 18e4;
@@ -223,11 +228,12 @@ var isCoreRpcMode = (rpc) => !rpc || rpc.mode === "core";
 
 // src/client/jetstream.record.ts
 var JetstreamRecord = class {
-  constructor(data, headers2, timeout, messageId) {
+  constructor(data, headers2, timeout, messageId, schedule) {
     this.data = data;
     this.headers = headers2;
     this.timeout = timeout;
     this.messageId = messageId;
+    this.schedule = schedule;
   }
 };
 var JetstreamRecordBuilder = class {
@@ -235,6 +241,7 @@ var JetstreamRecordBuilder = class {
   headers = /* @__PURE__ */ new Map();
   timeout;
   messageId;
+  scheduleOptions;
   constructor(data) {
     this.data = data;
   }
@@ -302,17 +309,43 @@ var JetstreamRecordBuilder = class {
     this.timeout = ms;
     return this;
   }
+  /**
+   * Schedule one-shot delayed delivery.
+   *
+   * The message is held by NATS and delivered to the event consumer
+   * at the specified time. Requires NATS >= 2.12 and `allow_msg_schedules: true`
+   * on the event stream (via `events: { stream: { allow_msg_schedules: true } }`).
+   *
+   * Only meaningful for events (`client.emit()`). If used with RPC
+   * (`client.send()`), a warning is logged and the schedule is ignored.
+   *
+   * @param date - Delivery time. Must be in the future.
+   * @throws Error if the date is not in the future.
+   */
+  scheduleAt(date) {
+    const ts = date.getTime();
+    if (Number.isNaN(ts)) {
+      throw new Error("Schedule date is invalid");
+    }
+    if (ts <= Date.now()) {
+      throw new Error("Schedule date must be in the future");
+    }
+    this.scheduleOptions = { at: new Date(ts) };
+    return this;
+  }
   /**
    * Build the immutable {@link JetstreamRecord}.
    *
    * @returns A frozen record ready to pass to `client.send()` or `client.emit()`.
    */
   build() {
+    const schedule = this.scheduleOptions ? { at: new Date(this.scheduleOptions.at.getTime()) } : void 0;
     return new JetstreamRecord(
       this.data,
       new Map(this.headers),
       this.timeout,
-      this.messageId
+      this.messageId,
+      schedule
     );
   }
   /** Validate that a header key is not reserved. */
@@ -364,7 +397,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
       this.setupInbox(nc);
     }
     this.statusSubscription ??= this.connection.status$.subscribe((status) => {
-      if (status.type === import_nats2.Events.Disconnect) {
+      if (status.type === "disconnect") {
         this.handleDisconnect();
       }
     });
@@ -392,19 +425,38 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
    * Publish a fire-and-forget event to JetStream.
    *
    * Events are published to either the workqueue stream or broadcast stream
-   * depending on the subject prefix.
+   * depending on the subject prefix. When a schedule is present the message
+   * is published to a `_sch` subject within the same stream, with the target
+   * set to the original event subject.
    */
   async dispatchEvent(packet) {
     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 this.connection.getJetStreamClient().publish(subject, this.codec.encode(data), {
-      headers: msgHeaders,
-      msgID: messageId ?? crypto.randomUUID()
-    });
-    if (ack.duplicate) {
-      this.logger.warn(`Duplicate event publish detected: ${subject} (seq: ${ack.seq})`);
+    const { data, hdrs, messageId, schedule } = this.extractRecordData(packet.data);
+    const eventSubject = this.buildEventSubject(packet.pattern);
+    const msgHeaders = this.buildHeaders(hdrs, { subject: eventSubject });
+    if (schedule) {
+      const scheduleSubject = this.buildScheduleSubject(eventSubject);
+      const ack = await this.connection.getJetStreamClient().publish(scheduleSubject, this.codec.encode(data), {
+        headers: msgHeaders,
+        msgID: messageId ?? import_nuid.nuid.next(),
+        schedule: {
+          specification: schedule.at,
+          target: eventSubject
+        }
+      });
+      if (ack.duplicate) {
+        this.logger.warn(
+          `Duplicate scheduled publish detected: ${scheduleSubject} (seq: ${ack.seq})`
+        );
+      }
+    } else {
+      const ack = await this.connection.getJetStreamClient().publish(eventSubject, this.codec.encode(data), {
+        headers: msgHeaders,
+        msgID: messageId ?? import_nuid.nuid.next()
+      });
+      if (ack.duplicate) {
+        this.logger.warn(`Duplicate event publish detected: ${eventSubject} (seq: ${ack.seq})`);
+      }
     }
     return void 0;
   }
@@ -416,7 +468,12 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
    */
   publish(packet, callback) {
     const subject = buildSubject(this.targetName, "cmd" /* Command */, packet.pattern);
-    const { data, hdrs, timeout, messageId } = this.extractRecordData(packet.data);
+    const { data, hdrs, timeout, messageId, schedule } = this.extractRecordData(packet.data);
+    if (schedule) {
+      this.logger.warn(
+        "scheduleAt() is ignored for RPC (client.send()). Use client.emit() for scheduled events."
+      );
+    }
     const onUnhandled = (err) => {
       this.logger.error("Unhandled publish error:", err);
       callback({ err: new Error("Internal transport error"), response: null, isDisposed: true });
@@ -425,7 +482,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     if (isCoreRpcMode(this.rootOptions.rpc)) {
       this.publishCoreRpc(subject, data, hdrs, timeout, callback).catch(onUnhandled);
     } else {
-      jetStreamCorrelationId = crypto.randomUUID();
+      jetStreamCorrelationId = import_nuid.nuid.next();
       this.publishJetStreamRpc(subject, data, callback, {
         headers: hdrs,
         timeout,
@@ -500,7 +557,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
       });
       await this.connection.getJetStreamClient().publish(subject, this.codec.encode(data), {
         headers: hdrs,
-        msgID: messageId ?? crypto.randomUUID()
+        msgID: messageId ?? import_nuid.nuid.next()
       });
     } catch (err) {
       const existingTimeout = this.pendingTimeouts.get(correlationId);
@@ -535,7 +592,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   }
   /** Setup shared inbox subscription for JetStream RPC responses. */
   setupInbox(nc) {
-    this.inbox = (0, import_nats2.createInbox)(internalName(this.rootOptions.name));
+    this.inbox = (0, import_transport_node.createInbox)(internalName(this.rootOptions.name));
     this.inboxSubscription = nc.subscribe(this.inbox, {
       callback: (err, msg) => {
         if (err) {
@@ -597,7 +654,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   }
   /** Build NATS headers merging custom headers with transport headers. */
   buildHeaders(customHeaders, transport) {
-    const hdrs = (0, import_nats2.headers)();
+    const hdrs = (0, import_transport_node.headers)();
     hdrs.set("x-subject" /* Subject */, transport.subject);
     hdrs.set("x-caller-name" /* CallerName */, this.callerName);
     if (transport.correlationId) {
@@ -613,17 +670,51 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     }
     return hdrs;
   }
-  /** Extract data, headers, and timeout from raw packet data or JetstreamRecord. */
+  /** Extract data, headers, timeout, and schedule from raw packet data or JetstreamRecord. */
   extractRecordData(rawData) {
     if (rawData instanceof JetstreamRecord) {
       return {
         data: rawData.data,
         hdrs: rawData.headers.size > 0 ? new Map(rawData.headers) : null,
         timeout: rawData.timeout,
-        messageId: rawData.messageId
+        messageId: rawData.messageId,
+        schedule: rawData.schedule
       };
     }
-    return { data: rawData, hdrs: null, timeout: void 0, messageId: void 0 };
+    return {
+      data: rawData,
+      hdrs: null,
+      timeout: void 0,
+      messageId: void 0,
+      schedule: void 0
+    };
+  }
+  /**
+   * Build a schedule-holder subject for NATS message scheduling.
+   *
+   * The schedule-holder subject resides in the same stream as the target but
+   * uses a separate `_sch` namespace that is NOT matched by any consumer filter.
+   * NATS holds the message and publishes it to the target subject after the delay.
+   *
+   * Examples:
+   * - `{svc}__microservice.ev.order.reminder` → `{svc}__microservice._sch.order.reminder`
+   * - `broadcast.config.updated` → `broadcast._sch.config.updated`
+   */
+  buildScheduleSubject(eventSubject) {
+    if (eventSubject.startsWith("broadcast.")) {
+      return eventSubject.replace("broadcast.", "broadcast._sch.");
+    }
+    const targetPrefix = `${internalName(this.targetName)}.`;
+    if (!eventSubject.startsWith(targetPrefix)) {
+      throw new Error(`Unexpected event subject format: ${eventSubject}`);
+    }
+    const withoutPrefix = eventSubject.slice(targetPrefix.length);
+    const dotIndex = withoutPrefix.indexOf(".");
+    if (dotIndex === -1) {
+      throw new Error(`Event subject missing pattern segment: ${eventSubject}`);
+    }
+    const pattern = withoutPrefix.slice(dotIndex + 1);
+    return `${targetPrefix}_sch.${pattern}`;
   }
   getRpcTimeout() {
     if (!this.rootOptions.rpc) return DEFAULT_RPC_TIMEOUT;
@@ -633,20 +724,21 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
 };
 
 // src/codec/json.codec.ts
-var import_nats3 = require("nats");
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
 var JsonCodec = class {
-  inner = (0, import_nats3.JSONCodec)();
   encode(data) {
-    return this.inner.encode(data);
+    return encoder.encode(JSON.stringify(data));
   }
   decode(data) {
-    return this.inner.decode(data);
+    return JSON.parse(decoder.decode(data));
   }
 };
 
 // src/connection/connection.provider.ts
 var import_common2 = require("@nestjs/common");
-var import_nats4 = require("nats");
+var import_transport_node2 = require("@nats-io/transport-node");
+var import_jetstream7 = require("@nats-io/jetstream");
 var import_rxjs = require("rxjs");
 var DEFAULT_OPTIONS = {
   maxReconnectAttempts: -1,
@@ -700,14 +792,7 @@ var ConnectionProvider = class {
   async getJetStreamManager() {
     if (this.jsmInstance) return this.jsmInstance;
     if (this.jsmPromise) return this.jsmPromise;
-    this.jsmPromise = (async () => {
-      const nc = await this.getConnection();
-      this.jsmInstance = await nc.jetstreamManager();
-      this.logger.log("JetStream manager initialized");
-      return this.jsmInstance;
-    })().finally(() => {
-      this.jsmPromise = null;
-    });
+    this.jsmPromise = this.initJetStreamManager();
     return this.jsmPromise;
   }
   /**
@@ -723,7 +808,7 @@ var ConnectionProvider = class {
     if (!this.connection || this.connection.isClosed()) {
       throw new Error("Not connected \u2014 call getConnection() before getJetStreamClient()");
     }
-    this.jsClient ??= this.connection.jetstream();
+    this.jsClient ??= (0, import_jetstream7.jetstream)(this.connection);
     return this.jsClient;
   }
   /** Direct access to the raw NATS connection, or `null` if not yet connected. */
@@ -759,11 +844,21 @@ var ConnectionProvider = class {
       this.jsmPromise = null;
     }
   }
+  async initJetStreamManager() {
+    try {
+      const nc = await this.getConnection();
+      this.jsmInstance = await (0, import_jetstream7.jetstreamManager)(nc);
+      this.logger.log("JetStream manager initialized");
+      return this.jsmInstance;
+    } finally {
+      this.jsmPromise = null;
+    }
+  }
   /** Internal: establish the physical connection with reconnect monitoring. */
   async establish() {
     const name = internalName(this.options.name);
     try {
-      const nc = await (0, import_nats4.connect)({
+      const nc = await (0, import_transport_node2.connect)({
         ...DEFAULT_OPTIONS,
         ...this.options.connectionOptions,
         servers: this.options.servers,
@@ -775,7 +870,7 @@ var ConnectionProvider = class {
       this.monitorStatus(nc);
       return nc;
     } catch (err) {
-      if (err instanceof import_nats4.NatsError && err.code === "CONNECTION_REFUSED") {
+      if (err instanceof Error && err.message.includes("REFUSED")) {
         throw new Error(`NATS connection refused: ${this.options.servers.join(", ")}`);
       }
       throw err;
@@ -783,27 +878,33 @@ var ConnectionProvider = class {
   }
   /** Subscribe to connection status events and emit hooks. */
   monitorStatus(nc) {
-    (async () => {
+    void (async () => {
       for await (const status of nc.status()) {
         switch (status.type) {
-          case import_nats4.Events.Disconnect:
+          case "disconnect":
             this.eventBus.emit("disconnect" /* Disconnect */);
             break;
-          case import_nats4.Events.Reconnect:
+          case "reconnect":
             this.jsClient = null;
             this.jsmInstance = null;
             this.jsmPromise = null;
             this.eventBus.emit("reconnect" /* Reconnect */, nc.getServer());
             break;
-          case import_nats4.Events.Error:
-            this.eventBus.emit("error" /* Error */, new Error(String(status.data)), "connection");
+          case "error":
+            this.eventBus.emit(
+              "error" /* Error */,
+              status.error,
+              "connection"
+            );
             break;
-          case import_nats4.Events.Update:
-          case import_nats4.Events.LDM:
-          case import_nats4.DebugEvents.Reconnecting:
-          case import_nats4.DebugEvents.PingTimer:
-          case import_nats4.DebugEvents.StaleConnection:
-          case import_nats4.DebugEvents.ClientInitiatedReconnect:
+          case "update":
+          case "ldm":
+          case "reconnecting":
+          case "ping":
+          case "staleConnection":
+          case "forceReconnect":
+          case "slowConsumer":
+          case "close":
             break;
         }
       }
@@ -1065,7 +1166,7 @@ var JetstreamStrategy = class extends import_microservices2.Server {
 
 // src/server/core-rpc.server.ts
 var import_common4 = require("@nestjs/common");
-var import_nats5 = require("nats");
+var import_transport_node3 = require("@nats-io/transport-node");
 
 // src/context/rpc.context.ts
 var import_microservices3 = require("@nestjs/microservices");
@@ -1351,7 +1452,7 @@ var CoreRpcServer = class {
   /** Send an error response back to the caller with x-error header. */
   respondWithError(msg, error) {
     try {
-      const hdrs = (0, import_nats5.headers)();
+      const hdrs = (0, import_transport_node3.headers)();
       hdrs.set("x-error" /* Error */, "true");
       msg.respond(this.codec.encode(serializeError(error)), { headers: hdrs });
     } catch {
@@ -1362,7 +1463,7 @@ var CoreRpcServer = class {
 
 // src/server/infrastructure/stream.provider.ts
 var import_common5 = require("@nestjs/common");
-var import_nats6 = require("nats");
+var import_jetstream13 = require("@nats-io/jetstream");
 var STREAM_NOT_FOUND = 10059;
 var StreamProvider = class {
   constructor(options, connection) {
@@ -1388,12 +1489,22 @@ var StreamProvider = class {
   getSubjects(kind) {
     const name = internalName(this.options.name);
     switch (kind) {
-      case "ev" /* Event */:
-        return [`${name}.${"ev" /* Event */}.>`];
+      case "ev" /* Event */: {
+        const subjects = [`${name}.${"ev" /* Event */}.>`];
+        if (this.isSchedulingEnabled(kind)) {
+          subjects.push(`${name}._sch.>`);
+        }
+        return subjects;
+      }
       case "cmd" /* Command */:
         return [`${name}.${"cmd" /* Command */}.>`];
-      case "broadcast" /* Broadcast */:
-        return ["broadcast.>"];
+      case "broadcast" /* Broadcast */: {
+        const subjects = ["broadcast.>"];
+        if (this.isSchedulingEnabled(kind)) {
+          subjects.push("broadcast._sch.>");
+        }
+        return subjects;
+      }
       case "ordered" /* Ordered */:
         return [`${name}.${"ordered" /* Ordered */}.>`];
     }
@@ -1407,7 +1518,7 @@ var StreamProvider = class {
       this.logger.debug(`Stream exists, updating: ${config.name}`);
       return await jsm.streams.update(config.name, config);
     } catch (err) {
-      if (err instanceof import_nats6.NatsError && err.api_error?.err_code === STREAM_NOT_FOUND) {
+      if (err instanceof import_jetstream13.JetStreamApiError && err.apiError().err_code === STREAM_NOT_FOUND) {
         this.logger.log(`Creating stream: ${config.name}`);
         return await jsm.streams.add(config);
       }
@@ -1442,6 +1553,11 @@ var StreamProvider = class {
         return DEFAULT_ORDERED_STREAM_CONFIG;
     }
   }
+  /** Check if scheduling is enabled for a stream kind via `allow_msg_schedules` override. */
+  isSchedulingEnabled(kind) {
+    const overrides = this.getOverrides(kind);
+    return overrides.allow_msg_schedules === true;
+  }
   /** Get user-provided overrides for a stream kind. */
   getOverrides(kind) {
     switch (kind) {
@@ -1459,7 +1575,7 @@ var StreamProvider = class {
 
 // src/server/infrastructure/consumer.provider.ts
 var import_common6 = require("@nestjs/common");
-var import_nats7 = require("nats");
+var import_jetstream15 = require("@nats-io/jetstream");
 var CONSUMER_NOT_FOUND = 10014;
 var ConsumerProvider = class {
   constructor(options, connection, streamProvider, patternRegistry) {
@@ -1500,7 +1616,7 @@ var ConsumerProvider = class {
       this.logger.debug(`Consumer exists, updating: ${name}`);
       return await jsm.consumers.update(stream, name, config);
     } catch (err) {
-      if (err instanceof import_nats7.NatsError && err.api_error?.err_code === CONSUMER_NOT_FOUND) {
+      if (err instanceof import_jetstream15.JetStreamApiError && err.apiError().err_code === CONSUMER_NOT_FOUND) {
         this.logger.log(`Creating consumer: ${name}`);
         return await jsm.consumers.add(stream, config);
       }
@@ -1559,6 +1675,10 @@ var ConsumerProvider = class {
         return DEFAULT_BROADCAST_CONSUMER_CONFIG;
       case "ordered" /* Ordered */:
         throw new Error("Ordered consumers are ephemeral and should not use durable config");
+      default: {
+        const _exhaustive = kind;
+        throw new Error(`Unexpected StreamKind: ${_exhaustive}`);
+      }
     }
   }
   /** Get user-provided overrides for a consumer kind. */
@@ -1572,13 +1692,17 @@ var ConsumerProvider = class {
         return this.options.broadcast?.consumer ?? {};
       case "ordered" /* Ordered */:
         throw new Error("Ordered consumers are ephemeral and should not use durable config");
+      default: {
+        const _exhaustive = kind;
+        throw new Error(`Unexpected StreamKind: ${_exhaustive}`);
+      }
     }
   }
 };
 
 // src/server/infrastructure/message.provider.ts
 var import_common7 = require("@nestjs/common");
-var import_nats8 = require("nats");
+var import_jetstream17 = require("@nats-io/jetstream");
 var import_rxjs3 = require("rxjs");
 var MessageProvider = class {
   constructor(connection, eventBus, consumeOptionsMap = /* @__PURE__ */ new Map()) {
@@ -1637,8 +1761,8 @@ var MessageProvider = class {
    * @param orderedConfig - Optional overrides for ordered consumer options.
    */
   async startOrdered(streamName2, filterSubjects, orderedConfig) {
-    const consumerOpts = { filterSubjects };
-    if (orderedConfig?.deliverPolicy !== void 0 && orderedConfig.deliverPolicy !== import_nats8.DeliverPolicy.All) {
+    const consumerOpts = { filter_subjects: filterSubjects };
+    if (orderedConfig?.deliverPolicy !== void 0 && orderedConfig.deliverPolicy !== import_jetstream17.DeliverPolicy.All) {
       consumerOpts.deliver_policy = orderedConfig.deliverPolicy;
     }
     if (orderedConfig?.optStartSeq !== void 0) {
@@ -1722,10 +1846,10 @@ var MessageProvider = class {
   }
   /** 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 === import_nats8.ConsumerEvents.HeartbeatsMissed && status.data >= 2) {
-          this.logger.warn(`Consumer ${name}: ${status.data} heartbeats missed, restarting`);
+    void (async () => {
+      for await (const status of messages.status()) {
+        if (status.type === "heartbeats_missed" && status.count >= 2) {
+          this.logger.warn(`Consumer ${name}: ${status.count} heartbeats missed, restarting`);
           messages.stop();
           break;
         }
@@ -2105,7 +2229,7 @@ var EventRouter = class {
 
 // src/server/routing/rpc.router.ts
 var import_common10 = require("@nestjs/common");
-var import_nats9 = require("nats");
+var import_transport_node4 = require("@nats-io/transport-node");
 var import_rxjs5 = require("rxjs");
 var RpcRouter = class {
   constructor(messageProvider, patternRegistry, connection, codec, eventBus, rpcOptions, ackWaitMap) {
@@ -2197,7 +2321,7 @@ var RpcRouter = class {
       stopAckExtension?.();
       msg.ack();
       try {
-        const hdrs = (0, import_nats9.headers)();
+        const hdrs = (0, import_transport_node4.headers)();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
         nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
       } catch (publishErr) {
@@ -2209,7 +2333,7 @@ var RpcRouter = class {
       clearTimeout(timeoutId);
       stopAckExtension?.();
       try {
-        const hdrs = (0, import_nats9.headers)();
+        const hdrs = (0, import_transport_node4.headers)();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
         hdrs.set("x-error" /* Error */, "true");
         nc.publish(replyTo, this.codec.encode(serializeError(err)), { headers: hdrs });
@@ -2659,8 +2783,12 @@ JetstreamModule = __decorateClass([
   RpcContext,
   StreamKind,
   TransportEvent,
+  buildSubject,
+  consumerName,
   getClientToken,
+  internalName,
   isCoreRpcMode,
   isJetStreamRpcMode,
+  streamName,
   toNanos
 });