@horizon-republic/nestjs-jetstream 2.2.0 → 2.3.0

package/dist/index.cjs

@@ -0,0 +1,2015 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from4, except, desc) => {
+  if (from4 && typeof from4 === "object" || typeof from4 === "function") {
+    for (let key of __getOwnPropNames(from4))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from4[key], enumerable: !(desc = __getOwnPropDesc(from4, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EventBus: () => EventBus,
+  JETSTREAM_CODEC: () => JETSTREAM_CODEC,
+  JETSTREAM_CONNECTION: () => JETSTREAM_CONNECTION,
+  JETSTREAM_EVENT_BUS: () => JETSTREAM_EVENT_BUS,
+  JETSTREAM_OPTIONS: () => JETSTREAM_OPTIONS,
+  JetstreamClient: () => JetstreamClient,
+  JetstreamHeader: () => JetstreamHeader,
+  JetstreamHealthIndicator: () => JetstreamHealthIndicator,
+  JetstreamModule: () => JetstreamModule,
+  JetstreamRecord: () => JetstreamRecord,
+  JetstreamRecordBuilder: () => JetstreamRecordBuilder,
+  JetstreamStrategy: () => JetstreamStrategy,
+  JsonCodec: () => JsonCodec,
+  RpcContext: () => RpcContext,
+  TransportEvent: () => TransportEvent,
+  getClientToken: () => getClientToken,
+  nanos: () => nanos
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/jetstream.module.ts
+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");
+
+// src/interfaces/hooks.interface.ts
+var TransportEvent = /* @__PURE__ */ ((TransportEvent2) => {
+  TransportEvent2["Connect"] = "connect";
+  TransportEvent2["Disconnect"] = "disconnect";
+  TransportEvent2["Reconnect"] = "reconnect";
+  TransportEvent2["Error"] = "error";
+  TransportEvent2["RpcTimeout"] = "rpcTimeout";
+  TransportEvent2["MessageRouted"] = "messageRouted";
+  TransportEvent2["ShutdownStart"] = "shutdownStart";
+  TransportEvent2["ShutdownComplete"] = "shutdownComplete";
+  TransportEvent2["DeadLetter"] = "deadLetter";
+  return TransportEvent2;
+})(TransportEvent || {});
+
+// src/jetstream.constants.ts
+var import_nats = require("nats");
+var JETSTREAM_OPTIONS = /* @__PURE__ */ Symbol("JETSTREAM_OPTIONS");
+var JETSTREAM_CONNECTION = /* @__PURE__ */ Symbol("JETSTREAM_CONNECTION");
+var JETSTREAM_CODEC = /* @__PURE__ */ Symbol("JETSTREAM_CODEC");
+var JETSTREAM_EVENT_BUS = /* @__PURE__ */ Symbol("JETSTREAM_EVENT_BUS");
+var getClientToken = (name) => name;
+var KB = 1024;
+var MB = 1024 * KB;
+var GB = 1024 * MB;
+var nanos = (ms) => ms * 1e6;
+var baseStreamConfig = {
+  retention: import_nats.RetentionPolicy.Workqueue,
+  storage: import_nats.StorageType.File,
+  num_replicas: 1,
+  discard: import_nats.DiscardPolicy.Old,
+  allow_direct: true,
+  compression: import_nats.StoreCompression.None
+};
+var DEFAULT_EVENT_STREAM_CONFIG = {
+  ...baseStreamConfig,
+  allow_rollup_hdrs: true,
+  max_consumers: 100,
+  max_msg_size: 10 * MB,
+  max_msgs_per_subject: 5e6,
+  max_msgs: 5e7,
+  max_bytes: 5 * GB,
+  max_age: nanos(7 * 24 * 60 * 60 * 1e3),
+  // 7 days
+  duplicate_window: nanos(2 * 60 * 1e3)
+  // 2 min
+};
+var DEFAULT_COMMAND_STREAM_CONFIG = {
+  ...baseStreamConfig,
+  allow_rollup_hdrs: false,
+  max_consumers: 50,
+  max_msg_size: 5 * MB,
+  max_msgs_per_subject: 1e5,
+  max_msgs: 1e6,
+  max_bytes: 100 * MB,
+  max_age: nanos(3 * 60 * 1e3),
+  // 3 min
+  duplicate_window: nanos(30 * 1e3)
+  // 30s
+};
+var DEFAULT_BROADCAST_STREAM_CONFIG = {
+  ...baseStreamConfig,
+  retention: import_nats.RetentionPolicy.Limits,
+  allow_rollup_hdrs: true,
+  max_consumers: 200,
+  max_msg_size: 10 * MB,
+  max_msgs_per_subject: 1e6,
+  max_msgs: 1e7,
+  max_bytes: 2 * GB,
+  max_age: nanos(24 * 60 * 60 * 1e3),
+  // 1 day
+  duplicate_window: nanos(2 * 60 * 1e3)
+  // 2 min
+};
+var DEFAULT_EVENT_CONSUMER_CONFIG = {
+  ack_wait: nanos(10 * 1e3),
+  // 10s
+  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
+};
+var DEFAULT_COMMAND_CONSUMER_CONFIG = {
+  ack_wait: nanos(5 * 60 * 1e3),
+  // 5 min
+  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
+};
+var DEFAULT_BROADCAST_CONSUMER_CONFIG = {
+  ack_wait: nanos(10 * 1e3),
+  // 10s
+  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
+};
+var DEFAULT_RPC_TIMEOUT = 3e4;
+var DEFAULT_JETSTREAM_RPC_TIMEOUT = 18e4;
+var DEFAULT_SHUTDOWN_TIMEOUT = 1e4;
+var JetstreamHeader = /* @__PURE__ */ ((JetstreamHeader2) => {
+  JetstreamHeader2["CorrelationId"] = "x-correlation-id";
+  JetstreamHeader2["ReplyTo"] = "x-reply-to";
+  JetstreamHeader2["Subject"] = "x-subject";
+  JetstreamHeader2["CallerName"] = "x-caller-name";
+  JetstreamHeader2["RequestId"] = "x-request-id";
+  JetstreamHeader2["TraceId"] = "x-trace-id";
+  JetstreamHeader2["SpanId"] = "x-span-id";
+  JetstreamHeader2["Error"] = "x-error";
+  return JetstreamHeader2;
+})(JetstreamHeader || {});
+var RESERVED_HEADERS = /* @__PURE__ */ new Set([
+  "x-correlation-id" /* CorrelationId */,
+  "x-reply-to" /* ReplyTo */,
+  "x-error" /* Error */
+]);
+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";
+  return `${internalName(serviceName)}_${kind}-stream`;
+};
+var consumerName = (serviceName, kind) => {
+  if (kind === "broadcast") return `${internalName(serviceName)}_broadcast-consumer`;
+  return `${internalName(serviceName)}_${kind}-consumer`;
+};
+
+// src/client/jetstream.record.ts
+var JetstreamRecord = class {
+  constructor(data, headers2, timeout) {
+    this.data = data;
+    this.headers = headers2;
+    this.timeout = timeout;
+  }
+};
+var JetstreamRecordBuilder = class {
+  data;
+  headers = /* @__PURE__ */ new Map();
+  timeout;
+  constructor(data) {
+    this.data = data;
+  }
+  /** Set the message payload. */
+  setData(data) {
+    this.data = data;
+    return this;
+  }
+  /**
+   * Set a single custom header.
+   *
+   * @throws Error if the header name is reserved by the transport.
+   */
+  setHeader(key, value) {
+    this.validateHeaderKey(key);
+    this.headers.set(key, value);
+    return this;
+  }
+  /**
+   * Set multiple custom headers at once.
+   *
+   * @throws Error if any header name is reserved by the transport.
+   */
+  setHeaders(headers2) {
+    for (const [key, value] of Object.entries(headers2)) {
+      this.setHeader(key, value);
+    }
+    return this;
+  }
+  /** Set RPC request timeout in milliseconds. */
+  setTimeout(ms) {
+    this.timeout = ms;
+    return this;
+  }
+  /** Build the immutable JetstreamRecord. */
+  build() {
+    return new JetstreamRecord(this.data, new Map(this.headers), this.timeout);
+  }
+  /** Validate that a header key is not reserved. */
+  validateHeaderKey(key) {
+    if (RESERVED_HEADERS.has(key)) {
+      throw new Error(
+        `Header "${key}" is reserved by the JetStream transport and cannot be set manually. Reserved headers: ${[...RESERVED_HEADERS].join(", ")}`
+      );
+    }
+  }
+};
+
+// src/client/jetstream.client.ts
+var JetstreamClient = class extends import_microservices.ClientProxy {
+  constructor(rootOptions, targetServiceName, connection, codec, eventBus) {
+    super();
+    this.rootOptions = rootOptions;
+    this.connection = connection;
+    this.codec = codec;
+    this.eventBus = eventBus;
+    this.targetName = targetServiceName;
+  }
+  logger = new import_common.Logger("Jetstream:Client");
+  /** Target service name this client sends messages to. */
+  targetName;
+  /** Shared inbox for JetStream-mode RPC responses. */
+  inbox = null;
+  inboxSubscription = null;
+  /** Pending JetStream-mode RPC callbacks, keyed by correlation ID. */
+  pendingMessages = /* @__PURE__ */ new Map();
+  /** Pending JetStream-mode RPC timeouts, keyed by correlation ID. */
+  pendingTimeouts = /* @__PURE__ */ new Map();
+  /** Subscription to connection status events for disconnect handling. */
+  statusSubscription = null;
+  /** Establish connection. Called automatically by NestJS on first use. */
+  async connect() {
+    const nc = await this.connection.getConnection();
+    if (this.isJetStreamRpcMode() && !this.inboxSubscription) {
+      this.setupInbox(nc);
+    }
+    this.statusSubscription ??= this.connection.status$.subscribe((status) => {
+      if (status.type === import_nats2.Events.Disconnect) {
+        this.handleDisconnect();
+      }
+    });
+    return nc;
+  }
+  /** Clean up resources. */
+  async close() {
+    this.statusSubscription?.unsubscribe();
+    this.statusSubscription = null;
+    this.rejectPendingRpcs(new Error("Client closed"));
+  }
+  /** Direct access to the raw NATS connection. */
+  unwrap() {
+    return this.connection.unwrap;
+  }
+  /**
+   * Publish a fire-and-forget event to JetStream.
+   *
+   * Events are published to either the workqueue stream or broadcast stream
+   * depending on the subject prefix.
+   */
+  async dispatchEvent(packet) {
+    const nc = await this.connect();
+    const { data, hdrs } = this.extractRecordData(packet.data);
+    const subject = this.buildEventSubject(packet.pattern);
+    const msgHeaders = this.buildHeaders(hdrs, { subject });
+    await nc.jetstream().publish(subject, this.codec.encode(data), {
+      headers: msgHeaders,
+      msgID: crypto.randomUUID()
+    });
+    return void 0;
+  }
+  /**
+   * Publish an RPC command and register callback for response.
+   *
+   * Core mode: uses nc.request() with timeout.
+   * JetStream mode: publishes to stream + waits for inbox response.
+   */
+  publish(packet, callback) {
+    const subject = buildSubject(this.targetName, "cmd", packet.pattern);
+    const { data, hdrs, timeout } = 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()) {
+      this.publishCoreRpc(subject, data, hdrs, timeout, callback).catch(onUnhandled);
+    } else {
+      jetStreamCorrelationId = crypto.randomUUID();
+      this.publishJetStreamRpc(
+        subject,
+        data,
+        hdrs,
+        timeout,
+        callback,
+        jetStreamCorrelationId
+      ).catch(onUnhandled);
+    }
+    return () => {
+      if (jetStreamCorrelationId) {
+        const timeoutId = this.pendingTimeouts.get(jetStreamCorrelationId);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          this.pendingTimeouts.delete(jetStreamCorrelationId);
+        }
+        this.pendingMessages.delete(jetStreamCorrelationId);
+      }
+    };
+  }
+  /** 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 hdrs = this.buildHeaders(customHeaders, { subject });
+      const response = await nc.request(subject, this.codec.encode(data), {
+        timeout: effectiveTimeout,
+        headers: hdrs
+      });
+      const decoded = this.codec.decode(response.data);
+      if (response.headers?.get("x-error" /* Error */)) {
+        callback({ err: decoded, response: null, isDisposed: true });
+      } else {
+        callback({ err: null, response: decoded, isDisposed: true });
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error");
+      this.logger.error(`Core RPC error (${subject}):`, err);
+      this.eventBus.emit("error" /* Error */, error, "client-rpc");
+      callback({ err: error, response: null, isDisposed: true });
+    }
+  }
+  /** JetStream mode: publish to stream + wait for inbox response. */
+  async publishJetStreamRpc(subject, data, customHeaders, timeout, callback, correlationId = crypto.randomUUID()) {
+    const effectiveTimeout = 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();
+      if (!this.inbox) {
+        throw new Error("Inbox not initialized \u2014 JetStream RPC mode requires a connected inbox");
+      }
+      const hdrs = this.buildHeaders(customHeaders, {
+        subject,
+        correlationId,
+        replyTo: this.inbox
+      });
+      await nc.jetstream().publish(subject, this.codec.encode(data), {
+        headers: hdrs,
+        msgID: crypto.randomUUID()
+      });
+    } catch (err) {
+      clearTimeout(timeoutId);
+      this.pendingTimeouts.delete(correlationId);
+      if (!this.pendingMessages.has(correlationId)) return;
+      this.pendingMessages.delete(correlationId);
+      const error = err instanceof Error ? err : new Error("Unknown error");
+      this.logger.error(`JetStream RPC publish error (${subject}):`, err);
+      callback({ err: error, response: null, isDisposed: true });
+    }
+  }
+  /** Fail-fast all pending JetStream RPC callbacks on connection loss. */
+  handleDisconnect() {
+    this.rejectPendingRpcs(new Error("Connection lost"));
+    this.inbox = null;
+  }
+  /** Reject all pending RPC callbacks, clear timeouts, and tear down inbox. */
+  rejectPendingRpcs(error) {
+    for (const callback of this.pendingMessages.values()) {
+      callback({ err: error, response: null, isDisposed: true });
+    }
+    for (const timeoutId of this.pendingTimeouts.values()) {
+      clearTimeout(timeoutId);
+    }
+    this.pendingMessages.clear();
+    this.pendingTimeouts.clear();
+    this.inboxSubscription?.unsubscribe();
+    this.inboxSubscription = null;
+  }
+  /** Setup shared inbox subscription for JetStream RPC responses. */
+  setupInbox(nc) {
+    this.inbox = (0, import_nats2.createInbox)(internalName(this.rootOptions.name));
+    this.inboxSubscription = nc.subscribe(this.inbox, {
+      callback: (err, msg) => {
+        if (err) {
+          this.logger.error("Inbox subscription error:", err);
+          return;
+        }
+        this.routeInboxReply(msg);
+      }
+    });
+    this.logger.debug(`Inbox subscription: ${this.inbox}`);
+  }
+  /** Route an inbox reply to the matching pending callback. */
+  routeInboxReply(msg) {
+    const correlationId = msg.headers?.get("x-correlation-id" /* CorrelationId */);
+    if (!correlationId) {
+      this.logger.warn("Inbox reply without correlation-id, ignoring");
+      return;
+    }
+    const callback = this.pendingMessages.get(correlationId);
+    if (!callback) {
+      this.logger.warn(`No pending handler for correlation-id: ${correlationId}`);
+      return;
+    }
+    const timeoutId = this.pendingTimeouts.get(correlationId);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      this.pendingTimeouts.delete(correlationId);
+    }
+    try {
+      const decoded = this.codec.decode(msg.data);
+      if (msg.headers?.get("x-error" /* Error */)) {
+        callback({ err: decoded, response: null, isDisposed: true });
+      } else {
+        callback({ err: null, response: decoded, isDisposed: true });
+      }
+    } catch (err) {
+      callback({
+        err: err instanceof Error ? err : new Error("Decode error"),
+        response: null,
+        isDisposed: true
+      });
+    } finally {
+      this.pendingMessages.delete(correlationId);
+    }
+  }
+  /** Build event subject — workqueue or broadcast. */
+  buildEventSubject(pattern) {
+    if (pattern.startsWith("broadcast:")) {
+      return buildBroadcastSubject(pattern.slice("broadcast:".length));
+    }
+    return buildSubject(this.targetName, "ev", pattern);
+  }
+  /** Build NATS headers merging custom headers with transport headers. */
+  buildHeaders(customHeaders, transport) {
+    const hdrs = (0, import_nats2.headers)();
+    hdrs.set("x-subject" /* Subject */, transport.subject);
+    hdrs.set("x-caller-name" /* CallerName */, internalName(this.rootOptions.name));
+    if (transport.correlationId) {
+      hdrs.set("x-correlation-id" /* CorrelationId */, transport.correlationId);
+    }
+    if (transport.replyTo) {
+      hdrs.set("x-reply-to" /* ReplyTo */, transport.replyTo);
+    }
+    if (customHeaders) {
+      for (const [key, value] of customHeaders) {
+        hdrs.set(key, value);
+      }
+    }
+    return hdrs;
+  }
+  /** Extract data, headers, and timeout 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
+      };
+    }
+    return { data: rawData, hdrs: null, timeout: 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;
+    return this.rootOptions.rpc.timeout ?? defaultTimeout;
+  }
+};
+
+// src/codec/json.codec.ts
+var import_nats3 = require("nats");
+var JsonCodec = class {
+  inner = (0, import_nats3.JSONCodec)();
+  encode(data) {
+    return this.inner.encode(data);
+  }
+  decode(data) {
+    return this.inner.decode(data);
+  }
+};
+
+// src/connection/connection.provider.ts
+var import_common2 = require("@nestjs/common");
+var import_nats4 = require("nats");
+var import_rxjs = require("rxjs");
+var ConnectionProvider = class {
+  constructor(options, eventBus) {
+    this.options = options;
+    this.eventBus = eventBus;
+    this.nc$ = (0, import_rxjs.defer)(() => this.getConnection()).pipe(
+      (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: false })
+    );
+    this.status$ = this.nc$.pipe(
+      (0, import_rxjs.switchMap)((nc) => (0, import_rxjs.from)(nc.status())),
+      (0, import_rxjs.share)()
+    );
+  }
+  /** Cached observable that replays the established connection to new subscribers. */
+  nc$;
+  /** Live stream of connection status events (no replay). */
+  status$;
+  logger = new import_common2.Logger("Jetstream:Connection");
+  connection = null;
+  connectionPromise = null;
+  jsmInstance = null;
+  /**
+   * Establish NATS connection. Idempotent — returns cached connection on subsequent calls.
+   *
+   * @throws Error if connection is refused (fail fast).
+   */
+  async getConnection() {
+    if (this.connection && !this.connection.isClosed()) {
+      return this.connection;
+    }
+    if (this.connectionPromise) {
+      return this.connectionPromise;
+    }
+    this.connectionPromise = this.establish();
+    return this.connectionPromise;
+  }
+  /**
+   * Get JetStream manager. Cached after first call.
+   */
+  async getJetStreamManager() {
+    if (this.jsmInstance) return this.jsmInstance;
+    const nc = await this.getConnection();
+    this.jsmInstance = await nc.jetstreamManager();
+    this.logger.log("JetStream manager initialized");
+    return this.jsmInstance;
+  }
+  /** Direct access to the raw NATS connection (assumes already connected). */
+  get unwrap() {
+    return this.connection;
+  }
+  /**
+   * Gracefully shut down the connection.
+   *
+   * Sequence: drain → wait for close. Falls back to force-close on error.
+   */
+  async shutdown() {
+    if (!this.connection || this.connection.isClosed()) return;
+    try {
+      await this.connection.drain();
+      await this.connection.closed();
+    } catch {
+      try {
+        await this.connection.close();
+      } catch {
+      }
+    } finally {
+      this.connection = null;
+      this.connectionPromise = null;
+      this.jsmInstance = 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)({
+        ...this.options.connectionOptions,
+        servers: this.options.servers,
+        name
+      });
+      this.connection = nc;
+      this.logger.log(`NATS connection established: ${nc.getServer()}`);
+      this.eventBus.emit("connect" /* Connect */, nc.getServer());
+      this.monitorStatus(nc);
+      return nc;
+    } catch (err) {
+      const natsErr = err;
+      if (natsErr.code === "CONNECTION_REFUSED") {
+        throw new Error(`NATS connection refused: ${this.options.servers.join(", ")}`);
+      }
+      throw err;
+    }
+  }
+  /** Subscribe to connection status events and emit hooks. */
+  monitorStatus(nc) {
+    (async () => {
+      for await (const status of nc.status()) {
+        switch (status.type) {
+          case import_nats4.Events.Disconnect:
+            this.eventBus.emit("disconnect" /* Disconnect */);
+            break;
+          case import_nats4.Events.Reconnect:
+            this.jsmInstance = 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");
+            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:
+            break;
+        }
+      }
+    })().catch((err) => {
+      this.logger.error("Status monitor error", err);
+    });
+  }
+};
+
+// src/hooks/event-bus.ts
+var EventBus = class {
+  hooks;
+  logger;
+  constructor(logger, hooks) {
+    this.logger = logger;
+    this.hooks = hooks ?? {};
+  }
+  /** Emit a lifecycle event. Dispatches to custom hook or Logger fallback. */
+  emit(event, ...args) {
+    const hook = this.hooks[event];
+    if (hook) {
+      try {
+        hook(...args);
+      } catch (err) {
+        this.logger.error(
+          `Hook "${event}" threw an error: ${err instanceof Error ? err.message : err}`
+        );
+      }
+      return;
+    }
+    this.defaultHandler(event, args);
+  }
+  /** Default Logger-based handlers for each event type. */
+  defaultHandler(event, args) {
+    switch (event) {
+      case "connect" /* Connect */:
+        this.logger.log(`Connected to NATS: ${args[0]}`);
+        break;
+      case "disconnect" /* Disconnect */:
+        this.logger.warn("NATS connection lost");
+        break;
+      case "reconnect" /* Reconnect */:
+        this.logger.log(`Reconnected to NATS: ${args[0]}`);
+        break;
+      case "error" /* Error */:
+        this.logger.error(`Transport error: ${args[0]}`, args[1] ?? "");
+        break;
+      case "rpcTimeout" /* RpcTimeout */:
+        this.logger.warn(`RPC timeout: ${args[0]} (cid: ${args[1]})`);
+        break;
+      case "messageRouted" /* MessageRouted */:
+        this.logger.debug(`Message routed: ${args[0]} [${args[1]}]`);
+        break;
+      case "shutdownStart" /* ShutdownStart */:
+        this.logger.log("Graceful shutdown initiated");
+        break;
+      case "shutdownComplete" /* ShutdownComplete */:
+        this.logger.log("Graceful shutdown complete");
+        break;
+      case "deadLetter" /* DeadLetter */: {
+        const info = args[0];
+        this.logger.warn(`Dead letter: ${info?.subject ?? "unknown"}`);
+        break;
+      }
+    }
+  }
+};
+
+// src/health/jetstream.health-indicator.ts
+var import_common3 = require("@nestjs/common");
+var JetstreamHealthIndicator = class {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  logger = new import_common3.Logger("Jetstream:Health");
+  /**
+   * Plain health status check.
+   *
+   * Returns the current connection status without throwing.
+   * Use this for custom health endpoints or monitoring integrations.
+   */
+  async check() {
+    const nc = this.connection.unwrap;
+    if (!nc || nc.isClosed()) {
+      return { connected: false, server: null, latency: null };
+    }
+    try {
+      const start = performance.now();
+      await nc.rtt();
+      const latency = Math.round(performance.now() - start);
+      return { connected: true, server: nc.getServer(), latency };
+    } catch (err) {
+      this.logger.warn(`Health check failed: ${err instanceof Error ? err.message : err}`);
+      return { connected: false, server: nc.getServer(), latency: null };
+    }
+  }
+  /**
+   * Terminus-compatible health check.
+   *
+   * Returns `{ [key]: { status: 'up', ... } }` on success.
+   * Throws an error with `{ [key]: { status: 'down', ... } }` on failure.
+   *
+   * @param key Health indicator key (default: 'jetstream')
+   */
+  async isHealthy(key = "jetstream") {
+    const status = await this.check();
+    const details = {
+      status: status.connected ? "up" : "down",
+      server: status.server,
+      latency: status.latency
+    };
+    if (!status.connected) {
+      throw Object.assign(new Error("Jetstream health check failed"), {
+        [key]: details
+      });
+    }
+    return { [key]: details };
+  }
+};
+JetstreamHealthIndicator = __decorateClass([
+  (0, import_common3.Injectable)()
+], JetstreamHealthIndicator);
+
+// src/server/strategy.ts
+var import_microservices2 = require("@nestjs/microservices");
+var JetstreamStrategy = class extends import_microservices2.Server {
+  constructor(options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer) {
+    super();
+    this.options = options;
+    this.connection = connection;
+    this.patternRegistry = patternRegistry;
+    this.streamProvider = streamProvider;
+    this.consumerProvider = consumerProvider;
+    this.messageProvider = messageProvider;
+    this.eventRouter = eventRouter;
+    this.rpcRouter = rpcRouter;
+    this.coreRpcServer = coreRpcServer;
+  }
+  transportId = /* @__PURE__ */ Symbol("jetstream-transport");
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Start the transport: register handlers, create infrastructure, begin consumption.
+   *
+   * Called by NestJS when `connectMicroservice()` is used, or internally by the module.
+   */
+  async listen(callback) {
+    this.patternRegistry.registerHandlers(this.getHandlers());
+    const streamKinds = this.resolveStreamKinds();
+    if (streamKinds.length > 0) {
+      await this.streamProvider.ensureStreams(streamKinds);
+      const consumers = await this.consumerProvider.ensureConsumers(streamKinds);
+      this.messageProvider.start(consumers);
+      if (this.patternRegistry.hasEventHandlers() || this.patternRegistry.hasBroadcastHandlers()) {
+        this.eventRouter.start();
+      }
+      if (this.isJetStreamRpcMode() && this.patternRegistry.hasRpcHandlers()) {
+        this.rpcRouter.start();
+      }
+    }
+    if (this.isCoreRpcMode() && this.patternRegistry.hasRpcHandlers()) {
+      await this.coreRpcServer.start();
+    }
+    callback();
+  }
+  /** Gracefully stop the transport. */
+  close() {
+    this.eventRouter.destroy();
+    this.rpcRouter.destroy();
+    this.coreRpcServer.stop();
+    this.messageProvider.destroy();
+  }
+  /**
+   * Register event listener (required by Server base class).
+   *
+   * Stores callbacks for potential use. Primary lifecycle events
+   * are routed through EventBus.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  on(event, callback) {
+    const existing = this.listeners.get(event) ?? [];
+    existing.push(callback);
+    this.listeners.set(event, existing);
+  }
+  /** Unwrap the underlying NATS connection. */
+  unwrap() {
+    return this.connection.unwrap;
+  }
+  /** Access the pattern registry (for module-level introspection). */
+  getPatternRegistry() {
+    return this.patternRegistry;
+  }
+  /** Determine which JetStream stream kinds are needed. */
+  resolveStreamKinds() {
+    const kinds = [];
+    if (this.patternRegistry.hasEventHandlers()) {
+      kinds.push("ev");
+    }
+    if (this.isJetStreamRpcMode() && this.patternRegistry.hasRpcHandlers()) {
+      kinds.push("cmd");
+    }
+    if (this.patternRegistry.hasBroadcastHandlers()) {
+      kinds.push("broadcast");
+    }
+    return kinds;
+  }
+  isCoreRpcMode() {
+    return !this.options.rpc || this.options.rpc.mode === "core";
+  }
+  isJetStreamRpcMode() {
+    return this.options.rpc?.mode === "jetstream";
+  }
+};
+
+// src/server/core-rpc.server.ts
+var import_common4 = require("@nestjs/common");
+var import_nats5 = require("nats");
+
+// src/context/rpc.context.ts
+var import_microservices3 = require("@nestjs/microservices");
+var RpcContext = class extends import_microservices3.BaseRpcContext {
+  /** Get the underlying NATS message (JsMsg for JetStream, Msg for Core). */
+  getMessage() {
+    return this.args[0];
+  }
+  /** Get the NATS subject this message was published to. */
+  getSubject() {
+    return this.args[0].subject;
+  }
+  /** Get all NATS message headers, or undefined if none are present. */
+  getHeaders() {
+    return this.args[0].headers;
+  }
+  /** Get a single header value by key. Returns undefined if the header or headers object is missing. */
+  getHeader(key) {
+    return this.args[0].headers?.get(key);
+  }
+  /** Type guard: narrows getMessage() return type to JsMsg when true. */
+  isJetStream() {
+    return "ack" in this.args[0];
+  }
+};
+
+// src/utils/serialize-error.ts
+var import_microservices4 = require("@nestjs/microservices");
+var serializeError = (err) => {
+  if (err instanceof import_microservices4.RpcException) return err.getError();
+  if (err instanceof Error) return { message: err.message };
+  return err;
+};
+
+// src/utils/unwrap-result.ts
+var import_rxjs2 = require("rxjs");
+var unwrapResult = async (result) => {
+  if ((0, import_rxjs2.isObservable)(result)) {
+    return subscribeToFirst(result);
+  }
+  const resolved = await result;
+  if ((0, import_rxjs2.isObservable)(resolved)) {
+    return subscribeToFirst(resolved);
+  }
+  return resolved;
+};
+var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
+  let done = false;
+  obs.subscribe({
+    next: (val) => {
+      if (!done) {
+        done = true;
+        resolve(val);
+      }
+    },
+    error: reject,
+    complete: () => {
+      if (!done) resolve(void 0);
+    }
+  });
+});
+
+// src/server/core-rpc.server.ts
+var CoreRpcServer = class {
+  constructor(options, connection, patternRegistry, codec, eventBus) {
+    this.options = options;
+    this.connection = connection;
+    this.patternRegistry = patternRegistry;
+    this.codec = codec;
+    this.eventBus = eventBus;
+  }
+  logger = new import_common4.Logger("Jetstream:CoreRpc");
+  subscription = null;
+  /** Start listening for RPC requests on the command subject. */
+  async start() {
+    const nc = await this.connection.getConnection();
+    const serviceName = internalName(this.options.name);
+    const subject = `${serviceName}.cmd.>`;
+    const queue = `${serviceName}_cmd_queue`;
+    this.subscription = nc.subscribe(subject, {
+      queue,
+      callback: (err, msg) => {
+        if (err) {
+          this.logger.error("Core RPC subscription error:", err);
+          return;
+        }
+        this.handleRequest(msg).catch((err2) => {
+          this.logger.error("Unhandled request error:", err2);
+        });
+      }
+    });
+    this.logger.log(`Core RPC listening: ${subject} (queue: ${queue})`);
+  }
+  /** Stop listening and clean up the subscription. */
+  stop() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+  }
+  /** Handle an incoming Core NATS request. */
+  async handleRequest(msg) {
+    const handler = this.patternRegistry.getHandler(msg.subject);
+    if (!handler) {
+      this.logger.warn(`No handler for Core RPC: ${msg.subject}`);
+      return;
+    }
+    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "rpc");
+    let data;
+    try {
+      data = this.codec.decode(msg.data);
+    } catch (err) {
+      this.logger.error(`Decode error for Core RPC ${msg.subject}:`, err);
+      this.respondWithError(msg, err);
+      return;
+    }
+    const ctx = new RpcContext([msg]);
+    try {
+      const result = await unwrapResult(handler(data, ctx));
+      msg.respond(this.codec.encode(result));
+    } catch (err) {
+      this.logger.error(`Handler error for Core RPC ${msg.subject}:`, err);
+      this.respondWithError(msg, err);
+    }
+  }
+  /** Send an error response back to the caller with x-error header. */
+  respondWithError(msg, error) {
+    try {
+      const hdrs = (0, import_nats5.headers)();
+      hdrs.set("x-error" /* Error */, "true");
+      msg.respond(this.codec.encode(serializeError(error)), { headers: hdrs });
+    } catch {
+      this.logger.error("Failed to encode error response");
+    }
+  }
+};
+
+// src/server/infrastructure/stream.provider.ts
+var import_common5 = require("@nestjs/common");
+var STREAM_NOT_FOUND = 10059;
+var StreamProvider = class {
+  constructor(options, connection) {
+    this.options = options;
+    this.connection = connection;
+  }
+  logger = new import_common5.Logger("Jetstream:Stream");
+  /**
+   * Ensure all required streams exist with correct configuration.
+   *
+   * @param kinds Which stream kinds to create. Determined by the module based
+   *              on RPC mode and registered handler patterns.
+   */
+  async ensureStreams(kinds) {
+    const jsm = await this.connection.getJetStreamManager();
+    await Promise.all(kinds.map((kind) => this.ensureStream(jsm, kind)));
+  }
+  /** Get the stream name for a given kind. */
+  getStreamName(kind) {
+    return streamName(this.options.name, kind);
+  }
+  /** Get the subjects pattern for a given kind. */
+  getSubjects(kind) {
+    const name = internalName(this.options.name);
+    switch (kind) {
+      case "ev":
+        return [`${name}.ev.>`];
+      case "cmd":
+        return [`${name}.cmd.>`];
+      case "broadcast":
+        return ["broadcast.>"];
+    }
+  }
+  /** Ensure a single stream exists, creating or updating as needed. */
+  async ensureStream(jsm, kind) {
+    const config = this.buildConfig(kind);
+    this.logger.log(`Ensuring stream: ${config.name}`);
+    try {
+      await jsm.streams.info(config.name);
+      this.logger.debug(`Stream exists, updating: ${config.name}`);
+      return await jsm.streams.update(config.name, config);
+    } catch (err) {
+      const natsErr = err;
+      if (natsErr.api_error?.err_code === STREAM_NOT_FOUND) {
+        this.logger.log(`Creating stream: ${config.name}`);
+        return await jsm.streams.add(config);
+      }
+      throw err;
+    }
+  }
+  /** Build the full stream config by merging defaults with user overrides. */
+  buildConfig(kind) {
+    const name = this.getStreamName(kind);
+    const subjects = this.getSubjects(kind);
+    const description = `JetStream ${kind} stream for ${this.options.name}`;
+    const defaults = this.getDefaults(kind);
+    const overrides = this.getOverrides(kind);
+    return {
+      ...defaults,
+      ...overrides,
+      name,
+      subjects,
+      description
+    };
+  }
+  /** Get default config for a stream kind. */
+  getDefaults(kind) {
+    switch (kind) {
+      case "ev":
+        return DEFAULT_EVENT_STREAM_CONFIG;
+      case "cmd":
+        return DEFAULT_COMMAND_STREAM_CONFIG;
+      case "broadcast":
+        return DEFAULT_BROADCAST_STREAM_CONFIG;
+    }
+  }
+  /** Get user-provided overrides for a stream kind. */
+  getOverrides(kind) {
+    switch (kind) {
+      case "ev":
+        return this.options.events?.stream ?? {};
+      case "cmd":
+        return this.options.rpc?.mode === "jetstream" ? this.options.rpc.stream ?? {} : {};
+      case "broadcast":
+        return this.options.broadcast?.stream ?? {};
+    }
+  }
+};
+
+// src/server/infrastructure/consumer.provider.ts
+var import_common6 = require("@nestjs/common");
+var CONSUMER_NOT_FOUND = 10014;
+var ConsumerProvider = class {
+  constructor(options, connection, streamProvider, patternRegistry) {
+    this.options = options;
+    this.connection = connection;
+    this.streamProvider = streamProvider;
+    this.patternRegistry = patternRegistry;
+  }
+  logger = new import_common6.Logger("Jetstream:Consumer");
+  /**
+   * Ensure consumers exist for the specified kinds.
+   *
+   * @returns Map of kind -> ConsumerInfo for downstream use.
+   */
+  async ensureConsumers(kinds) {
+    const jsm = await this.connection.getJetStreamManager();
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      kinds.map(async (kind) => {
+        const info = await this.ensureConsumer(jsm, kind);
+        results.set(kind, info);
+      })
+    );
+    return results;
+  }
+  /** Get the consumer name for a given kind. */
+  getConsumerName(kind) {
+    return consumerName(this.options.name, kind);
+  }
+  /** Ensure a single consumer exists, creating if needed. */
+  async ensureConsumer(jsm, kind) {
+    const stream = this.streamProvider.getStreamName(kind);
+    const config = this.buildConfig(kind);
+    const name = config.durable_name;
+    this.logger.log(`Ensuring consumer: ${name} on stream: ${stream}`);
+    try {
+      const info = await jsm.consumers.info(stream, name);
+      this.logger.debug(`Consumer exists: ${name}`);
+      return info;
+    } catch (err) {
+      const natsErr = err;
+      if (natsErr.api_error?.err_code === CONSUMER_NOT_FOUND) {
+        this.logger.log(`Creating consumer: ${name}`);
+        return await jsm.consumers.add(stream, config);
+      }
+      throw err;
+    }
+  }
+  /** Build consumer config by merging defaults with user overrides. */
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- NATS API uses snake_case
+  buildConfig(kind) {
+    const name = this.getConsumerName(kind);
+    const serviceName = internalName(this.options.name);
+    const defaults = this.getDefaults(kind);
+    const overrides = this.getOverrides(kind);
+    if (kind === "broadcast") {
+      const broadcastPatterns = this.patternRegistry.getBroadcastPatterns();
+      if (broadcastPatterns.length === 1) {
+        return {
+          ...defaults,
+          ...overrides,
+          name,
+          durable_name: name,
+          filter_subject: broadcastPatterns[0]
+        };
+      }
+      return {
+        ...defaults,
+        ...overrides,
+        name,
+        durable_name: name,
+        filter_subjects: broadcastPatterns
+      };
+    }
+    const filter_subject = kind === "ev" ? `${serviceName}.ev.>` : `${serviceName}.cmd.>`;
+    return {
+      ...defaults,
+      ...overrides,
+      name,
+      durable_name: name,
+      filter_subject
+    };
+  }
+  /** Get default config for a consumer kind. */
+  getDefaults(kind) {
+    switch (kind) {
+      case "ev":
+        return DEFAULT_EVENT_CONSUMER_CONFIG;
+      case "cmd":
+        return DEFAULT_COMMAND_CONSUMER_CONFIG;
+      case "broadcast":
+        return DEFAULT_BROADCAST_CONSUMER_CONFIG;
+    }
+  }
+  /** Get user-provided overrides for a consumer kind. */
+  getOverrides(kind) {
+    switch (kind) {
+      case "ev":
+        return this.options.events?.consumer ?? {};
+      case "cmd":
+        return this.options.rpc?.mode === "jetstream" ? this.options.rpc.consumer ?? {} : {};
+      case "broadcast":
+        return this.options.broadcast?.consumer ?? {};
+    }
+  }
+};
+
+// src/server/infrastructure/message.provider.ts
+var import_common7 = require("@nestjs/common");
+var import_rxjs3 = require("rxjs");
+var MessageProvider = class {
+  constructor(connection, eventBus) {
+    this.connection = connection;
+    this.eventBus = eventBus;
+  }
+  logger = new import_common7.Logger("Jetstream:Message");
+  destroy$ = new import_rxjs3.Subject();
+  eventMessages$ = new import_rxjs3.Subject();
+  commandMessages$ = new import_rxjs3.Subject();
+  broadcastMessages$ = new import_rxjs3.Subject();
+  /** Observable stream of workqueue event messages. */
+  get events$() {
+    return this.eventMessages$.asObservable();
+  }
+  /** Observable stream of RPC command messages (jetstream mode). */
+  get commands$() {
+    return this.commandMessages$.asObservable();
+  }
+  /** Observable stream of broadcast event messages. */
+  get broadcasts$() {
+    return this.broadcastMessages$.asObservable();
+  }
+  /**
+   * Start consuming messages from the given consumer infos.
+   *
+   * Each consumer gets an independent self-healing flow.
+   * Call `destroy()` to stop all consumers.
+   */
+  start(consumers) {
+    const flows = [];
+    for (const [kind, info] of consumers) {
+      flows.push(this.createFlow(kind, info));
+    }
+    if (flows.length > 0) {
+      (0, import_rxjs3.merge)(...flows).pipe((0, import_rxjs3.takeUntil)(this.destroy$)).subscribe();
+    }
+  }
+  /** Stop all consumer flows and complete all subjects. */
+  destroy() {
+    this.destroy$.next();
+    this.destroy$.complete();
+    this.eventMessages$.complete();
+    this.commandMessages$.complete();
+    this.broadcastMessages$.complete();
+  }
+  /** Create a self-healing consumer flow for a specific kind. */
+  createFlow(kind, info) {
+    const target$ = this.getTargetSubject(kind);
+    return (0, import_rxjs3.defer)(() => this.consumeOnce(info, target$)).pipe(
+      (0, import_rxjs3.catchError)((err) => {
+        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 import_rxjs3.EMPTY;
+      }),
+      (0, import_rxjs3.repeat)({
+        delay: () => {
+          this.logger.warn(`Consumer ${info.name} stream ended, restarting...`);
+          this.eventBus.emit(
+            "error" /* Error */,
+            new Error(`Consumer ${info.name} stream ended`),
+            "message-provider"
+          );
+          return (0, import_rxjs3.timer)(100);
+        }
+      }),
+      (0, import_rxjs3.takeUntil)(this.destroy$)
+    );
+  }
+  /** Single iteration: get consumer -> pull messages -> emit to subject. */
+  async consumeOnce(info, target$) {
+    const js = (await this.connection.getConnection()).jetstream();
+    const consumer = await js.consumers.get(info.stream_name, info.name);
+    const messages = await consumer.consume();
+    for await (const msg of messages) {
+      target$.next(msg);
+    }
+  }
+  /** Get the target subject for a consumer kind. */
+  getTargetSubject(kind) {
+    switch (kind) {
+      case "ev":
+        return this.eventMessages$;
+      case "cmd":
+        return this.commandMessages$;
+      case "broadcast":
+        return this.broadcastMessages$;
+    }
+  }
+};
+
+// src/server/routing/pattern-registry.ts
+var import_common8 = require("@nestjs/common");
+var PatternRegistry = class {
+  constructor(options) {
+    this.options = options;
+  }
+  logger = new import_common8.Logger("Jetstream:PatternRegistry");
+  registry = /* @__PURE__ */ new Map();
+  /**
+   * Register all handlers from the NestJS strategy.
+   *
+   * @param handlers Map of pattern -> MessageHandler from `Server.getHandlers()`.
+   */
+  registerHandlers(handlers) {
+    const serviceName = this.options.name;
+    for (const [pattern, handler] of handlers) {
+      const isEvent = handler.isEventHandler ?? false;
+      const isBroadcast = !!handler.extras?.broadcast;
+      let fullSubject;
+      if (isBroadcast) {
+        fullSubject = buildBroadcastSubject(pattern);
+      } else if (isEvent) {
+        fullSubject = buildSubject(serviceName, "ev", pattern);
+      } else {
+        fullSubject = buildSubject(serviceName, "cmd", pattern);
+      }
+      this.registry.set(fullSubject, {
+        handler,
+        pattern,
+        isEvent,
+        isBroadcast
+      });
+      let kind;
+      if (isBroadcast) {
+        kind = "broadcast";
+      } else if (isEvent) {
+        kind = "event";
+      } else {
+        kind = "rpc";
+      }
+      this.logger.debug(`Registered ${kind}: ${pattern} -> ${fullSubject}`);
+    }
+    this.logSummary();
+  }
+  /** Find handler for a full NATS subject. */
+  getHandler(subject) {
+    return this.registry.get(subject)?.handler ?? null;
+  }
+  /** 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}`);
+  }
+  /** Check if any broadcast handlers are registered. */
+  hasBroadcastHandlers() {
+    return Array.from(this.registry.values()).some((r) => r.isBroadcast);
+  }
+  /** Check if any RPC (command) handlers are registered. */
+  hasRpcHandlers() {
+    return Array.from(this.registry.values()).some((r) => !r.isEvent && !r.isBroadcast);
+  }
+  /** Check if any workqueue event handlers are registered. */
+  hasEventHandlers() {
+    return Array.from(this.registry.values()).some((r) => r.isEvent && !r.isBroadcast);
+  }
+  /** Get patterns grouped by kind. */
+  getPatternsByKind() {
+    const events = [];
+    const commands = [];
+    const broadcasts = [];
+    for (const entry of this.registry.values()) {
+      if (entry.isBroadcast) broadcasts.push(entry.pattern);
+      else if (entry.isEvent) events.push(entry.pattern);
+      else commands.push(entry.pattern);
+    }
+    return { events, commands, broadcasts };
+  }
+  /** 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.`, "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 } = this.getPatternsByKind();
+    this.logger.log(
+      `Registered handlers: ${commands.length} RPC, ${events.length} events, ${broadcasts.length} broadcasts`
+    );
+  }
+};
+
+// src/server/routing/event.router.ts
+var import_common9 = require("@nestjs/common");
+var import_rxjs4 = require("rxjs");
+var EventRouter = class {
+  constructor(messageProvider, patternRegistry, codec, eventBus, deadLetterConfig) {
+    this.messageProvider = messageProvider;
+    this.patternRegistry = patternRegistry;
+    this.codec = codec;
+    this.eventBus = eventBus;
+    this.deadLetterConfig = deadLetterConfig;
+  }
+  logger = new import_common9.Logger("Jetstream:EventRouter");
+  subscriptions = [];
+  /** Start routing event and broadcast messages to handlers. */
+  start() {
+    this.subscribeToStream(this.messageProvider.events$, "workqueue");
+    this.subscribeToStream(this.messageProvider.broadcasts$, "broadcast");
+  }
+  /** Stop routing and unsubscribe from all streams. */
+  destroy() {
+    for (const sub of this.subscriptions) {
+      sub.unsubscribe();
+    }
+    this.subscriptions.length = 0;
+  }
+  /** Subscribe to a message stream and route each message. */
+  subscribeToStream(stream$, label) {
+    const subscription = stream$.pipe(
+      (0, import_rxjs4.mergeMap)((msg) => this.handle(msg)),
+      (0, import_rxjs4.catchError)((err, caught) => {
+        this.logger.error(`Unexpected error in ${label} event router`, err);
+        return caught;
+      })
+    ).subscribe();
+    this.subscriptions.push(subscription);
+  }
+  /** Handle a single event message: decode -> execute handler -> ack/nak. */
+  handle(msg) {
+    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 import_rxjs4.EMPTY;
+    }
+    let data;
+    try {
+      data = this.codec.decode(msg.data);
+    } catch (err) {
+      msg.term("Decode error");
+      this.logger.error(`Decode error for ${msg.subject}:`, err);
+      return import_rxjs4.EMPTY;
+    }
+    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "event");
+    const ctx = new RpcContext([msg]);
+    return (0, import_rxjs4.from)(this.executeHandler(handler, data, ctx, msg));
+  }
+  /** Execute handler, then ack on success or nak/dead-letter on failure. */
+  async executeHandler(handler, data, ctx, msg) {
+    try {
+      const result = await handler(data, ctx);
+      if ((0, import_rxjs4.isObservable)(result)) {
+        await (0, import_rxjs4.lastValueFrom)(result, { defaultValue: void 0 });
+      }
+      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();
+      }
+    }
+  }
+  /** 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) return false;
+    return msg.info.deliveryCount >= maxDeliver;
+  }
+  /** Handle a dead letter: invoke callback, then term or nak based on result. */
+  async handleDeadLetter(msg, data, error) {
+    const info = {
+      subject: msg.subject,
+      data,
+      headers: msg.headers,
+      error,
+      deliveryCount: msg.info.deliveryCount,
+      stream: msg.info.stream,
+      streamSequence: msg.info.streamSequence,
+      timestamp: new Date(msg.info.timestampNanos / 1e6).toISOString()
+    };
+    this.eventBus.emit("deadLetter" /* DeadLetter */, info);
+    if (!this.deadLetterConfig) return;
+    try {
+      await this.deadLetterConfig.onDeadLetter(info);
+      msg.term("Dead letter processed");
+    } catch (hookErr) {
+      this.logger.error(`onDeadLetter callback failed for ${msg.subject}, nak for retry:`, hookErr);
+      msg.nak();
+    }
+  }
+};
+
+// src/server/routing/rpc.router.ts
+var import_common10 = require("@nestjs/common");
+var import_nats6 = require("nats");
+var import_rxjs5 = require("rxjs");
+var RpcRouter = class {
+  constructor(messageProvider, patternRegistry, connection, codec, eventBus, timeout) {
+    this.messageProvider = messageProvider;
+    this.patternRegistry = patternRegistry;
+    this.connection = connection;
+    this.codec = codec;
+    this.eventBus = eventBus;
+    this.timeout = timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT;
+  }
+  logger = new import_common10.Logger("Jetstream:RpcRouter");
+  timeout;
+  subscription = null;
+  /** Start routing command messages to handlers. */
+  start() {
+    this.subscription = this.messageProvider.commands$.pipe(
+      (0, import_rxjs5.mergeMap)((msg) => this.handle(msg)),
+      (0, import_rxjs5.catchError)((err, caught) => {
+        this.logger.error("Unexpected error in RPC router", err);
+        return caught;
+      })
+    ).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 import_rxjs5.EMPTY;
+    }
+    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 import_rxjs5.EMPTY;
+    }
+    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 import_rxjs5.EMPTY;
+    }
+    this.eventBus.emit("messageRouted" /* MessageRouted */, msg.subject, "rpc");
+    return (0, import_rxjs5.from)(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 ctx = new RpcContext([msg]);
+    const hdrs = (0, import_nats6.headers)();
+    hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
+    let settled = false;
+    const timeoutId = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      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);
+      nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
+      msg.ack();
+    } catch (err) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      try {
+        hdrs.set("x-error" /* Error */, "true");
+        nc.publish(replyTo, this.codec.encode(serializeError(err)), { headers: hdrs });
+      } catch (encodeErr) {
+        this.logger.error(`Failed to encode RPC error for ${msg.subject}`, encodeErr);
+      }
+      msg.term(`Handler error: ${msg.subject}`);
+    }
+  }
+};
+
+// src/shutdown/shutdown.manager.ts
+var import_common11 = require("@nestjs/common");
+var ShutdownManager = class {
+  constructor(connection, eventBus, timeout) {
+    this.connection = connection;
+    this.eventBus = eventBus;
+    this.timeout = timeout;
+  }
+  logger = new import_common11.Logger("Jetstream:Shutdown");
+  /**
+   * Execute the full shutdown sequence.
+   *
+   * @param strategy Optional strategy to close (stops consumers and subscriptions).
+   */
+  async shutdown(strategy) {
+    this.eventBus.emit("shutdownStart" /* ShutdownStart */);
+    this.logger.log(`Graceful shutdown started (timeout: ${this.timeout}ms)`);
+    strategy?.close();
+    await Promise.race([
+      this.connection.shutdown(),
+      new Promise((resolve) => setTimeout(resolve, this.timeout))
+    ]);
+    this.eventBus.emit("shutdownComplete" /* ShutdownComplete */);
+    this.logger.log("Graceful shutdown complete");
+  }
+};
+
+// src/jetstream.module.ts
+var JetstreamModule = class {
+  constructor(shutdownManager, strategy) {
+    this.shutdownManager = shutdownManager;
+    this.strategy = strategy;
+  }
+  // -------------------------------------------------------------------
+  // forRoot — global module registration
+  // -------------------------------------------------------------------
+  /**
+   * Register the JetStream transport globally.
+   *
+   * Creates a shared NATS connection, codec, event bus, and optionally
+   * the full consumer infrastructure (streams, consumers, routers).
+   *
+   * @param options Module configuration.
+   * @returns Dynamic module ready to be imported.
+   */
+  static forRoot(options) {
+    const providers = this.createCoreProviders(options);
+    return {
+      module: JetstreamModule,
+      global: true,
+      providers,
+      exports: [
+        JETSTREAM_CONNECTION,
+        JETSTREAM_CODEC,
+        JETSTREAM_EVENT_BUS,
+        JETSTREAM_OPTIONS,
+        ShutdownManager,
+        JetstreamStrategy,
+        JetstreamHealthIndicator
+      ]
+    };
+  }
+  // -------------------------------------------------------------------
+  // forRootAsync — async global module registration
+  // -------------------------------------------------------------------
+  /**
+   * Register the JetStream transport globally with async configuration.
+   *
+   * Supports `useFactory`, `useExisting`, and `useClass` patterns
+   * for loading configuration from ConfigService, environment, etc.
+   *
+   * @param asyncOptions Async configuration.
+   * @returns Dynamic module ready to be imported.
+   */
+  static forRootAsync(asyncOptions) {
+    const asyncProviders = this.createAsyncOptionsProvider(asyncOptions);
+    const coreProviders = this.createCoreDependentProviders();
+    return {
+      module: JetstreamModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [...asyncProviders, ...coreProviders],
+      exports: [
+        JETSTREAM_CONNECTION,
+        JETSTREAM_CODEC,
+        JETSTREAM_EVENT_BUS,
+        JETSTREAM_OPTIONS,
+        ShutdownManager,
+        JetstreamStrategy,
+        JetstreamHealthIndicator
+      ]
+    };
+  }
+  // -------------------------------------------------------------------
+  // forFeature — per-module client registration
+  // -------------------------------------------------------------------
+  /**
+   * Register a lightweight client proxy for a target service.
+   *
+   * Reuses the shared NATS connection from `forRoot()`.
+   * Import in each feature module that needs to communicate with a specific service.
+   *
+   * @param options Feature options with target service name.
+   * @returns Dynamic module with the client provider.
+   */
+  static forFeature(options) {
+    const clientToken = getClientToken(options.name);
+    const clientProvider = {
+      provide: clientToken,
+      inject: [JETSTREAM_OPTIONS, JETSTREAM_CONNECTION, JETSTREAM_CODEC, JETSTREAM_EVENT_BUS],
+      useFactory: (rootOptions, connection, rootCodec, eventBus) => {
+        const codec = options.codec ?? rootCodec;
+        return new JetstreamClient(rootOptions, options.name, connection, codec, eventBus);
+      }
+    };
+    return {
+      module: JetstreamModule,
+      providers: [clientProvider],
+      exports: [clientToken]
+    };
+  }
+  // -------------------------------------------------------------------
+  // Provider factories
+  // -------------------------------------------------------------------
+  /** Create all providers for synchronous forRoot(). */
+  /**
+   * Build a map of stream name -> max_deliver for dead letter detection.
+   * Each stream kind (ev, broadcast) has its own consumer config with potentially
+   * different max_deliver values.
+   */
+  static buildMaxDeliverMap(options) {
+    const map = /* @__PURE__ */ new Map();
+    const defaultEventMax = DEFAULT_EVENT_CONSUMER_CONFIG.max_deliver ?? 3;
+    const defaultBroadcastMax = DEFAULT_BROADCAST_CONSUMER_CONFIG.max_deliver ?? 3;
+    map.set(
+      streamName(options.name, "ev"),
+      options.events?.consumer?.max_deliver ?? defaultEventMax
+    );
+    map.set(
+      streamName(options.name, "broadcast"),
+      options.broadcast?.consumer?.max_deliver ?? defaultBroadcastMax
+    );
+    return map;
+  }
+  static createCoreProviders(options) {
+    return [
+      {
+        provide: JETSTREAM_OPTIONS,
+        useValue: options
+      },
+      ...this.createCoreDependentProviders()
+    ];
+  }
+  /** Create providers that depend on JETSTREAM_OPTIONS (shared by sync and async). */
+  static createCoreDependentProviders() {
+    return [
+      // EventBus — hook system with Logger fallback
+      {
+        provide: JETSTREAM_EVENT_BUS,
+        inject: [JETSTREAM_OPTIONS],
+        useFactory: (options) => {
+          const logger = new import_common12.Logger("Jetstream:Module");
+          return new EventBus(logger, options.hooks);
+        }
+      },
+      // Codec — global encode/decode
+      {
+        provide: JETSTREAM_CODEC,
+        inject: [JETSTREAM_OPTIONS],
+        useFactory: (options) => {
+          return options.codec ?? new JsonCodec();
+        }
+      },
+      // ConnectionProvider — single NATS connection
+      {
+        provide: JETSTREAM_CONNECTION,
+        inject: [JETSTREAM_OPTIONS, JETSTREAM_EVENT_BUS],
+        useFactory: (options, eventBus) => {
+          return new ConnectionProvider(options, eventBus);
+        }
+      },
+      // JetstreamHealthIndicator — health check for NATS connection
+      {
+        provide: JetstreamHealthIndicator,
+        inject: [JETSTREAM_CONNECTION],
+        useFactory: (connection) => {
+          return new JetstreamHealthIndicator(connection);
+        }
+      },
+      // ShutdownManager — graceful shutdown orchestration
+      {
+        provide: ShutdownManager,
+        inject: [JETSTREAM_CONNECTION, JETSTREAM_EVENT_BUS, JETSTREAM_OPTIONS],
+        useFactory: (connection, eventBus, options) => {
+          return new ShutdownManager(
+            connection,
+            eventBus,
+            options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT
+          );
+        }
+      },
+      // ---------------------------------------------------------------
+      // Consumer infrastructure — only created when consumer !== false.
+      // Providers return null when consumer is disabled (publisher-only mode).
+      // ---------------------------------------------------------------
+      // PatternRegistry — subject-to-handler mapping
+      {
+        provide: PatternRegistry,
+        inject: [JETSTREAM_OPTIONS],
+        useFactory: (options) => {
+          if (options.consumer === false) return null;
+          return new PatternRegistry(options);
+        }
+      },
+      // StreamProvider — JetStream stream lifecycle
+      {
+        provide: StreamProvider,
+        inject: [JETSTREAM_OPTIONS, JETSTREAM_CONNECTION],
+        useFactory: (options, connection) => {
+          if (options.consumer === false) return null;
+          return new StreamProvider(options, connection);
+        }
+      },
+      // ConsumerProvider — JetStream consumer lifecycle (receives PatternRegistry for broadcast filtering)
+      {
+        provide: ConsumerProvider,
+        inject: [JETSTREAM_OPTIONS, JETSTREAM_CONNECTION, StreamProvider, PatternRegistry],
+        useFactory: (options, connection, streamProvider, patternRegistry) => {
+          if (options.consumer === false) return null;
+          return new ConsumerProvider(options, connection, streamProvider, patternRegistry);
+        }
+      },
+      // 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);
+        }
+      },
+      // EventRouter — routes event and broadcast messages to handlers
+      {
+        provide: EventRouter,
+        inject: [
+          JETSTREAM_OPTIONS,
+          MessageProvider,
+          PatternRegistry,
+          JETSTREAM_CODEC,
+          JETSTREAM_EVENT_BUS
+        ],
+        useFactory: (options, messageProvider, patternRegistry, codec, eventBus) => {
+          if (options.consumer === false) return null;
+          const deadLetterConfig = options.onDeadLetter ? {
+            maxDeliverByStream: JetstreamModule.buildMaxDeliverMap(options),
+            onDeadLetter: options.onDeadLetter
+          } : void 0;
+          return new EventRouter(
+            messageProvider,
+            patternRegistry,
+            codec,
+            eventBus,
+            deadLetterConfig
+          );
+        }
+      },
+      // RpcRouter — routes RPC command messages in JetStream mode
+      {
+        provide: RpcRouter,
+        inject: [
+          JETSTREAM_OPTIONS,
+          MessageProvider,
+          PatternRegistry,
+          JETSTREAM_CONNECTION,
+          JETSTREAM_CODEC,
+          JETSTREAM_EVENT_BUS
+        ],
+        useFactory: (options, messageProvider, patternRegistry, connection, codec, eventBus) => {
+          if (options.consumer === false) return null;
+          const timeout = options.rpc?.mode === "jetstream" ? options.rpc.timeout : void 0;
+          return new RpcRouter(
+            messageProvider,
+            patternRegistry,
+            connection,
+            codec,
+            eventBus,
+            timeout
+          );
+        }
+      },
+      // CoreRpcServer — RPC via NATS Core request/reply
+      {
+        provide: CoreRpcServer,
+        inject: [
+          JETSTREAM_OPTIONS,
+          JETSTREAM_CONNECTION,
+          PatternRegistry,
+          JETSTREAM_CODEC,
+          JETSTREAM_EVENT_BUS
+        ],
+        useFactory: (options, connection, patternRegistry, codec, eventBus) => {
+          if (options.consumer === false) return null;
+          return new CoreRpcServer(options, connection, patternRegistry, codec, eventBus);
+        }
+      },
+      // JetstreamStrategy — server-side transport (only when consumer enabled)
+      {
+        provide: JetstreamStrategy,
+        inject: [
+          JETSTREAM_OPTIONS,
+          JETSTREAM_CONNECTION,
+          PatternRegistry,
+          StreamProvider,
+          ConsumerProvider,
+          MessageProvider,
+          EventRouter,
+          RpcRouter,
+          CoreRpcServer
+        ],
+        useFactory: (options, connection, patternRegistry, streamProvider, consumerProvider, messageProvider, eventRouter, rpcRouter, coreRpcServer) => {
+          if (options.consumer === false) return null;
+          return new JetstreamStrategy(
+            options,
+            connection,
+            patternRegistry,
+            streamProvider,
+            consumerProvider,
+            messageProvider,
+            eventRouter,
+            rpcRouter,
+            coreRpcServer
+          );
+        }
+      }
+    ];
+  }
+  /** Create async options provider from useFactory/useExisting/useClass. */
+  static createAsyncOptionsProvider(asyncOptions) {
+    if (asyncOptions.useFactory) {
+      const factory = asyncOptions.useFactory;
+      return [
+        {
+          provide: JETSTREAM_OPTIONS,
+          useFactory: async (...args) => {
+            const partial = await factory(...args);
+            return { ...partial, name: asyncOptions.name };
+          },
+          inject: asyncOptions.inject ?? []
+        }
+      ];
+    }
+    if (asyncOptions.useExisting) {
+      return [
+        {
+          provide: JETSTREAM_OPTIONS,
+          useFactory: (config) => ({
+            ...config,
+            name: asyncOptions.name
+          }),
+          inject: [asyncOptions.useExisting]
+        }
+      ];
+    }
+    const useClass = asyncOptions.useClass;
+    return [
+      { provide: useClass, useClass },
+      {
+        provide: JETSTREAM_OPTIONS,
+        useFactory: (config) => ({
+          ...config,
+          name: asyncOptions.name
+        }),
+        inject: [useClass]
+      }
+    ];
+  }
+  // -------------------------------------------------------------------
+  // Lifecycle hooks
+  // -------------------------------------------------------------------
+  /**
+   * Gracefully shut down the transport on application termination.
+   */
+  async onApplicationShutdown() {
+    if (this.shutdownManager) {
+      await this.shutdownManager.shutdown(this.strategy ?? void 0);
+    }
+  }
+};
+JetstreamModule = __decorateClass([
+  (0, import_common12.Global)(),
+  (0, import_common12.Module)({}),
+  __decorateParam(0, (0, import_common12.Optional)()),
+  __decorateParam(0, (0, import_common12.Inject)(ShutdownManager)),
+  __decorateParam(1, (0, import_common12.Optional)()),
+  __decorateParam(1, (0, import_common12.Inject)(JetstreamStrategy))
+], JetstreamModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventBus,
+  JETSTREAM_CODEC,
+  JETSTREAM_CONNECTION,
+  JETSTREAM_EVENT_BUS,
+  JETSTREAM_OPTIONS,
+  JetstreamClient,
+  JetstreamHeader,
+  JetstreamHealthIndicator,
+  JetstreamModule,
+  JetstreamRecord,
+  JetstreamRecordBuilder,
+  JetstreamStrategy,
+  JsonCodec,
+  RpcContext,
+  TransportEvent,
+  getClientToken,
+  nanos
+});
+//# sourceMappingURL=index.cjs.map