@horizon-republic/nestjs-jetstream 2.9.0 → 2.10.0

package/dist/index.cjs

@@ -7,11 +7,11 @@ 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))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from4[key], enumerable: !(desc = __getOwnPropDesc(from4, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -29,14 +29,25 @@ var __decorateParam = (index, decorator) => (target, key) => decorator(target, k
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ConsumeKind: () => ConsumeKind,
+  DEFAULT_BROADCAST_CONSUMER_CONFIG: () => DEFAULT_BROADCAST_CONSUMER_CONFIG,
+  DEFAULT_BROADCAST_STREAM_CONFIG: () => DEFAULT_BROADCAST_STREAM_CONFIG,
+  DEFAULT_COMMAND_CONSUMER_CONFIG: () => DEFAULT_COMMAND_CONSUMER_CONFIG,
+  DEFAULT_COMMAND_STREAM_CONFIG: () => DEFAULT_COMMAND_STREAM_CONFIG,
+  DEFAULT_DLQ_STREAM_CONFIG: () => DEFAULT_DLQ_STREAM_CONFIG,
+  DEFAULT_EVENT_CONSUMER_CONFIG: () => DEFAULT_EVENT_CONSUMER_CONFIG,
+  DEFAULT_EVENT_STREAM_CONFIG: () => DEFAULT_EVENT_STREAM_CONFIG,
+  DEFAULT_JETSTREAM_RPC_TIMEOUT: () => DEFAULT_JETSTREAM_RPC_TIMEOUT,
   DEFAULT_METADATA_BUCKET: () => DEFAULT_METADATA_BUCKET,
   DEFAULT_METADATA_HISTORY: () => DEFAULT_METADATA_HISTORY,
   DEFAULT_METADATA_REPLICAS: () => DEFAULT_METADATA_REPLICAS,
   DEFAULT_METADATA_TTL: () => DEFAULT_METADATA_TTL,
-  EventBus: () => EventBus,
+  DEFAULT_ORDERED_STREAM_CONFIG: () => DEFAULT_ORDERED_STREAM_CONFIG,
+  DEFAULT_RPC_TIMEOUT: () => DEFAULT_RPC_TIMEOUT,
+  DEFAULT_SHUTDOWN_TIMEOUT: () => DEFAULT_SHUTDOWN_TIMEOUT,
+  DEFAULT_TRACES: () => DEFAULT_TRACES,
   JETSTREAM_CODEC: () => JETSTREAM_CODEC,
   JETSTREAM_CONNECTION: () => JETSTREAM_CONNECTION,
-  JETSTREAM_EVENT_BUS: () => JETSTREAM_EVENT_BUS,
   JETSTREAM_OPTIONS: () => JETSTREAM_OPTIONS,
   JetstreamClient: () => JetstreamClient,
   JetstreamDlqHeader: () => JetstreamDlqHeader,
@@ -46,12 +57,18 @@ __export(index_exports, {
   JetstreamRecord: () => JetstreamRecord,
   JetstreamRecordBuilder: () => JetstreamRecordBuilder,
   JetstreamStrategy: () => JetstreamStrategy,
+  JetstreamTrace: () => JetstreamTrace,
   JsonCodec: () => JsonCodec,
   MIN_METADATA_TTL: () => MIN_METADATA_TTL,
   MessageKind: () => MessageKind,
+  MsgpackCodec: () => MsgpackCodec,
+  NatsErrorCode: () => NatsErrorCode,
   PatternPrefix: () => PatternPrefix,
+  PublishKind: () => PublishKind,
+  RESERVED_HEADERS: () => RESERVED_HEADERS,
   RpcContext: () => RpcContext,
   StreamKind: () => StreamKind,
+  TRACER_NAME: () => TRACER_NAME,
   TransportEvent: () => TransportEvent,
   buildBroadcastSubject: () => buildBroadcastSubject,
   buildSubject: () => buildSubject,
@@ -68,13 +85,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/jetstream.module.ts
-var import_common14 = require("@nestjs/common");
+var import_common18 = require("@nestjs/common");
 
 // src/client/jetstream.client.ts
-var import_common = require("@nestjs/common");
+var import_common5 = require("@nestjs/common");
 var import_microservices = require("@nestjs/microservices");
-var import_transport_node = require("@nats-io/transport-node");
+var import_api8 = require("@opentelemetry/api");
 var import_nuid = require("@nats-io/nuid");
+var import_transport_node = require("@nats-io/transport-node");
 
 // src/interfaces/hooks.interface.ts
 var MessageKind = /* @__PURE__ */ ((MessageKind2) => {
@@ -264,6 +282,907 @@ var PatternPrefix = /* @__PURE__ */ ((PatternPrefix2) => {
 var isJetStreamRpcMode = (rpc) => rpc?.mode === "jetstream";
 var isCoreRpcMode = (rpc) => !rpc || rpc.mode === "core";
 
+// src/otel/constants.ts
+var TRACER_NAME = "@horizon-republic/nestjs-jetstream";
+
+// src/otel/attribute-keys.ts
+var ATTR_MESSAGING_SYSTEM = "messaging.system";
+var ATTR_MESSAGING_DESTINATION_NAME = "messaging.destination.name";
+var ATTR_MESSAGING_DESTINATION_TEMPLATE = "messaging.destination.template";
+var ATTR_MESSAGING_CLIENT_ID = "messaging.client.id";
+var ATTR_MESSAGING_OPERATION_NAME = "messaging.operation.name";
+var ATTR_MESSAGING_OPERATION_TYPE = "messaging.operation.type";
+var ATTR_MESSAGING_MESSAGE_BODY_SIZE = "messaging.message.body.size";
+var ATTR_MESSAGING_MESSAGE_ID = "messaging.message.id";
+var ATTR_MESSAGING_MESSAGE_CONVERSATION_ID = "messaging.message.conversation_id";
+var ATTR_MESSAGING_CONSUMER_GROUP_NAME = "messaging.consumer.group.name";
+var ATTR_MESSAGING_HEADER_PREFIX = "messaging.header.";
+var ATTR_MESSAGING_NATS_STREAM_NAME = "messaging.nats.stream.name";
+var ATTR_MESSAGING_NATS_STREAM_SEQUENCE = "messaging.nats.message.stream_sequence";
+var ATTR_MESSAGING_NATS_CONSUMER_SEQUENCE = "messaging.nats.message.consumer_sequence";
+var ATTR_MESSAGING_NATS_DELIVERY_COUNT = "messaging.nats.message.delivery_count";
+var ATTR_MESSAGING_NATS_BODY = "messaging.nats.message.body";
+var ATTR_MESSAGING_NATS_BODY_TRUNCATED = "messaging.nats.message.body.truncated";
+var ATTR_SERVER_ADDRESS = "server.address";
+var ATTR_SERVER_PORT = "server.port";
+var ATTR_JETSTREAM_SERVICE_NAME = "jetstream.service.name";
+var ATTR_JETSTREAM_KIND = "jetstream.kind";
+var ATTR_JETSTREAM_RPC_REPLY_HAS_ERROR = "jetstream.rpc.reply.has_error";
+var ATTR_JETSTREAM_RPC_REPLY_ERROR_CODE = "jetstream.rpc.reply.error.code";
+var ATTR_JETSTREAM_PROVISIONING_ENTITY = "jetstream.provisioning.entity";
+var ATTR_JETSTREAM_PROVISIONING_ACTION = "jetstream.provisioning.action";
+var ATTR_JETSTREAM_PROVISIONING_NAME = "jetstream.provisioning.name";
+var ATTR_JETSTREAM_SELF_HEALING_REASON = "jetstream.self_healing.reason";
+var ATTR_JETSTREAM_MIGRATION_REASON = "jetstream.migration.reason";
+var ATTR_JETSTREAM_DEAD_LETTER_REASON = "jetstream.dead_letter.reason";
+var ATTR_JETSTREAM_SCHEDULE_TARGET = "jetstream.schedule.target";
+var ATTR_NATS_CONNECTION_SERVER = "nats.connection.server";
+var NATS_MSG_ID_HEADER = "Nats-Msg-Id";
+var HOOK_PUBLISH = "publishHook";
+var HOOK_CONSUME = "consumeHook";
+var HOOK_RESPONSE = "responseHook";
+var SPAN_NAME_PUBLISH = "publish";
+var SPAN_NAME_PROCESS = "process";
+var SPAN_NAME_SEND = "send";
+var SPAN_NAME_DEAD_LETTER = "dead_letter";
+var SPAN_NAME_NATS_CONNECTION = "nats.connection";
+var SPAN_NAME_JETSTREAM_SHUTDOWN = "jetstream.shutdown";
+var SPAN_NAME_JETSTREAM_SELF_HEALING = "jetstream.self_healing";
+var SPAN_NAME_JETSTREAM_MIGRATION = "jetstream.migration";
+var SPAN_NAME_JETSTREAM_PROVISIONING_PREFIX = "jetstream.provisioning.";
+var EVENT_CONNECTION_DISCONNECTED = "connection.disconnected";
+var EVENT_CONNECTION_RECONNECTED = "connection.reconnected";
+var messagingHeaderAttr = (headerName) => `${ATTR_MESSAGING_HEADER_PREFIX}${headerName.toLowerCase()}`;
+
+// src/otel/trace-kinds.ts
+var JetstreamTrace = /* @__PURE__ */ ((JetstreamTrace2) => {
+  JetstreamTrace2["Publish"] = "publish";
+  JetstreamTrace2["Consume"] = "consume";
+  JetstreamTrace2["RpcClientSend"] = "rpc.client.send";
+  JetstreamTrace2["DeadLetter"] = "dead_letter";
+  JetstreamTrace2["ConnectionLifecycle"] = "connection.lifecycle";
+  JetstreamTrace2["SelfHealing"] = "self_healing";
+  JetstreamTrace2["Provisioning"] = "provisioning";
+  JetstreamTrace2["Migration"] = "migration";
+  JetstreamTrace2["Shutdown"] = "shutdown";
+  return JetstreamTrace2;
+})(JetstreamTrace || {});
+var DEFAULT_TRACES = [
+  "publish" /* Publish */,
+  "consume" /* Consume */,
+  "rpc.client.send" /* RpcClientSend */,
+  "dead_letter" /* DeadLetter */
+];
+
+// src/otel/capture.ts
+var NEGATION_PREFIX = "!";
+var REGEX_SPECIAL_RE = /[.+?^${}()|[\]\\*]/gu;
+var escapeForRegex = (input) => input.replace(REGEX_SPECIAL_RE, "\\$&");
+var globToRegex = (glob) => {
+  const escaped = escapeForRegex(glob.toLowerCase()).replace(/\\\*/gu, ".*");
+  return new RegExp(`^${escaped}$`, "u");
+};
+var compileHeaderAllowlist = (allowlist) => {
+  if (allowlist === true) return () => true;
+  if (allowlist === false) return () => false;
+  if (allowlist.length === 0) return () => false;
+  const includes = [];
+  const excludes = [];
+  for (const pattern of allowlist) {
+    const isExclude = pattern.startsWith(NEGATION_PREFIX);
+    const body = isExclude ? pattern.slice(NEGATION_PREFIX.length) : pattern;
+    const regex = globToRegex(body);
+    if (isExclude) excludes.push(regex);
+    else includes.push(regex);
+  }
+  return (name) => {
+    const lower = name.toLowerCase();
+    if (!includes.some((re) => re.test(lower))) return false;
+    if (excludes.some((re) => re.test(lower))) return false;
+    return true;
+  };
+};
+var subjectMatcherCache = /* @__PURE__ */ new WeakMap();
+var compileSubjectAllowlist = (allowlist) => {
+  if (!allowlist || allowlist.length === 0) return () => true;
+  const cached = subjectMatcherCache.get(allowlist);
+  if (cached) return cached;
+  const regexes = allowlist.map(globToRegex);
+  const matcher = (subject) => {
+    const lower = subject.toLowerCase();
+    return regexes.some((re) => re.test(lower));
+  };
+  subjectMatcherCache.set(allowlist, matcher);
+  return matcher;
+};
+var subjectMatchesAllowlist = (subject, allowlist) => compileSubjectAllowlist(allowlist)(subject);
+var HEADER_DENYLIST = /* @__PURE__ */ new Set([
+  "traceparent",
+  "tracestate",
+  "baggage",
+  "sentry-trace",
+  "b3",
+  "x-b3-traceid",
+  "x-b3-spanid",
+  "x-b3-parentspanid",
+  "x-b3-sampled",
+  "x-b3-flags",
+  "uber-trace-id",
+  "x-correlation-id",
+  "x-reply-to",
+  "x-error",
+  "x-subject",
+  "x-caller-name"
+]);
+var isNatsServerHeader = (lower) => lower.startsWith("nats-");
+var captureMatchingHeaders = (headers2, matcher) => {
+  if (!headers2) return {};
+  const out = {};
+  for (const key of headers2.keys()) {
+    const lower = key.toLowerCase();
+    if (HEADER_DENYLIST.has(lower)) continue;
+    if (isNatsServerHeader(lower)) continue;
+    if (!matcher(key)) continue;
+    const value = headers2.get(key);
+    if (value === "") continue;
+    out[messagingHeaderAttr(lower)] = value;
+  }
+  return out;
+};
+var tryUtf8Decode = (bytes) => {
+  try {
+    return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  } catch {
+    return Buffer.from(bytes).toString("base64");
+  }
+};
+var captureBodyAttribute = (subject, payload, capture) => {
+  if (capture === false) return {};
+  if (payload.byteLength === 0) return {};
+  if (!subjectMatchesAllowlist(subject, capture.subjectAllowlist)) return {};
+  const { maxBytes } = capture;
+  const truncated = payload.byteLength > maxBytes;
+  const slice = truncated ? payload.subarray(0, maxBytes) : payload;
+  const decoded = tryUtf8Decode(slice);
+  const out = { [ATTR_MESSAGING_NATS_BODY]: decoded };
+  if (truncated) out[ATTR_MESSAGING_NATS_BODY_TRUNCATED] = true;
+  return out;
+};
+
+// src/otel/config.ts
+var PublishKind = /* @__PURE__ */ ((PublishKind2) => {
+  PublishKind2["Event"] = "event";
+  PublishKind2["RpcRequest"] = "rpc.request";
+  PublishKind2["Broadcast"] = "broadcast";
+  PublishKind2["Ordered"] = "ordered";
+  return PublishKind2;
+})(PublishKind || {});
+var ConsumeKind = /* @__PURE__ */ ((ConsumeKind2) => {
+  ConsumeKind2["Event"] = "event";
+  ConsumeKind2["Rpc"] = "rpc";
+  ConsumeKind2["Broadcast"] = "broadcast";
+  ConsumeKind2["Ordered"] = "ordered";
+  return ConsumeKind2;
+})(ConsumeKind || {});
+var DEFAULT_CAPTURE_HEADERS = ["x-request-id"];
+var DEFAULT_CAPTURE_BODY_MAX_BYTES = 4096;
+var NESTJS_BARE_ERROR_MESSAGE = "Internal server error";
+var isNestjsBareErrorSentinel = (obj) => obj.status === "error" && obj.message === NESTJS_BARE_ERROR_MESSAGE;
+var defaultErrorClassifier = (err) => {
+  if (err === null || typeof err !== "object") return "unexpected";
+  if (!(err instanceof Error)) {
+    if (isNestjsBareErrorSentinel(err)) return "unexpected";
+    return "expected";
+  }
+  let proto = err;
+  while (proto) {
+    const name = proto.constructor?.name;
+    if (name === "RpcException" || name === "HttpException") return "expected";
+    proto = Object.getPrototypeOf(proto);
+  }
+  return "unexpected";
+};
+var expandTracesOption = (option) => {
+  if (option === void 0 || option === "default") return new Set(DEFAULT_TRACES);
+  if (option === "all") return new Set(Object.values(JetstreamTrace));
+  if (option === "none") return /* @__PURE__ */ new Set();
+  return new Set(option);
+};
+var compileHeaderMatcher = (option) => compileHeaderAllowlist(option ?? DEFAULT_CAPTURE_HEADERS);
+var resolveCaptureBody = (option) => {
+  if (option === void 0 || option === false) return false;
+  if (option === true) return { maxBytes: DEFAULT_CAPTURE_BODY_MAX_BYTES };
+  return {
+    maxBytes: option.maxBytes ?? DEFAULT_CAPTURE_BODY_MAX_BYTES,
+    subjectAllowlist: option.subjectAllowlist
+  };
+};
+var resolveOtelOptions = (options = {}) => {
+  return {
+    enabled: options.enabled ?? true,
+    traces: expandTracesOption(options.traces),
+    captureHeaders: compileHeaderMatcher(options.captureHeaders),
+    captureBody: resolveCaptureBody(options.captureBody),
+    publishHook: options.publishHook,
+    consumeHook: options.consumeHook,
+    responseHook: options.responseHook,
+    shouldTracePublish: options.shouldTracePublish,
+    shouldTraceConsume: options.shouldTraceConsume,
+    errorClassifier: options.errorClassifier ?? defaultErrorClassifier
+  };
+};
+
+// src/otel/internal-utils.ts
+var import_common = require("@nestjs/common");
+var logger = new import_common.Logger("Jetstream:Otel");
+var safelyInvokeHook = (hookName, hook, ...args) => {
+  if (!hook) return;
+  const logHookFailure = (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.debug(`OTel ${hookName} threw: ${message}`);
+  };
+  try {
+    const result = hook(...args);
+    if (result !== null && typeof result === "object" && "then" in result && typeof result.then === "function") {
+      result.then(void 0, logHookFailure);
+    }
+  } catch (err) {
+    logHookFailure(err);
+  }
+};
+var stripIpv6Brackets = (host) => host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+var parsePort = (portRaw) => {
+  if (!portRaw) return void 0;
+  const port = Number.parseInt(portRaw, 10);
+  return Number.isInteger(port) ? port : void 0;
+};
+var parseServerAddress = (servers) => {
+  const raw = servers[0];
+  if (!raw) return null;
+  if (raw.includes("://")) {
+    try {
+      const url = new URL(raw);
+      if (url.hostname.length === 0) return null;
+      const host2 = stripIpv6Brackets(url.hostname);
+      const port2 = parsePort(url.port || void 0);
+      return port2 === void 0 ? { host: host2 } : { host: host2, port: port2 };
+    } catch {
+      return null;
+    }
+  }
+  if (raw.startsWith("[")) {
+    const closeIdx = raw.indexOf("]");
+    if (closeIdx <= 0) return null;
+    const host2 = raw.slice(1, closeIdx);
+    const port2 = parsePort(raw.slice(closeIdx + 1).replace(/^:/u, ""));
+    return port2 === void 0 ? { host: host2 } : { host: host2, port: port2 };
+  }
+  const [host, portRaw] = raw.split(":");
+  if (!host) return null;
+  const port = parsePort(portRaw);
+  return port === void 0 ? { host } : { host, port };
+};
+var deriveOtelAttrs = (options) => ({
+  otel: resolveOtelOptions(options.otel),
+  serviceName: internalName(options.name),
+  serverEndpoint: parseServerAddress(options.servers)
+});
+
+// src/otel/propagator.ts
+var import_api = require("@opentelemetry/api");
+var injectContext = (ctx, carrier, setter) => {
+  import_api.propagation.inject(ctx, carrier, setter);
+};
+var extractContext = (ctx, carrier, getter) => import_api.propagation.extract(ctx, carrier, getter);
+
+// src/otel/tracer.ts
+var import_api2 = require("@opentelemetry/api");
+var PACKAGE_VERSION = true ? "2.10.0" : "0.0.0";
+var getTracer = () => import_api2.trace.getTracer(TRACER_NAME, PACKAGE_VERSION);
+
+// src/otel/carrier.ts
+var hdrsSetter = {
+  set: (headers2, key, value) => {
+    headers2.set(key, value);
+  }
+};
+var hdrsGetter = {
+  keys: (headers2) => headers2 ? headers2.keys() : [],
+  get: (headers2, key) => {
+    if (!headers2) return void 0;
+    const all = typeof headers2.values === "function" ? headers2.values(key) : void 0;
+    if (Array.isArray(all)) {
+      const nonEmpty = all.filter((value) => value !== "");
+      if (nonEmpty.length === 0) return void 0;
+      return nonEmpty.join(",");
+    }
+    const single = headers2.get(key);
+    return single === "" ? void 0 : single;
+  }
+};
+
+// src/otel/attributes.ts
+var MESSAGING_SYSTEM = "nats";
+var baseMessagingAttributes = (ctx) => {
+  const attrs = {
+    [ATTR_MESSAGING_SYSTEM]: MESSAGING_SYSTEM,
+    [ATTR_MESSAGING_DESTINATION_NAME]: ctx.subject,
+    [ATTR_MESSAGING_CLIENT_ID]: ctx.serviceName
+  };
+  if (ctx.serverAddress) attrs[ATTR_SERVER_ADDRESS] = ctx.serverAddress;
+  if (ctx.serverPort !== void 0) attrs[ATTR_SERVER_PORT] = ctx.serverPort;
+  if (ctx.pattern && ctx.pattern !== ctx.subject) {
+    attrs[ATTR_MESSAGING_DESTINATION_TEMPLATE] = ctx.pattern;
+  }
+  return attrs;
+};
+var jetstreamKindForPublish = (kind) => kind === "rpc.request" /* RpcRequest */ ? "rpc" /* Rpc */ : kind;
+var buildPublishAttributes = (ctx) => {
+  const attrs = {
+    ...baseMessagingAttributes(ctx),
+    [ATTR_MESSAGING_OPERATION_NAME]: SPAN_NAME_PUBLISH,
+    [ATTR_MESSAGING_OPERATION_TYPE]: SPAN_NAME_SEND,
+    [ATTR_MESSAGING_MESSAGE_BODY_SIZE]: ctx.payloadBytes,
+    [ATTR_JETSTREAM_KIND]: jetstreamKindForPublish(ctx.kind)
+  };
+  if (ctx.messageId) attrs[ATTR_MESSAGING_MESSAGE_ID] = ctx.messageId;
+  if (ctx.correlationId) attrs[ATTR_MESSAGING_MESSAGE_CONVERSATION_ID] = ctx.correlationId;
+  return attrs;
+};
+var buildConsumeAttributes = (ctx) => {
+  const { msg, info, kind, payloadBytes } = ctx;
+  const attrs = {
+    ...baseMessagingAttributes(ctx),
+    [ATTR_MESSAGING_OPERATION_NAME]: SPAN_NAME_PROCESS,
+    [ATTR_MESSAGING_OPERATION_TYPE]: SPAN_NAME_PROCESS,
+    [ATTR_MESSAGING_MESSAGE_BODY_SIZE]: payloadBytes,
+    [ATTR_JETSTREAM_KIND]: kind
+  };
+  if (info) {
+    attrs[ATTR_MESSAGING_NATS_STREAM_NAME] = info.stream;
+    attrs[ATTR_MESSAGING_CONSUMER_GROUP_NAME] = info.consumer;
+    attrs[ATTR_MESSAGING_NATS_STREAM_SEQUENCE] = info.streamSequence;
+    attrs[ATTR_MESSAGING_NATS_CONSUMER_SEQUENCE] = info.deliverySequence;
+    attrs[ATTR_MESSAGING_NATS_DELIVERY_COUNT] = info.deliveryCount;
+  }
+  const messageId = msg.headers?.get(NATS_MSG_ID_HEADER);
+  if (messageId) attrs[ATTR_MESSAGING_MESSAGE_ID] = messageId;
+  return attrs;
+};
+var buildRpcClientAttributes = (ctx) => {
+  const attrs = {
+    ...baseMessagingAttributes(ctx),
+    [ATTR_MESSAGING_OPERATION_NAME]: SPAN_NAME_SEND,
+    [ATTR_MESSAGING_OPERATION_TYPE]: SPAN_NAME_SEND,
+    [ATTR_MESSAGING_MESSAGE_BODY_SIZE]: ctx.payloadBytes,
+    [ATTR_JETSTREAM_KIND]: "rpc" /* Rpc */
+  };
+  if (ctx.correlationId) attrs[ATTR_MESSAGING_MESSAGE_CONVERSATION_ID] = ctx.correlationId;
+  if (ctx.messageId) attrs[ATTR_MESSAGING_MESSAGE_ID] = ctx.messageId;
+  return attrs;
+};
+var buildDeadLetterAttributes = (ctx) => {
+  const attrs = {
+    ...baseMessagingAttributes(ctx),
+    [ATTR_MESSAGING_OPERATION_NAME]: SPAN_NAME_DEAD_LETTER,
+    [ATTR_MESSAGING_OPERATION_TYPE]: SPAN_NAME_PROCESS,
+    [ATTR_MESSAGING_NATS_DELIVERY_COUNT]: ctx.finalDeliveryCount
+  };
+  if (ctx.reason) attrs[ATTR_JETSTREAM_DEAD_LETTER_REASON] = ctx.reason;
+  return attrs;
+};
+var extractFromRpcException = (record) => {
+  const getError = record.getError;
+  if (typeof getError !== "function") return void 0;
+  return codeFromPayload(getError.call(record));
+};
+var extractFromHttpException = (record) => {
+  const getStatus = record.getStatus;
+  if (typeof getStatus !== "function") return void 0;
+  const status = getStatus.call(record);
+  return typeof status === "number" && Number.isFinite(status) ? `HTTP_${status}` : void 0;
+};
+var extractFromOwnCode = (record) => {
+  const code = record.code ?? record.errorCode;
+  return typeof code === "string" && isStableErrorCode(code) ? code : void 0;
+};
+var extractExpectedErrorCode = (err) => {
+  if (err === null || typeof err !== "object") return void 0;
+  const record = err;
+  if (hasAncestorNamed(err, "RpcException")) {
+    const fromPayload = extractFromRpcException(record);
+    if (fromPayload !== void 0) return fromPayload;
+  }
+  if (hasAncestorNamed(err, "HttpException")) {
+    const fromStatus = extractFromHttpException(record);
+    if (fromStatus !== void 0) return fromStatus;
+  }
+  return extractFromOwnCode(record);
+};
+var hasAncestorNamed = (err, name) => {
+  let proto = Object.getPrototypeOf(err);
+  while (proto) {
+    const ctorName = proto.constructor?.name;
+    if (ctorName === name) return true;
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+};
+var STABLE_ERROR_CODE_RE = /^[A-Z][A-Z0-9_]*$/u;
+var isStableErrorCode = (value) => STABLE_ERROR_CODE_RE.test(value);
+var codeFromPayload = (payload) => {
+  if (payload === null || payload === void 0) return void 0;
+  if (typeof payload === "string") return isStableErrorCode(payload) ? payload : void 0;
+  if (typeof payload === "object") {
+    const code = payload.code;
+    if (typeof code === "string" && isStableErrorCode(code)) return code;
+  }
+  return void 0;
+};
+var buildExpectedErrorAttributes = (err) => {
+  const attrs = {
+    [ATTR_JETSTREAM_RPC_REPLY_HAS_ERROR]: true
+  };
+  const code = extractExpectedErrorCode(err);
+  if (code !== void 0) attrs[ATTR_JETSTREAM_RPC_REPLY_ERROR_CODE] = code;
+  return attrs;
+};
+var applyExpectedErrorAttributes = (span, err) => {
+  span.setAttributes(buildExpectedErrorAttributes(err));
+};
+
+// src/otel/spans/publish.ts
+var import_common2 = require("@nestjs/common");
+var import_api3 = require("@opentelemetry/api");
+var logger2 = new import_common2.Logger("Jetstream:Otel");
+var shouldTracePublishSafe = (predicate, subject, record) => {
+  if (!predicate) return true;
+  try {
+    return predicate(subject, record);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger2.debug(`OTel shouldTracePublish threw: ${message}`);
+    return true;
+  }
+};
+var withPublishSpan = async (ctx, config, fn) => {
+  if (!config.enabled) return fn();
+  const shouldCreateSpan = config.traces.has("publish" /* Publish */) && shouldTracePublishSafe(config.shouldTracePublish, ctx.subject, ctx.record);
+  if (!shouldCreateSpan) {
+    injectContext(import_api3.context.active(), ctx.headers, hdrsSetter);
+    return fn();
+  }
+  const tracer = getTracer();
+  const span = tracer.startSpan(`${SPAN_NAME_PUBLISH} ${ctx.subject}`, {
+    kind: import_api3.SpanKind.PRODUCER,
+    attributes: {
+      ...buildPublishAttributes({
+        subject: ctx.subject,
+        pattern: ctx.pattern,
+        serviceName: ctx.serviceName,
+        serverAddress: ctx.endpoint?.host,
+        serverPort: ctx.endpoint?.port,
+        kind: ctx.kind,
+        payloadBytes: ctx.payloadBytes,
+        messageId: ctx.messageId,
+        correlationId: ctx.correlationId
+      }),
+      ...ctx.scheduleTarget ? { [ATTR_JETSTREAM_SCHEDULE_TARGET]: ctx.scheduleTarget } : {},
+      ...captureMatchingHeaders(ctx.headers, config.captureHeaders),
+      ...captureBodyAttribute(ctx.subject, ctx.payload, config.captureBody)
+    }
+  });
+  const ctxWithSpan = import_api3.trace.setSpan(import_api3.context.active(), span);
+  injectContext(ctxWithSpan, ctx.headers, hdrsSetter);
+  const start = Date.now();
+  const invokeResponseHook = (error) => {
+    import_api3.context.with(ctxWithSpan, () => {
+      safelyInvokeHook(HOOK_RESPONSE, config.responseHook, span, {
+        subject: ctx.subject,
+        durationMs: Date.now() - start,
+        error
+      });
+    });
+  };
+  try {
+    const result = await import_api3.context.with(ctxWithSpan, async () => {
+      safelyInvokeHook(HOOK_PUBLISH, config.publishHook, span, {
+        subject: ctx.subject,
+        record: ctx.record,
+        kind: ctx.kind
+      });
+      return fn();
+    });
+    span.setStatus({ code: import_api3.SpanStatusCode.OK });
+    invokeResponseHook();
+    return result;
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    span.recordException(error);
+    span.setStatus({ code: import_api3.SpanStatusCode.ERROR, message: error.message });
+    invokeResponseHook(error);
+    throw err;
+  } finally {
+    span.end();
+  }
+};
+
+// src/otel/spans/consume.ts
+var import_api4 = require("@opentelemetry/api");
+var isPromiseLike = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+var applyExpectedError = (span, err) => {
+  span.setStatus({ code: import_api4.SpanStatusCode.OK });
+  applyExpectedErrorAttributes(span, err);
+};
+var applyUnexpectedError = (span, err) => {
+  const error = err instanceof Error ? err : new Error(String(err));
+  span.recordException(error);
+  span.setStatus({ code: import_api4.SpanStatusCode.ERROR, message: error.message });
+};
+var withConsumeSpan = (ctx, config, fn, options = {}) => {
+  if (!config.enabled) return fn();
+  const parentCtx = extractContext(import_api4.ROOT_CONTEXT, ctx.msg.headers, hdrsGetter);
+  const shouldCreateSpan = config.traces.has("consume" /* Consume */) && (config.shouldTraceConsume?.(ctx.subject, ctx.msg) ?? true);
+  if (!shouldCreateSpan) {
+    return import_api4.context.with(parentCtx, fn);
+  }
+  const tracer = getTracer();
+  const span = tracer.startSpan(
+    `${SPAN_NAME_PROCESS} ${ctx.subject}`,
+    {
+      kind: import_api4.SpanKind.CONSUMER,
+      attributes: {
+        ...buildConsumeAttributes({
+          subject: ctx.subject,
+          pattern: ctx.pattern,
+          msg: ctx.msg,
+          info: ctx.info,
+          kind: ctx.kind,
+          payloadBytes: ctx.payloadBytes,
+          serviceName: ctx.serviceName,
+          serverAddress: ctx.endpoint?.host,
+          serverPort: ctx.endpoint?.port
+        }),
+        ...captureMatchingHeaders(ctx.msg.headers, config.captureHeaders),
+        ...captureBodyAttribute(ctx.subject, ctx.msg.data, config.captureBody)
+      }
+    },
+    parentCtx
+  );
+  const ctxWithSpan = import_api4.trace.setSpan(parentCtx, span);
+  const start = Date.now();
+  let finalized = false;
+  const { signal, timeoutLabel = "handler.timeout" } = options;
+  let detachAbort = null;
+  const invokeResponseHook = (durationMs, error) => {
+    import_api4.context.with(ctxWithSpan, () => {
+      safelyInvokeHook(HOOK_RESPONSE, config.responseHook, span, {
+        subject: ctx.subject,
+        durationMs,
+        error
+      });
+    });
+  };
+  const finishOk2 = () => {
+    if (finalized) return;
+    finalized = true;
+    detachAbort?.();
+    span.setStatus({ code: import_api4.SpanStatusCode.OK });
+    invokeResponseHook(Date.now() - start);
+    span.end();
+  };
+  const finishError2 = (err) => {
+    if (finalized) return;
+    finalized = true;
+    detachAbort?.();
+    let classification = "unexpected";
+    try {
+      classification = config.errorClassifier(err);
+    } catch {
+    }
+    if (classification === "expected") {
+      applyExpectedError(span, err);
+    } else {
+      applyUnexpectedError(span, err);
+    }
+    invokeResponseHook(Date.now() - start, err instanceof Error ? err : new Error(String(err)));
+    span.end();
+  };
+  const onAbort = () => {
+    if (finalized) return;
+    finalized = true;
+    const error = new Error(timeoutLabel);
+    span.addEvent(timeoutLabel);
+    span.recordException(error);
+    span.setStatus({ code: import_api4.SpanStatusCode.ERROR, message: timeoutLabel });
+    invokeResponseHook(Date.now() - start, error);
+    span.end();
+  };
+  if (signal) {
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+      detachAbort = () => {
+        signal.removeEventListener("abort", onAbort);
+      };
+    }
+  }
+  let result;
+  try {
+    result = import_api4.context.with(ctxWithSpan, () => {
+      safelyInvokeHook(HOOK_CONSUME, config.consumeHook, span, {
+        subject: ctx.subject,
+        msg: ctx.msg,
+        handlerMetadata: ctx.handlerMetadata,
+        kind: ctx.kind
+      });
+      return fn();
+    });
+  } catch (err) {
+    finishError2(err);
+    throw err;
+  }
+  if (isPromiseLike(result)) {
+    return Promise.resolve(result).then(
+      (value) => {
+        finishOk2();
+        return value;
+      },
+      (err) => {
+        finishError2(err);
+        throw err;
+      }
+    );
+  }
+  finishOk2();
+  return result;
+};
+
+// src/otel/spans/rpc-client.ts
+var import_common3 = require("@nestjs/common");
+var import_api5 = require("@opentelemetry/api");
+var logger3 = new import_common3.Logger("Jetstream:Otel");
+var RPC_TIMEOUT_MESSAGE = "rpc.timeout";
+var beginRpcClientSpan = (ctx, config) => {
+  if (!config.enabled) {
+    return {
+      activeContext: import_api5.context.active(),
+      finish: () => void 0
+    };
+  }
+  if (!config.traces.has("rpc.client.send" /* RpcClientSend */)) {
+    injectContext(import_api5.context.active(), ctx.headers, hdrsSetter);
+    return {
+      activeContext: import_api5.context.active(),
+      finish: () => void 0
+    };
+  }
+  const tracer = getTracer();
+  const span = tracer.startSpan(`${SPAN_NAME_SEND} ${ctx.subject}`, {
+    kind: import_api5.SpanKind.CLIENT,
+    attributes: {
+      ...buildRpcClientAttributes({
+        subject: ctx.subject,
+        pattern: ctx.pattern,
+        correlationId: ctx.correlationId,
+        payloadBytes: ctx.payloadBytes,
+        messageId: ctx.messageId,
+        serviceName: ctx.serviceName,
+        serverAddress: ctx.endpoint?.host,
+        serverPort: ctx.endpoint?.port
+      }),
+      ...captureMatchingHeaders(ctx.headers, config.captureHeaders),
+      ...captureBodyAttribute(ctx.subject, ctx.payload, config.captureBody)
+    }
+  });
+  const ctxWithSpan = import_api5.trace.setSpan(import_api5.context.active(), span);
+  injectContext(ctxWithSpan, ctx.headers, hdrsSetter);
+  const start = Date.now();
+  let finalized = false;
+  const finish = (outcome) => {
+    if (finalized) return;
+    finalized = true;
+    let reply;
+    let error;
+    switch (outcome.kind) {
+      case "ok" /* Ok */:
+        reply = outcome.reply;
+        span.setStatus({ code: import_api5.SpanStatusCode.OK });
+        break;
+      case "reply-error" /* ReplyError */:
+        reply = outcome.replyPayload;
+        applyExpectedErrorAttributes(span, outcome.replyPayload);
+        span.setStatus({ code: import_api5.SpanStatusCode.OK });
+        break;
+      case "timeout" /* Timeout */:
+        error = new Error(RPC_TIMEOUT_MESSAGE);
+        span.addEvent(RPC_TIMEOUT_MESSAGE);
+        span.setStatus({ code: import_api5.SpanStatusCode.ERROR, message: RPC_TIMEOUT_MESSAGE });
+        break;
+      case "error" /* Error */:
+        error = outcome.error;
+        span.recordException(outcome.error);
+        span.setStatus({ code: import_api5.SpanStatusCode.ERROR, message: outcome.error.message });
+        break;
+      default: {
+        const unknownOutcome = outcome;
+        logger3.error(`Unhandled RPC outcome: ${String(unknownOutcome.kind)}`);
+        span.setStatus({ code: import_api5.SpanStatusCode.ERROR, message: "unknown outcome" });
+      }
+    }
+    import_api5.context.with(ctxWithSpan, () => {
+      safelyInvokeHook(HOOK_RESPONSE, config.responseHook, span, {
+        subject: ctx.subject,
+        durationMs: Date.now() - start,
+        reply,
+        error
+      });
+    });
+    span.end();
+  };
+  return { activeContext: ctxWithSpan, finish };
+};
+
+// src/otel/spans/dead-letter.ts
+var import_api6 = require("@opentelemetry/api");
+var withDeadLetterSpan = async (ctx, config, fn) => {
+  if (!config.enabled || !config.traces.has("dead_letter" /* DeadLetter */)) {
+    return fn();
+  }
+  const parentCtx = extractContext(import_api6.ROOT_CONTEXT, ctx.msg.headers, hdrsGetter);
+  const tracer = getTracer();
+  const span = tracer.startSpan(
+    `${SPAN_NAME_DEAD_LETTER} ${ctx.msg.subject}`,
+    {
+      kind: import_api6.SpanKind.INTERNAL,
+      attributes: buildDeadLetterAttributes({
+        subject: ctx.msg.subject,
+        pattern: ctx.pattern,
+        serviceName: ctx.serviceName,
+        serverAddress: ctx.endpoint?.host,
+        serverPort: ctx.endpoint?.port,
+        finalDeliveryCount: ctx.finalDeliveryCount,
+        reason: ctx.reason
+      })
+    },
+    parentCtx
+  );
+  const ctxWithSpan = import_api6.trace.setSpan(parentCtx, span);
+  const start = Date.now();
+  const invokeResponseHook = (error) => {
+    import_api6.context.with(ctxWithSpan, () => {
+      safelyInvokeHook(HOOK_RESPONSE, config.responseHook, span, {
+        subject: ctx.msg.subject,
+        durationMs: Date.now() - start,
+        error
+      });
+    });
+  };
+  try {
+    const result = await import_api6.context.with(ctxWithSpan, fn);
+    span.setStatus({ code: import_api6.SpanStatusCode.OK });
+    invokeResponseHook();
+    return result;
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    span.recordException(error);
+    span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: error.message });
+    invokeResponseHook(error);
+    throw err;
+  } finally {
+    span.end();
+  }
+};
+
+// src/otel/spans/infrastructure.ts
+var import_common4 = require("@nestjs/common");
+var import_api7 = require("@opentelemetry/api");
+var logger4 = new import_common4.Logger("Jetstream:Otel");
+var startInfraSpan = (config, traceKind, name, ctx, extraAttributes = {}) => {
+  if (!config.enabled || !config.traces.has(traceKind)) return null;
+  const tracer = getTracer();
+  const attributes = {
+    [ATTR_JETSTREAM_SERVICE_NAME]: ctx.serviceName
+  };
+  if (ctx.endpoint?.host) attributes[ATTR_SERVER_ADDRESS] = ctx.endpoint.host;
+  if (ctx.endpoint?.port !== void 0) attributes[ATTR_SERVER_PORT] = ctx.endpoint.port;
+  for (const [key, value] of Object.entries(extraAttributes)) {
+    if (value !== void 0) attributes[key] = value;
+  }
+  return tracer.startSpan(name, { kind: import_api7.SpanKind.INTERNAL, attributes });
+};
+var finishOk = (span) => {
+  span.setStatus({ code: import_api7.SpanStatusCode.OK });
+  span.end();
+};
+var finishError = (span, err) => {
+  const error = err instanceof Error ? err : new Error(String(err));
+  span.recordException(error);
+  span.setStatus({ code: import_api7.SpanStatusCode.ERROR, message: error.message });
+  span.end();
+};
+var wrapInfra = async (config, traceKind, name, ctx, attributes, op) => {
+  const span = startInfraSpan(config, traceKind, name, ctx, attributes);
+  if (!span) return op();
+  const ctxWithSpan = import_api7.trace.setSpan(import_api7.context.active(), span);
+  try {
+    const result = await import_api7.context.with(ctxWithSpan, op);
+    finishOk(span);
+    return result;
+  } catch (err) {
+    finishError(span, err);
+    throw err;
+  }
+};
+var beginConnectionLifecycleSpan = (config, ctx) => {
+  const span = startInfraSpan(
+    config,
+    "connection.lifecycle" /* ConnectionLifecycle */,
+    SPAN_NAME_NATS_CONNECTION,
+    ctx,
+    { [ATTR_NATS_CONNECTION_SERVER]: ctx.server }
+  );
+  if (!span) {
+    return {
+      recordEvent: () => void 0,
+      finish: () => void 0
+    };
+  }
+  let finalized = false;
+  return {
+    recordEvent: (name, attributes) => {
+      if (finalized) {
+        logger4.debug(`recordEvent('${name}') called after connection span finished`);
+        return;
+      }
+      span.addEvent(name, attributes);
+    },
+    finish: (err) => {
+      if (finalized) return;
+      finalized = true;
+      if (err === void 0) finishOk(span);
+      else finishError(span, err);
+    }
+  };
+};
+var withSelfHealingSpan = (config, ctx, op) => wrapInfra(
+  config,
+  "self_healing" /* SelfHealing */,
+  SPAN_NAME_JETSTREAM_SELF_HEALING,
+  ctx,
+  {
+    [ATTR_MESSAGING_NATS_STREAM_NAME]: ctx.stream,
+    [ATTR_MESSAGING_CONSUMER_GROUP_NAME]: ctx.consumer,
+    [ATTR_JETSTREAM_SELF_HEALING_REASON]: ctx.reason
+  },
+  op
+);
+var withProvisioningSpan = (config, ctx, op) => wrapInfra(
+  config,
+  "provisioning" /* Provisioning */,
+  `${SPAN_NAME_JETSTREAM_PROVISIONING_PREFIX}${ctx.entity}`,
+  ctx,
+  {
+    [ATTR_JETSTREAM_PROVISIONING_ENTITY]: ctx.entity,
+    [ATTR_JETSTREAM_PROVISIONING_ACTION]: ctx.action,
+    [ATTR_JETSTREAM_PROVISIONING_NAME]: ctx.name
+  },
+  op
+);
+var withMigrationSpan = (config, ctx, op) => wrapInfra(
+  config,
+  "migration" /* Migration */,
+  SPAN_NAME_JETSTREAM_MIGRATION,
+  ctx,
+  {
+    [ATTR_MESSAGING_NATS_STREAM_NAME]: ctx.stream,
+    [ATTR_JETSTREAM_MIGRATION_REASON]: ctx.reason
+  },
+  op
+);
+var withShutdownSpan = (config, ctx, op) => wrapInfra(config, "shutdown" /* Shutdown */, SPAN_NAME_JETSTREAM_SHUTDOWN, ctx, {}, op);
+
 // src/client/jetstream.record.ts
 var JetstreamRecord = class {
   constructor(data, headers2, timeout, messageId, schedule, ttl) {
@@ -416,9 +1335,14 @@ var JetstreamRecordBuilder = class {
       this.ttlDuration
     );
   }
-  /** Validate that a header key is not reserved. */
+  /**
+   * Validate that a header key is not reserved. NATS treats header names
+   * case-insensitively, so the check is against the lowercase form to keep
+   * `'X-Correlation-ID'`, `'x-correlation-id'`, and any other casing in
+   * lockstep. `RESERVED_HEADERS` is defined as an all-lowercase set.
+   */
   validateHeaderKey(key) {
-    if (RESERVED_HEADERS.has(key)) {
+    if (RESERVED_HEADERS.has(key.toLowerCase())) {
       throw new Error(
         `Header "${key}" is reserved by the JetStream transport and cannot be set manually. Reserved headers: ${[...RESERVED_HEADERS].join(", ")}`
       );
@@ -438,6 +1362,12 @@ var nanosToGoDuration = (nanos) => {
 };
 
 // src/client/jetstream.client.ts
+var BROADCAST_SUBJECT_PREFIX = "broadcast.";
+var detectEventKind = (pattern) => {
+  if (pattern.startsWith("broadcast:" /* Broadcast */)) return "broadcast" /* Broadcast */;
+  if (pattern.startsWith("ordered:" /* Ordered */)) return "ordered" /* Ordered */;
+  return "event" /* Event */;
+};
 var JetstreamClient = class extends import_microservices.ClientProxy {
   constructor(rootOptions, targetServiceName, connection, codec, eventBus) {
     super();
@@ -447,12 +1377,40 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     this.eventBus = eventBus;
     this.targetName = targetServiceName;
     this.callerName = internalName(this.rootOptions.name);
-  }
-  logger = new import_common.Logger("Jetstream:Client");
+    const targetInternal = internalName(targetServiceName);
+    this.eventSubjectPrefix = `${targetInternal}.${"ev" /* Event */}.`;
+    this.commandSubjectPrefix = `${targetInternal}.${"cmd" /* Command */}.`;
+    this.orderedSubjectPrefix = `${targetInternal}.${"ordered" /* Ordered */}.`;
+    this.isCoreMode = isCoreRpcMode(this.rootOptions.rpc);
+    this.defaultRpcTimeout = isJetStreamRpcMode(this.rootOptions.rpc) ? this.rootOptions.rpc?.timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT : this.rootOptions.rpc?.timeout ?? DEFAULT_RPC_TIMEOUT;
+    const derived = deriveOtelAttrs(this.rootOptions);
+    this.otel = derived.otel;
+    this.serverEndpoint = derived.serverEndpoint;
+  }
+  logger = new import_common5.Logger("Jetstream:Client");
   /** Target service name this client sends messages to. */
   targetName;
   /** Pre-cached caller name derived from rootOptions.name, computed once in constructor. */
   callerName;
+  /**
+   * Subject prefixes of the form `{serviceName}__microservice.{kind}.` — one
+   * per stream kind this client may publish to. Built once in the constructor
+   * so producing a full subject is a single string concat with the user pattern.
+   */
+  eventSubjectPrefix;
+  commandSubjectPrefix;
+  orderedSubjectPrefix;
+  /**
+   * RPC configuration snapshots. The values are derived from rootOptions at
+   * construction time so the publish hot path never has to re-run
+   * isCoreRpcMode / getRpcTimeout on every call.
+   */
+  isCoreMode;
+  defaultRpcTimeout;
+  /** Resolved OpenTelemetry configuration, computed once in the constructor. */
+  otel;
+  /** Server endpoint parts used for `server.address` / `server.port` span attributes. */
+  serverEndpoint;
   /** Shared inbox for JetStream-mode RPC responses. */
   inbox = null;
   inboxSubscription = null;
@@ -462,6 +1420,12 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   pendingTimeouts = /* @__PURE__ */ new Map();
   /** Subscription to connection status events for disconnect handling. */
   statusSubscription = null;
+  /**
+   * Cached readiness flag. Once `connect()` has wired the inbox and status
+   * subscription, subsequent publishes skip the `await connect()` microtask
+   * and reach for the underlying connection synchronously instead.
+   */
+  readyForPublish = false;
   /**
    * Establish connection. Called automatically by NestJS on first use.
    *
@@ -472,7 +1436,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
    */
   async connect() {
     const nc = await this.connection.getConnection();
-    if (isJetStreamRpcMode(this.rootOptions.rpc) && !this.inboxSubscription) {
+    if (!this.isCoreMode && !this.inboxSubscription) {
       this.setupInbox(nc);
     }
     this.statusSubscription ??= this.connection.status$.subscribe((status) => {
@@ -480,12 +1444,14 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
         this.handleDisconnect();
       }
     });
+    this.readyForPublish = true;
     return nc;
   }
   /** Clean up resources: reject pending RPCs, unsubscribe from status events. */
   async close() {
     this.statusSubscription?.unsubscribe();
     this.statusSubscription = null;
+    this.readyForPublish = false;
     this.rejectPendingRpcs(new Error("Client closed"));
   }
   /**
@@ -509,36 +1475,58 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
    * set to the original event subject.
    */
   async dispatchEvent(packet) {
-    await this.connect();
+    if (!this.readyForPublish) await this.connect();
     const { data, hdrs, messageId, schedule, ttl } = this.extractRecordData(packet.data);
     const eventSubject = this.buildEventSubject(packet.pattern);
+    const publishSubject = schedule ? this.buildScheduleSubject(eventSubject) : eventSubject;
     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), {
+    const encoded = this.codec.encode(data);
+    const effectiveMsgId = messageId ?? import_nuid.nuid.next();
+    const record = packet.data instanceof JetstreamRecord ? packet.data : new JetstreamRecord(data, /* @__PURE__ */ new Map());
+    await withPublishSpan(
+      {
+        subject: publishSubject,
+        pattern: packet.pattern,
+        record,
+        kind: detectEventKind(packet.pattern),
+        payloadBytes: encoded.length,
+        payload: encoded,
+        messageId: effectiveMsgId,
         headers: msgHeaders,
-        msgID: messageId ?? import_nuid.nuid.next(),
-        ttl,
-        schedule: {
-          specification: schedule.at,
-          target: eventSubject
+        serviceName: this.callerName,
+        endpoint: this.serverEndpoint,
+        scheduleTarget: schedule ? eventSubject : void 0
+      },
+      this.otel,
+      async () => {
+        const warnIfDuplicate = (kindLabel, ack2) => {
+          if (ack2.duplicate) {
+            this.logger.warn(
+              `Duplicate ${kindLabel} publish detected: ${publishSubject} (seq: ${ack2.seq})`
+            );
+          }
+        };
+        if (schedule) {
+          const ack2 = await this.connection.getJetStreamClient().publish(publishSubject, encoded, {
+            headers: msgHeaders,
+            msgID: effectiveMsgId,
+            ttl,
+            schedule: {
+              specification: schedule.at,
+              target: eventSubject
+            }
+          });
+          warnIfDuplicate("scheduled", ack2);
+          return;
         }
-      });
-      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(),
-        ttl
-      });
-      if (ack.duplicate) {
-        this.logger.warn(`Duplicate event publish detected: ${eventSubject} (seq: ${ack.seq})`);
+        const ack = await this.connection.getJetStreamClient().publish(publishSubject, encoded, {
+          headers: msgHeaders,
+          msgID: effectiveMsgId,
+          ttl
+        });
+        warnIfDuplicate("event", ack);
       }
-    }
+    );
     return void 0;
   }
   /**
@@ -548,7 +1536,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
    * JetStream mode: publishes to stream + waits for inbox response.
    */
   publish(packet, callback) {
-    const subject = buildSubject(this.targetName, "cmd" /* Command */, packet.pattern);
+    const subject = this.commandSubjectPrefix + packet.pattern;
     const { data, hdrs, timeout, messageId, schedule, ttl } = this.extractRecordData(packet.data);
     if (schedule) {
       this.logger.warn(
@@ -565,7 +1553,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
       callback({ err: new Error("Internal transport error"), response: null, isDisposed: true });
     };
     let jetStreamCorrelationId = null;
-    if (isCoreRpcMode(this.rootOptions.rpc)) {
+    if (this.isCoreMode) {
       this.publishCoreRpc(subject, data, hdrs, timeout, callback).catch(onUnhandled);
     } else {
       jetStreamCorrelationId = import_nuid.nuid.next();
@@ -589,37 +1577,102 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   }
   /** Core mode: nc.request() with timeout. */
   async publishCoreRpc(subject, data, customHeaders, timeout, callback) {
+    const effectiveTimeout = timeout ?? this.defaultRpcTimeout;
+    const hdrs = this.buildHeaders(customHeaders, { subject });
+    const encoded = this.codec.encode(data);
+    const spanHandle = beginRpcClientSpan(
+      {
+        subject,
+        payloadBytes: encoded.length,
+        payload: encoded,
+        headers: hdrs,
+        serviceName: this.callerName,
+        endpoint: this.serverEndpoint
+      },
+      this.otel
+    );
     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 nc = this.readyForPublish ? this.connection.unwrap : await this.connect();
+      const response = await import_api8.context.with(
+        spanHandle.activeContext,
+        () => nc.request(subject, encoded, {
+          timeout: effectiveTimeout,
+          headers: hdrs
+        })
+      );
       const decoded = this.codec.decode(response.data);
       if (response.headers?.get("x-error" /* Error */)) {
+        spanHandle.finish({ kind: "reply-error" /* ReplyError */, replyPayload: decoded });
         callback({ err: decoded, response: null, isDisposed: true });
       } else {
+        spanHandle.finish({ kind: "ok" /* Ok */, reply: decoded });
         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");
+      if (error instanceof import_transport_node.TimeoutError) {
+        spanHandle.finish({ kind: "timeout" /* Timeout */ });
+        this.eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, "");
+      } else {
+        spanHandle.finish({ kind: "error" /* Error */, error });
+        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, callback, options) {
     const { headers: customHeaders, correlationId, messageId } = options;
-    const effectiveTimeout = options.timeout ?? this.getRpcTimeout();
-    this.pendingMessages.set(correlationId, callback);
+    const effectiveTimeout = options.timeout ?? this.defaultRpcTimeout;
+    const hdrs = this.buildHeaders(customHeaders, {
+      subject,
+      correlationId,
+      replyTo: this.inbox ?? ""
+    });
+    const encoded = this.codec.encode(data);
+    const spanHandle = beginRpcClientSpan(
+      {
+        subject,
+        correlationId,
+        payloadBytes: encoded.length,
+        payload: encoded,
+        messageId,
+        headers: hdrs,
+        serviceName: this.callerName,
+        endpoint: this.serverEndpoint
+      },
+      this.otel
+    );
+    this.pendingMessages.set(correlationId, (packet) => {
+      if (packet.err) {
+        if (packet.err instanceof Error) {
+          spanHandle.finish({ kind: "error" /* Error */, error: packet.err });
+        } else {
+          spanHandle.finish({ kind: "reply-error" /* ReplyError */, replyPayload: packet.err });
+        }
+      } else {
+        spanHandle.finish({ kind: "ok" /* Ok */, reply: packet.response });
+      }
+      callback(packet);
+    });
+    const timeoutId = setTimeout(() => {
+      if (!this.pendingMessages.has(correlationId)) return;
+      this.pendingTimeouts.delete(correlationId);
+      this.pendingMessages.delete(correlationId);
+      spanHandle.finish({ kind: "timeout" /* Timeout */ });
+      this.eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
+      callback({ err: new Error(RPC_TIMEOUT_MESSAGE), response: null, isDisposed: true });
+    }, effectiveTimeout);
+    this.pendingTimeouts.set(correlationId, timeoutId);
     try {
-      await this.connect();
+      if (!this.readyForPublish) await this.connect();
       if (!this.pendingMessages.has(correlationId)) return;
       if (!this.inbox) {
+        clearTimeout(timeoutId);
+        this.pendingTimeouts.delete(correlationId);
         this.pendingMessages.delete(correlationId);
+        const inboxError = new Error("Inbox not initialized");
+        spanHandle.finish({ kind: "error" /* Error */, error: inboxError });
         callback({
           err: new Error("Inbox not initialized \u2014 JetStream RPC mode requires a connected inbox"),
           response: null,
@@ -627,24 +1680,13 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
         });
         return;
       }
-      const timeoutId = setTimeout(() => {
-        if (!this.pendingMessages.has(correlationId)) return;
-        this.pendingTimeouts.delete(correlationId);
-        this.pendingMessages.delete(correlationId);
-        this.logger.error(`JetStream RPC timeout (${effectiveTimeout}ms): ${subject}`);
-        this.eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
-        callback({ err: new Error("RPC timeout"), response: null, isDisposed: true });
-      }, effectiveTimeout);
-      this.pendingTimeouts.set(correlationId, timeoutId);
-      const hdrs = this.buildHeaders(customHeaders, {
-        subject,
-        correlationId,
-        replyTo: this.inbox
-      });
-      await this.connection.getJetStreamClient().publish(subject, this.codec.encode(data), {
-        headers: hdrs,
-        msgID: messageId ?? import_nuid.nuid.next()
-      });
+      await import_api8.context.with(
+        spanHandle.activeContext,
+        () => this.connection.getJetStreamClient().publish(subject, encoded, {
+          headers: hdrs,
+          msgID: messageId ?? import_nuid.nuid.next()
+        })
+      );
     } catch (err) {
       const existingTimeout = this.pendingTimeouts.get(correlationId);
       if (existingTimeout) {
@@ -654,7 +1696,8 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
       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);
+      spanHandle.finish({ kind: "error" /* Error */, error });
+      this.eventBus.emit("error" /* Error */, error, `jetstream-rpc-publish:${subject}`);
       callback({ err: error, response: null, isDisposed: true });
     }
   }
@@ -662,6 +1705,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
   handleDisconnect() {
     this.rejectPendingRpcs(new Error("Connection lost"));
     this.inbox = null;
+    this.readyForPublish = false;
   }
   /** Reject all pending RPC callbacks, clear timeouts, and tear down inbox. */
   rejectPendingRpcs(error) {
@@ -725,19 +1769,22 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
       this.pendingMessages.delete(correlationId);
     }
   }
-  /** Build event subject — workqueue, broadcast, or ordered. */
+  /**
+   * Resolve a user pattern to a fully-qualified NATS subject, dispatching
+   * between the event, broadcast, and ordered prefixes.
+   *
+   * The leading-char check short-circuits the `startsWith` comparisons for
+   * patterns that cannot possibly carry a broadcast/ordered marker, which is
+   * the overwhelmingly common case.
+   */
   buildEventSubject(pattern) {
-    if (pattern.startsWith("broadcast:" /* Broadcast */)) {
-      return buildBroadcastSubject(pattern.slice("broadcast:" /* Broadcast */.length));
-    }
-    if (pattern.startsWith("ordered:" /* Ordered */)) {
-      return buildSubject(
-        this.targetName,
-        "ordered" /* Ordered */,
-        pattern.slice("ordered:" /* Ordered */.length)
-      );
+    if (pattern.charCodeAt(0) === 98 && pattern.startsWith("broadcast:" /* Broadcast */)) {
+      return BROADCAST_SUBJECT_PREFIX + pattern.slice("broadcast:" /* Broadcast */.length);
     }
-    return buildSubject(this.targetName, "ev" /* Event */, pattern);
+    if (pattern.charCodeAt(0) === 111 && pattern.startsWith("ordered:" /* Ordered */)) {
+      return this.orderedSubjectPrefix + pattern.slice("ordered:" /* Ordered */.length);
+    }
+    return this.eventSubjectPrefix + pattern;
   }
   /** Build NATS headers merging custom headers with transport headers. */
   buildHeaders(customHeaders, transport) {
@@ -762,7 +1809,7 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     if (rawData instanceof JetstreamRecord) {
       return {
         data: rawData.data,
-        hdrs: rawData.headers.size > 0 ? new Map(rawData.headers) : null,
+        hdrs: rawData.headers.size > 0 ? rawData.headers : null,
         timeout: rawData.timeout,
         messageId: rawData.messageId,
         schedule: rawData.schedule,
@@ -805,11 +1852,6 @@ var JetstreamClient = class extends import_microservices.ClientProxy {
     const pattern = withoutPrefix.slice(dotIndex + 1);
     return `${targetPrefix}_sch.${pattern}`;
   }
-  getRpcTimeout() {
-    if (!this.rootOptions.rpc) return DEFAULT_RPC_TIMEOUT;
-    const defaultTimeout = isJetStreamRpcMode(this.rootOptions.rpc) ? DEFAULT_JETSTREAM_RPC_TIMEOUT : DEFAULT_RPC_TIMEOUT;
-    return this.rootOptions.rpc.timeout ?? defaultTimeout;
-  }
 };
 
 // src/codec/json.codec.ts
@@ -824,10 +1866,23 @@ var JsonCodec = class {
   }
 };
 
+// src/codec/msgpack.codec.ts
+var MsgpackCodec = class {
+  constructor(packr) {
+    this.packr = packr;
+  }
+  encode(data) {
+    return this.packr.pack(data);
+  }
+  decode(data) {
+    return this.packr.unpack(data);
+  }
+};
+
 // src/connection/connection.provider.ts
-var import_common2 = require("@nestjs/common");
+var import_common6 = require("@nestjs/common");
 var import_transport_node2 = require("@nats-io/transport-node");
-var import_jetstream7 = require("@nats-io/jetstream");
+var import_jetstream8 = require("@nats-io/jetstream");
 var import_rxjs = require("rxjs");
 var DEFAULT_OPTIONS = {
   maxReconnectAttempts: -1,
@@ -837,6 +1892,10 @@ var ConnectionProvider = class {
   constructor(options, eventBus) {
     this.options = options;
     this.eventBus = eventBus;
+    const derived = deriveOtelAttrs(options);
+    this.otel = derived.otel;
+    this.otelServiceName = derived.serviceName;
+    this.otelEndpoint = derived.serverEndpoint;
     this.nc$ = (0, import_rxjs.defer)(() => this.getConnection()).pipe(
       (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: false })
     );
@@ -849,12 +1908,16 @@ var ConnectionProvider = class {
   nc$;
   /** Live stream of connection status events (no replay). */
   status$;
-  logger = new import_common2.Logger("Jetstream:Connection");
+  logger = new import_common6.Logger("Jetstream:Connection");
   connection = null;
   connectionPromise = null;
   jsClient = null;
   jsmInstance = null;
   jsmPromise = null;
+  otel;
+  otelServiceName;
+  otelEndpoint;
+  lifecycleSpan = null;
   /**
    * Establish NATS connection. Idempotent — returns cached connection on subsequent calls.
    *
@@ -897,7 +1960,7 @@ var ConnectionProvider = class {
     if (!this.connection || this.connection.isClosed()) {
       throw new Error("Not connected \u2014 call getConnection() before getJetStreamClient()");
     }
-    this.jsClient ??= (0, import_jetstream7.jetstream)(this.connection);
+    this.jsClient ??= (0, import_jetstream8.jetstream)(this.connection);
     return this.jsClient;
   }
   /** Direct access to the raw NATS connection, or `null` if not yet connected. */
@@ -918,14 +1981,24 @@ var ConnectionProvider = class {
     }
     if (!this.connection || this.connection.isClosed()) return;
     try {
-      await this.connection.drain();
-      await this.connection.closed();
-    } catch {
-      try {
-        await this.connection.close();
-      } catch {
-      }
+      await withShutdownSpan(
+        this.otel,
+        { serviceName: this.otelServiceName, endpoint: this.otelEndpoint },
+        async () => {
+          try {
+            await this.connection?.drain();
+            await this.connection?.closed();
+          } catch {
+            try {
+              await this.connection?.close();
+            } catch {
+            }
+          }
+        }
+      );
     } finally {
+      this.lifecycleSpan?.finish();
+      this.lifecycleSpan = null;
       this.connection = null;
       this.connectionPromise = null;
       this.jsClient = null;
@@ -936,7 +2009,7 @@ var ConnectionProvider = class {
   async initJetStreamManager() {
     try {
       const nc = await this.getConnection();
-      this.jsmInstance = await (0, import_jetstream7.jetstreamManager)(nc);
+      this.jsmInstance = await (0, import_jetstream8.jetstreamManager)(nc);
       this.logger.log("JetStream manager initialized");
       return this.jsmInstance;
     } finally {
@@ -945,17 +2018,25 @@ var ConnectionProvider = class {
   }
   /** Internal: establish the physical connection with reconnect monitoring. */
   async establish() {
-    const name = internalName(this.options.name);
     try {
       const nc = await (0, import_transport_node2.connect)({
         ...DEFAULT_OPTIONS,
+        // Default the NATS connection name to the OTel-derived service name so
+        // `nats server info` lines up with span attributes, but let user-supplied
+        // `connectionOptions.name` win when set.
+        name: this.otelServiceName,
         ...this.options.connectionOptions,
-        servers: this.options.servers,
-        name
+        servers: this.options.servers
       });
       this.connection = nc;
       this.logger.log(`NATS connection established: ${nc.getServer()}`);
       this.eventBus.emit("connect" /* Connect */, nc.getServer());
+      this.lifecycleSpan?.finish();
+      this.lifecycleSpan = beginConnectionLifecycleSpan(this.otel, {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        server: nc.getServer()
+      });
       this.monitorStatus(nc);
       return nc;
     } catch (err) {
@@ -965,37 +2046,55 @@ var ConnectionProvider = class {
       throw err;
     }
   }
+  /** Handle a single `nc.status()` event, emitting hooks and span events. */
+  handleStatusEvent(status, nc) {
+    switch (status.type) {
+      case "disconnect":
+        this.eventBus.emit("disconnect" /* Disconnect */);
+        this.lifecycleSpan?.recordEvent(EVENT_CONNECTION_DISCONNECTED);
+        break;
+      case "reconnect":
+        this.jsClient = null;
+        this.jsmInstance = null;
+        this.jsmPromise = null;
+        this.eventBus.emit("reconnect" /* Reconnect */, nc.getServer());
+        this.lifecycleSpan?.recordEvent(EVENT_CONNECTION_RECONNECTED, {
+          [ATTR_NATS_CONNECTION_SERVER]: nc.getServer()
+        });
+        break;
+      case "error":
+        this.eventBus.emit(
+          "error" /* Error */,
+          status.error,
+          "connection"
+        );
+        break;
+      case "update":
+      case "ldm":
+      case "reconnecting":
+      case "ping":
+      case "staleConnection":
+      case "forceReconnect":
+      case "slowConsumer":
+      case "close":
+        break;
+      default: {
+        const _exhaustive = status;
+        const unknown = _exhaustive.type ?? "unknown";
+        this.logger.warn(`Unhandled NATS status event: ${unknown}`);
+      }
+    }
+  }
   /** Subscribe to connection status events and emit hooks. */
   monitorStatus(nc) {
     void (async () => {
-      for await (const status of nc.status()) {
-        switch (status.type) {
-          case "disconnect":
-            this.eventBus.emit("disconnect" /* Disconnect */);
-            break;
-          case "reconnect":
-            this.jsClient = null;
-            this.jsmInstance = null;
-            this.jsmPromise = null;
-            this.eventBus.emit("reconnect" /* Reconnect */, nc.getServer());
-            break;
-          case "error":
-            this.eventBus.emit(
-              "error" /* Error */,
-              status.error,
-              "connection"
-            );
-            break;
-          case "update":
-          case "ldm":
-          case "reconnecting":
-          case "ping":
-          case "staleConnection":
-          case "forceReconnect":
-          case "slowConsumer":
-          case "close":
-            break;
+      try {
+        for await (const status of nc.status()) {
+          this.handleStatusEvent(status, nc);
         }
+      } finally {
+        this.lifecycleSpan?.finish();
+        this.lifecycleSpan = null;
       }
     })().catch((err) => {
       this.logger.error("Status monitor error", err);
@@ -1007,8 +2106,8 @@ var ConnectionProvider = class {
 var EventBus = class {
   hooks;
   logger;
-  constructor(logger, hooks) {
-    this.logger = logger;
+  constructor(logger5, hooks) {
+    this.logger = logger5;
     this.hooks = hooks ?? {};
   }
   /**
@@ -1036,6 +2135,15 @@ var EventBus = class {
       kind
     );
   }
+  /**
+   * Check whether a hook is registered for the given event.
+   *
+   * Used by the routing hot path to elide the emit call entirely when the
+   * transport owner did not register a listener.
+   */
+  hasHook(event) {
+    return this.hooks[event] !== void 0;
+  }
   callHook(event, hook, ...args) {
     try {
       const result = hook(...args);
@@ -1055,12 +2163,12 @@ var EventBus = class {
 };
 
 // src/health/jetstream.health-indicator.ts
-var import_common3 = require("@nestjs/common");
+var import_common7 = require("@nestjs/common");
 var JetstreamHealthIndicator = class {
   constructor(connection) {
     this.connection = connection;
   }
-  logger = new import_common3.Logger("Jetstream:Health");
+  logger = new import_common7.Logger("Jetstream:Health");
   /**
    * Plain health status check.
    *
@@ -1117,7 +2225,7 @@ var JetstreamHealthIndicator = class {
   }
 };
 JetstreamHealthIndicator = __decorateClass([
-  (0, import_common3.Injectable)()
+  (0, import_common7.Injectable)()
 ], JetstreamHealthIndicator);
 
 // src/server/strategy.ts
@@ -1266,7 +2374,7 @@ var JetstreamStrategy = class extends import_microservices2.Server {
 };
 
 // src/server/core-rpc.server.ts
-var import_common4 = require("@nestjs/common");
+var import_common8 = require("@nestjs/common");
 var import_transport_node3 = require("@nats-io/transport-node");
 
 // src/context/rpc.context.ts
@@ -1276,9 +2384,6 @@ var RpcContext = class extends import_microservices3.BaseRpcContext {
   _retryDelay;
   _shouldTerminate = false;
   _terminateReason;
-  // ---------------------------------------------------------------------------
-  // Message accessors
-  // ---------------------------------------------------------------------------
   /**
    * Get the underlying NATS message.
    *
@@ -1313,9 +2418,6 @@ var RpcContext = class extends import_microservices3.BaseRpcContext {
   isJetStream() {
     return "ack" in this.args[0];
   }
-  // ---------------------------------------------------------------------------
-  // JetStream metadata (return undefined for Core NATS messages)
-  // ---------------------------------------------------------------------------
   /** How many times this message has been delivered. */
   getDeliveryCount() {
     return this.asJetStream()?.info.deliveryCount;
@@ -1337,9 +2439,6 @@ var RpcContext = class extends import_microservices3.BaseRpcContext {
   getCallerName() {
     return this.getHeader("x-caller-name" /* CallerName */);
   }
-  // ---------------------------------------------------------------------------
-  // Handler-controlled settlement
-  // ---------------------------------------------------------------------------
   /**
    * Signal the transport to retry (nak) this message instead of acknowledging it.
    *
@@ -1384,9 +2483,6 @@ var RpcContext = class extends import_microservices3.BaseRpcContext {
       throw new Error(`${method}() is only available for JetStream messages`);
     }
   }
-  // ---------------------------------------------------------------------------
-  // Transport-facing state (read by EventRouter)
-  // ---------------------------------------------------------------------------
   /** @internal */
   get shouldRetry() {
     return this._shouldRetry;
@@ -1418,16 +2514,71 @@ var resolveAckExtensionInterval = (config, ackWaitNanos) => {
   const interval = Math.floor(ackWaitNanos / 1e6 / 2);
   return Math.max(interval, MIN_ACK_EXTENSION_INTERVAL);
 };
+var AckExtensionPool = class {
+  entries = /* @__PURE__ */ new Set();
+  handle = null;
+  handleFireAt = 0;
+  schedule(msg, interval) {
+    const entry = {
+      msg,
+      interval,
+      nextFireAt: Date.now() + interval,
+      active: true
+    };
+    this.entries.add(entry);
+    this.ensureWake(entry.nextFireAt);
+    return entry;
+  }
+  cancel(entry) {
+    if (!entry.active) return;
+    entry.active = false;
+    this.entries.delete(entry);
+    if (this.entries.size === 0 && this.handle !== null) {
+      clearTimeout(this.handle);
+      this.handle = null;
+      this.handleFireAt = 0;
+    }
+  }
+  /**
+   * Ensure the shared timer will fire no later than `dueAt`. If an earlier
+   * wake is already scheduled, leave it; otherwise replace it with a tighter one.
+   */
+  ensureWake(dueAt) {
+    if (this.handle !== null && this.handleFireAt <= dueAt) return;
+    if (this.handle !== null) clearTimeout(this.handle);
+    const delay = Math.max(0, dueAt - Date.now());
+    const handle = setTimeout(() => {
+      this.tick();
+    }, delay);
+    if (typeof handle.unref === "function") handle.unref();
+    this.handle = handle;
+    this.handleFireAt = dueAt;
+  }
+  tick() {
+    this.handle = null;
+    this.handleFireAt = 0;
+    const now = Date.now();
+    let earliest = Infinity;
+    for (const entry of this.entries) {
+      if (!entry.active) continue;
+      if (entry.nextFireAt <= now) {
+        try {
+          entry.msg.working();
+        } catch {
+        }
+        entry.nextFireAt = now + entry.interval;
+      }
+      if (entry.nextFireAt < earliest) earliest = entry.nextFireAt;
+    }
+    if (earliest !== Infinity) this.ensureWake(earliest);
+  }
+};
+var pool = new AckExtensionPool();
 var startAckExtensionTimer = (msg, interval) => {
   if (interval === null || interval <= 0) return null;
-  const timer2 = setInterval(() => {
-    try {
-      msg.working();
-    } catch {
-    }
-  }, interval);
+  const entry = pool.schedule(msg, interval);
   return () => {
-    clearInterval(timer2);
+    pool.cancel(entry);
   };
 };
 
@@ -1441,11 +2592,8 @@ var serializeError = (err) => {
 
 // src/utils/unwrap-result.ts
 var import_rxjs2 = require("rxjs");
-var RESOLVED_VOID = Promise.resolve(void 0);
-var RESOLVED_NULL = Promise.resolve(null);
 var unwrapResult = (result) => {
-  if (result === void 0) return RESOLVED_VOID;
-  if (result === null) return RESOLVED_NULL;
+  if (result === void 0 || result === null) return result;
   if ((0, import_rxjs2.isObservable)(result)) {
     return subscribeToFirst(result);
   }
@@ -1454,8 +2602,9 @@ var unwrapResult = (result) => {
       (resolved) => (0, import_rxjs2.isObservable)(resolved) ? subscribeToFirst(resolved) : resolved
     );
   }
-  return Promise.resolve(result);
+  return result;
 };
+var isPromiseLike2 = (value) => value !== null && typeof value === "object" && typeof value.then === "function";
 var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
   let done = false;
   let subscription = null;
@@ -1485,20 +2634,25 @@ var subscribeToFirst = (obs) => new Promise((resolve, reject) => {
 // 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;
+    const derived = deriveOtelAttrs(options);
+    this.otel = derived.otel;
+    this.serviceName = derived.serviceName;
+    this.serverEndpoint = derived.serverEndpoint;
   }
-  logger = new import_common4.Logger("Jetstream:CoreRpc");
+  logger = new import_common8.Logger("Jetstream:CoreRpc");
   subscription = null;
+  otel;
+  serviceName;
+  serverEndpoint;
   /** 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`;
+    const subject = `${this.serviceName}.cmd.>`;
+    const queue = `${this.serviceName}_cmd_queue`;
     this.subscription = nc.subscribe(subject, {
       queue,
       callback: (err, msg) => {
@@ -1543,10 +2697,29 @@ var CoreRpcServer = class {
     }
     const ctx = new RpcContext([msg]);
     try {
-      const result = await unwrapResult(handler(data, ctx));
-      msg.respond(this.codec.encode(result));
+      const raw = await withConsumeSpan(
+        {
+          subject: msg.subject,
+          msg,
+          kind: "rpc" /* Rpc */,
+          payloadBytes: msg.data.length,
+          handlerMetadata: { pattern: msg.subject },
+          serviceName: this.serviceName,
+          endpoint: this.serverEndpoint
+        },
+        this.otel,
+        () => {
+          const out = unwrapResult(handler(data, ctx));
+          return isPromiseLike2(out) ? out : out;
+        }
+      );
+      msg.respond(this.codec.encode(raw));
     } catch (err) {
-      this.logger.error(`Handler error for Core RPC ${msg.subject}:`, err);
+      this.eventBus.emit(
+        "error" /* Error */,
+        err instanceof Error ? err : new Error(String(err)),
+        `core-rpc-handler:${msg.subject}`
+      );
       this.respondWithError(msg, err);
     }
   }
@@ -1563,9 +2736,17 @@ var CoreRpcServer = class {
 };
 
 // src/server/infrastructure/stream.provider.ts
-var import_common6 = require("@nestjs/common");
+var import_common10 = require("@nestjs/common");
 var import_jetstream14 = require("@nats-io/jetstream");
 
+// src/server/infrastructure/nats-error-codes.ts
+var NatsErrorCode = /* @__PURE__ */ ((NatsErrorCode2) => {
+  NatsErrorCode2[NatsErrorCode2["ConsumerNotFound"] = 10014] = "ConsumerNotFound";
+  NatsErrorCode2[NatsErrorCode2["ConsumerAlreadyExists"] = 10148] = "ConsumerAlreadyExists";
+  NatsErrorCode2[NatsErrorCode2["StreamNotFound"] = 10059] = "StreamNotFound";
+  return NatsErrorCode2;
+})(NatsErrorCode || {});
+
 // src/server/infrastructure/stream-config-diff.ts
 var TRANSPORT_CONTROLLED_PROPERTIES = /* @__PURE__ */ new Set([
   "retention"
@@ -1622,7 +2803,7 @@ var isEqual = (a, b) => {
 };
 
 // src/server/infrastructure/stream-migration.ts
-var import_common5 = require("@nestjs/common");
+var import_common9 = require("@nestjs/common");
 var import_jetstream13 = require("@nats-io/jetstream");
 var MIGRATION_BACKUP_SUFFIX = "__migration_backup";
 var DEFAULT_SOURCING_TIMEOUT_MS = 3e4;
@@ -1631,7 +2812,7 @@ var StreamMigration = class {
   constructor(sourcingTimeoutMs = DEFAULT_SOURCING_TIMEOUT_MS) {
     this.sourcingTimeoutMs = sourcingTimeoutMs;
   }
-  logger = new import_common5.Logger("Jetstream:Stream");
+  logger = new import_common9.Logger("Jetstream:Stream");
   async migrate(jsm, streamName2, newConfig) {
     const backupName = `${streamName2}${MIGRATION_BACKUP_SUFFIX}`;
     const startTime = Date.now();
@@ -1713,9 +2894,16 @@ var StreamProvider = class {
   constructor(options, connection) {
     this.options = options;
     this.connection = connection;
+    const derived = deriveOtelAttrs(options);
+    this.otel = derived.otel;
+    this.otelServiceName = derived.serviceName;
+    this.otelEndpoint = derived.serverEndpoint;
   }
-  logger = new import_common6.Logger("Jetstream:Stream");
+  logger = new import_common10.Logger("Jetstream:Stream");
   migration = new StreamMigration();
+  otel;
+  otelServiceName;
+  otelEndpoint;
   /**
    * Ensure all required streams exist with correct configuration.
    *
@@ -1761,32 +2949,56 @@ var StreamProvider = class {
   /** 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 {
-      const currentInfo = await jsm.streams.info(config.name);
-      return await this.handleExistingStream(jsm, currentInfo, config);
-    } catch (err) {
-      if (err instanceof import_jetstream14.JetStreamApiError && err.apiError().err_code === 10059 /* StreamNotFound */) {
-        this.logger.log(`Creating stream: ${config.name}`);
-        return await jsm.streams.add(config);
+    return withProvisioningSpan(
+      this.otel,
+      {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        entity: "stream",
+        name: config.name,
+        action: "ensure"
+      },
+      async () => {
+        this.logger.log(`Ensuring stream: ${config.name}`);
+        try {
+          const currentInfo = await jsm.streams.info(config.name);
+          return await this.handleExistingStream(jsm, currentInfo, config);
+        } catch (err) {
+          if (err instanceof import_jetstream14.JetStreamApiError && err.apiError().err_code === 10059 /* StreamNotFound */) {
+            this.logger.log(`Creating stream: ${config.name}`);
+            return await jsm.streams.add(config);
+          }
+          throw err;
+        }
       }
-      throw err;
-    }
+    );
   }
   /** Ensure a dead-letter queue stream exists, creating or updating as needed. */
   async ensureDlqStream(jsm) {
     const config = this.buildDlqConfig();
-    this.logger.log(`Ensuring DLQ stream: ${config.name}`);
-    try {
-      const currentInfo = await jsm.streams.info(config.name);
-      return await this.handleExistingStream(jsm, currentInfo, config);
-    } catch (err) {
-      if (err instanceof import_jetstream14.JetStreamApiError && err.apiError().err_code === 10059 /* StreamNotFound */) {
-        this.logger.log(`Creating DLQ stream: ${config.name}`);
-        return await jsm.streams.add(config);
+    return withProvisioningSpan(
+      this.otel,
+      {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        entity: "stream",
+        name: config.name,
+        action: "ensure"
+      },
+      async () => {
+        this.logger.log(`Ensuring DLQ stream: ${config.name}`);
+        try {
+          const currentInfo = await jsm.streams.info(config.name);
+          return await this.handleExistingStream(jsm, currentInfo, config);
+        } catch (err) {
+          if (err instanceof import_jetstream14.JetStreamApiError && err.apiError().err_code === 10059 /* StreamNotFound */) {
+            this.logger.log(`Creating DLQ stream: ${config.name}`);
+            return await jsm.streams.add(config);
+          }
+          throw err;
+        }
       }
-      throw err;
-    }
+    );
   }
   async handleExistingStream(jsm, currentInfo, config) {
     const diff = compareStreamConfig(currentInfo.config, config);
@@ -1815,7 +3027,18 @@ var StreamProvider = class {
       }
       return currentInfo;
     }
-    await this.migration.migrate(jsm, config.name, config);
+    await withMigrationSpan(
+      this.otel,
+      {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        stream: config.name,
+        reason: diff.changes.filter((c) => c.mutability === "immutable").map((c) => c.property).join(", ")
+      },
+      async () => {
+        await this.migration.migrate(jsm, config.name, config);
+      }
+    );
     return await jsm.streams.info(config.name);
   }
   buildMutableOnlyConfig(config, currentConfig, diff) {
@@ -1931,7 +3154,7 @@ var StreamProvider = class {
 };
 
 // src/server/infrastructure/consumer.provider.ts
-var import_common7 = require("@nestjs/common");
+var import_common11 = require("@nestjs/common");
 var import_jetstream16 = require("@nats-io/jetstream");
 var ConsumerProvider = class {
   constructor(options, connection, streamProvider, patternRegistry) {
@@ -1939,8 +3162,15 @@ var ConsumerProvider = class {
     this.connection = connection;
     this.streamProvider = streamProvider;
     this.patternRegistry = patternRegistry;
-  }
-  logger = new import_common7.Logger("Jetstream:Consumer");
+    const derived = deriveOtelAttrs(options);
+    this.otel = derived.otel;
+    this.otelServiceName = derived.serviceName;
+    this.otelEndpoint = derived.serverEndpoint;
+  }
+  logger = new import_common11.Logger("Jetstream:Consumer");
+  otel;
+  otelServiceName;
+  otelEndpoint;
   /**
    * Ensure consumers exist for the specified kinds.
    *
@@ -1970,17 +3200,29 @@ var ConsumerProvider = class {
     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 {
-      await jsm.consumers.info(stream, name);
-      this.logger.debug(`Consumer exists, updating: ${name}`);
-      return await jsm.consumers.update(stream, name, config);
-    } catch (err) {
-      if (!(err instanceof import_jetstream16.JetStreamApiError) || err.apiError().err_code !== 10014 /* ConsumerNotFound */) {
-        throw err;
+    return withProvisioningSpan(
+      this.otel,
+      {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        entity: "consumer",
+        name,
+        action: "ensure"
+      },
+      async () => {
+        this.logger.log(`Ensuring consumer: ${name} on stream: ${stream}`);
+        try {
+          await jsm.consumers.info(stream, name);
+          this.logger.debug(`Consumer exists, updating: ${name}`);
+          return await jsm.consumers.update(stream, name, config);
+        } catch (err) {
+          if (!(err instanceof import_jetstream16.JetStreamApiError) || err.apiError().err_code !== 10014 /* ConsumerNotFound */) {
+            throw err;
+          }
+          return await this.createConsumer(jsm, stream, name, config);
+        }
       }
-      return await this.createConsumer(jsm, stream, name, config);
-    }
+    );
   }
   /**
    * Recover a consumer that disappeared during runtime.
@@ -1999,16 +3241,28 @@ var ConsumerProvider = class {
     const stream = this.streamProvider.getStreamName(kind);
     const config = this.buildConfig(kind);
     const name = config.durable_name;
-    this.logger.log(`Recovering consumer: ${name} on stream: ${stream}`);
-    await this.assertNoMigrationInProgress(jsm, stream);
-    try {
-      return await jsm.consumers.info(stream, name);
-    } catch (err) {
-      if (!(err instanceof import_jetstream16.JetStreamApiError) || err.apiError().err_code !== 10014 /* ConsumerNotFound */) {
-        throw err;
+    return withProvisioningSpan(
+      this.otel,
+      {
+        serviceName: this.otelServiceName,
+        endpoint: this.otelEndpoint,
+        entity: "consumer",
+        name,
+        action: "recover"
+      },
+      async () => {
+        this.logger.log(`Recovering consumer: ${name} on stream: ${stream}`);
+        await this.assertNoMigrationInProgress(jsm, stream);
+        try {
+          return await jsm.consumers.info(stream, name);
+        } catch (err) {
+          if (!(err instanceof import_jetstream16.JetStreamApiError) || err.apiError().err_code !== 10014 /* ConsumerNotFound */) {
+            throw err;
+          }
+          return await this.createConsumer(jsm, stream, name, config);
+        }
       }
-      return await this.createConsumer(jsm, stream, name, config);
-    }
+    );
   }
   /**
    * Throw if a migration backup stream exists for this stream.
@@ -2124,7 +3378,7 @@ var ConsumerProvider = class {
 };
 
 // src/server/infrastructure/message.provider.ts
-var import_common8 = require("@nestjs/common");
+var import_common12 = require("@nestjs/common");
 var import_jetstream18 = require("@nats-io/jetstream");
 var import_rxjs3 = require("rxjs");
 var MessageProvider = class {
@@ -2134,7 +3388,7 @@ var MessageProvider = class {
     this.consumeOptionsMap = consumeOptionsMap;
     this.consumerRecoveryFn = consumerRecoveryFn;
   }
-  logger = new import_common8.Logger("Jetstream:Message");
+  logger = new import_common12.Logger("Jetstream:Message");
   activeIterators = /* @__PURE__ */ new Set();
   orderedReadyResolve = null;
   orderedReadyReject = null;
@@ -2254,13 +3508,17 @@ var MessageProvider = class {
     }
     const defaults = { idle_heartbeat: 5e3 };
     const userOptions = this.consumeOptionsMap.get(kind) ?? {};
-    const messages = await consumer.consume({ ...defaults, ...userOptions });
+    const messages = await consumer.consume({
+      ...defaults,
+      ...userOptions,
+      callback: (msg) => {
+        target$.next(msg);
+      }
+    });
     this.activeIterators.add(messages);
     this.monitorConsumerHealth(messages, consumerName2);
     try {
-      for await (const msg of messages) {
-        target$.next(msg);
-      }
+      await messages.closed();
     } finally {
       this.activeIterators.delete(messages);
     }
@@ -2352,11 +3610,16 @@ var MessageProvider = class {
       })
     );
   }
-  /** Single iteration: create ordered consumer -> iterate messages. */
+  /** Single iteration: create ordered consumer -> push messages into the subject. */
   async consumeOrderedOnce(streamName2, consumerOpts) {
     const js = this.connection.getJetStreamClient();
     const consumer = await js.consumers.get(streamName2, consumerOpts);
-    const messages = await consumer.consume();
+    const orderedMessages$ = this.orderedMessages$;
+    const messages = await consumer.consume({
+      callback: (msg) => {
+        orderedMessages$.next(msg);
+      }
+    });
     if (this.orderedReadyResolve) {
       this.orderedReadyResolve();
       this.orderedReadyResolve = null;
@@ -2364,9 +3627,7 @@ var MessageProvider = class {
     }
     this.activeIterators.add(messages);
     try {
-      for await (const msg of messages) {
-        this.orderedMessages$.next(msg);
-      }
+      await messages.closed();
     } finally {
       this.activeIterators.delete(messages);
     }
@@ -2374,7 +3635,7 @@ var MessageProvider = class {
 };
 
 // src/server/infrastructure/metadata.provider.ts
-var import_common9 = require("@nestjs/common");
+var import_common13 = require("@nestjs/common");
 var import_kv = require("@nats-io/kv");
 var MetadataProvider = class {
   constructor(options, connection) {
@@ -2383,7 +3644,7 @@ var MetadataProvider = class {
     this.replicas = options.metadata?.replicas ?? DEFAULT_METADATA_REPLICAS;
     this.ttl = Math.max(options.metadata?.ttl ?? DEFAULT_METADATA_TTL, MIN_METADATA_TTL);
   }
-  logger = new import_common9.Logger("Jetstream:Metadata");
+  logger = new import_common13.Logger("Jetstream:Metadata");
   bucketName;
   replicas;
   ttl;
@@ -2476,7 +3737,7 @@ var MetadataProvider = class {
 };
 
 // src/server/routing/pattern-registry.ts
-var import_common10 = require("@nestjs/common");
+var import_common14 = require("@nestjs/common");
 var HANDLER_LABELS = {
   ["broadcast" /* Broadcast */]: "broadcast" /* Broadcast */,
   ["ordered" /* Ordered */]: "ordered" /* Ordered */,
@@ -2487,7 +3748,7 @@ var PatternRegistry = class {
   constructor(options) {
     this.options = options;
   }
-  logger = new import_common10.Logger("Jetstream:PatternRegistry");
+  logger = new import_common14.Logger("Jetstream:PatternRegistry");
   registry = /* @__PURE__ */ new Map();
   // Cached after registerHandlers() — the registry is immutable from that point
   cachedPatterns = null;
@@ -2644,9 +3905,13 @@ var PatternRegistry = class {
 };
 
 // src/server/routing/event.router.ts
-var import_common11 = require("@nestjs/common");
-var import_rxjs4 = require("rxjs");
+var import_common15 = require("@nestjs/common");
 var import_transport_node4 = require("@nats-io/transport-node");
+var eventConsumeKindFor = (kind) => {
+  if (kind === "broadcast" /* Broadcast */) return "broadcast" /* Broadcast */;
+  if (kind === "ordered" /* Ordered */) return "ordered" /* Ordered */;
+  return "event" /* Event */;
+};
 var EventRouter = class {
   constructor(messageProvider, patternRegistry, codec, eventBus, deadLetterConfig, processingConfig, ackWaitMap, connection, options) {
     this.messageProvider = messageProvider;
@@ -2658,9 +3923,22 @@ var EventRouter = class {
     this.ackWaitMap = ackWaitMap;
     this.connection = connection;
     this.options = options;
+    if (options) {
+      const derived = deriveOtelAttrs(options);
+      this.otel = derived.otel;
+      this.serviceName = derived.serviceName;
+      this.serverEndpoint = derived.serverEndpoint;
+    } else {
+      this.otel = resolveOtelOptions({ enabled: false });
+      this.serviceName = "";
+      this.serverEndpoint = null;
+    }
   }
-  logger = new import_common11.Logger("Jetstream:EventRouter");
+  logger = new import_common15.Logger("Jetstream:EventRouter");
   subscriptions = [];
+  otel;
+  serviceName;
+  serverEndpoint;
   /**
    * Update the max_deliver thresholds from actual NATS consumer configs.
    * Called after consumers are ensured so the DLQ map reflects reality.
@@ -2684,15 +3962,233 @@ var EventRouter = class {
     }
     this.subscriptions.length = 0;
   }
-  /** Subscribe to a message stream and route each message. */
+  /** Subscribe to a message stream and route each message to its handler. */
   subscribeToStream(stream$, kind) {
     const isOrdered = kind === "ordered" /* Ordered */;
+    const patternRegistry = this.patternRegistry;
+    const codec = this.codec;
+    const eventBus = this.eventBus;
+    const logger5 = this.logger;
+    const deadLetterConfig = this.deadLetterConfig;
+    const otel = this.otel;
+    const serviceName = this.serviceName;
+    const serverEndpoint = this.serverEndpoint;
+    const spanKind = eventConsumeKindFor(kind);
     const ackExtensionInterval = isOrdered ? null : resolveAckExtensionInterval(this.getAckExtensionConfig(kind), this.ackWaitMap?.get(kind));
+    const hasAckExtension = ackExtensionInterval !== null && ackExtensionInterval > 0;
     const concurrency = this.getConcurrency(kind);
-    const route = (msg) => (0, import_rxjs4.from)(
-      isOrdered ? this.handleOrderedSafe(msg) : this.handleSafe(msg, ackExtensionInterval, kind)
-    );
-    const subscription = stream$.pipe(isOrdered ? (0, import_rxjs4.concatMap)(route) : (0, import_rxjs4.mergeMap)(route, concurrency)).subscribe();
+    const hasDlqCheck = deadLetterConfig !== void 0;
+    const emitRouted = eventBus.hasHook("messageRouted" /* MessageRouted */);
+    const isDeadLetter = (msg) => {
+      if (!hasDlqCheck) return false;
+      const maxDeliver = deadLetterConfig.maxDeliverByStream?.get(msg.info.stream);
+      if (maxDeliver === void 0 || maxDeliver <= 0) return false;
+      return msg.info.deliveryCount >= maxDeliver;
+    };
+    const handleDeadLetter = hasDlqCheck ? (msg, data, err) => this.handleDeadLetter(msg, data, err) : null;
+    const settleSuccess = (msg, ctx) => {
+      if (ctx.shouldTerminate) msg.term(ctx.terminateReason);
+      else if (ctx.shouldRetry) msg.nak(ctx.retryDelay);
+      else msg.ack();
+    };
+    const settleFailure = async (msg, data, err) => {
+      if (handleDeadLetter !== null && isDeadLetter(msg)) {
+        await handleDeadLetter(msg, data, err);
+        return;
+      }
+      msg.nak();
+    };
+    const resolveEvent = (msg) => {
+      const subject = msg.subject;
+      try {
+        const handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          msg.term(`No handler for event: ${subject}`);
+          logger5.error(`No handler for subject: ${subject}`);
+          return null;
+        }
+        let data;
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          msg.term("Decode error");
+          logger5.error(`Decode error for ${subject}:`, err);
+          return null;
+        }
+        if (emitRouted) eventBus.emitMessageRouted(subject, "event" /* Event */);
+        return { handler, data };
+      } catch (err) {
+        logger5.error(`Unexpected error in ${kind} event router`, err);
+        try {
+          msg.term("Unexpected router error");
+        } catch (termErr) {
+          logger5.error(`Failed to terminate message ${subject}:`, termErr);
+        }
+        return null;
+      }
+    };
+    const handleSafe = (msg) => {
+      const resolved = resolveEvent(msg);
+      if (resolved === null) return void 0;
+      const { handler, data } = resolved;
+      const ctx = new RpcContext([msg]);
+      const stopAckExtension = hasAckExtension ? startAckExtensionTimer(msg, ackExtensionInterval) : null;
+      let pending;
+      try {
+        pending = withConsumeSpan(
+          {
+            subject: msg.subject,
+            msg,
+            info: msg.info,
+            kind: spanKind,
+            payloadBytes: msg.data.length,
+            handlerMetadata: { pattern: msg.subject },
+            serviceName,
+            endpoint: serverEndpoint
+          },
+          otel,
+          () => unwrapResult(handler(data, ctx))
+        );
+      } catch (err) {
+        eventBus.emit(
+          "error" /* Error */,
+          err instanceof Error ? err : new Error(String(err)),
+          `${kind}-handler:${msg.subject}`
+        );
+        return settleFailure(msg, data, err).finally(() => {
+          if (stopAckExtension !== null) stopAckExtension();
+        });
+      }
+      if (!isPromiseLike2(pending)) {
+        settleSuccess(msg, ctx);
+        if (stopAckExtension !== null) stopAckExtension();
+        return void 0;
+      }
+      return pending.then(
+        () => {
+          settleSuccess(msg, ctx);
+          if (stopAckExtension !== null) stopAckExtension();
+        },
+        async (err) => {
+          eventBus.emit(
+            "error" /* Error */,
+            err instanceof Error ? err : new Error(String(err)),
+            `${kind}-handler:${msg.subject}`
+          );
+          try {
+            await settleFailure(msg, data, err);
+          } finally {
+            if (stopAckExtension !== null) stopAckExtension();
+          }
+        }
+      );
+    };
+    const handleOrderedSafe = (msg) => {
+      const subject = msg.subject;
+      let handler;
+      let data;
+      try {
+        handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          logger5.error(`No handler for subject: ${subject}`);
+          return void 0;
+        }
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          logger5.error(`Decode error for ${subject}:`, err);
+          return void 0;
+        }
+        if (emitRouted) eventBus.emitMessageRouted(subject, "event" /* Event */);
+      } catch (err) {
+        logger5.error(`Ordered handler error (${subject}):`, err);
+        return void 0;
+      }
+      const ctx = new RpcContext([msg]);
+      const warnIfSettlementAttempted = () => {
+        if (ctx.shouldRetry || ctx.shouldTerminate) {
+          logger5.warn(
+            `retry()/terminate() ignored for ordered message ${subject} \u2014 ordered consumers auto-acknowledge`
+          );
+        }
+      };
+      let pending;
+      try {
+        pending = withConsumeSpan(
+          {
+            subject: msg.subject,
+            msg,
+            info: msg.info,
+            kind: spanKind,
+            payloadBytes: msg.data.length,
+            handlerMetadata: { pattern: msg.subject },
+            serviceName,
+            endpoint: serverEndpoint
+          },
+          otel,
+          () => unwrapResult(handler(data, ctx))
+        );
+      } catch (err) {
+        logger5.error(`Ordered handler error (${subject}):`, err);
+        return void 0;
+      }
+      if (!isPromiseLike2(pending)) {
+        warnIfSettlementAttempted();
+        return void 0;
+      }
+      return pending.then(warnIfSettlementAttempted, (err) => {
+        logger5.error(`Ordered handler error (${subject}):`, err);
+      });
+    };
+    const route = isOrdered ? handleOrderedSafe : handleSafe;
+    const maxActive = isOrdered ? 1 : concurrency ?? Number.POSITIVE_INFINITY;
+    const backlogWarnThreshold = 1e3;
+    let active = 0;
+    let backlogWarned = false;
+    const backlog = [];
+    const onAsyncDone = () => {
+      active--;
+      drainBacklog();
+    };
+    const drainBacklog = () => {
+      while (active < maxActive) {
+        const next = backlog.shift();
+        if (next === void 0) return;
+        active++;
+        const result = route(next);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+        }
+      }
+      if (backlog.length < backlogWarnThreshold) backlogWarned = false;
+    };
+    const subscription = stream$.subscribe({
+      next: (msg) => {
+        if (active >= maxActive) {
+          backlog.push(msg);
+          if (!backlogWarned && backlog.length >= backlogWarnThreshold) {
+            backlogWarned = true;
+            logger5.warn(
+              `${kind} backlog reached ${backlog.length} messages \u2014 consumer may be falling behind`
+            );
+          }
+          return;
+        }
+        active++;
+        const result = route(msg);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+          if (backlog.length > 0) drainBacklog();
+        }
+      },
+      error: (err) => {
+        logger5.error(`Stream error in ${kind} router`, err);
+      }
+    });
     this.subscriptions.push(subscription);
   }
   getConcurrency(kind) {
@@ -2705,94 +4201,11 @@ var EventRouter = class {
     if (kind === "broadcast" /* Broadcast */) return this.processingConfig?.broadcast?.ackExtension;
     return void 0;
   }
-  /** Handle a single event message with error isolation. */
-  async handleSafe(msg, ackExtensionInterval, kind) {
-    try {
-      const resolved = this.decodeMessage(msg);
-      if (!resolved) return;
-      await this.executeHandler(
-        resolved.handler,
-        resolved.data,
-        resolved.ctx,
-        msg,
-        ackExtensionInterval
-      );
-    } catch (err) {
-      this.logger.error(`Unexpected error in ${kind} event router`, err);
-    }
-  }
-  /** Handle an ordered message with error isolation. */
-  async handleOrderedSafe(msg) {
-    try {
-      const resolved = this.decodeMessage(msg, true);
-      if (!resolved) return;
-      await unwrapResult(resolved.handler(resolved.data, resolved.ctx));
-      if (resolved.ctx.shouldRetry || resolved.ctx.shouldTerminate) {
-        this.logger.warn(
-          `retry()/terminate() ignored for ordered message ${msg.subject} \u2014 ordered consumers auto-acknowledge`
-        );
-      }
-    } catch (err) {
-      this.logger.error(`Ordered handler error (${msg.subject}):`, err);
-    }
-  }
-  /** Resolve handler, decode payload, and build context. Returns null on failure. */
-  decodeMessage(msg, isOrdered = false) {
-    const handler = this.patternRegistry.getHandler(msg.subject);
-    if (!handler) {
-      if (!isOrdered) msg.term(`No handler for event: ${msg.subject}`);
-      this.logger.error(`No handler for subject: ${msg.subject}`);
-      return null;
-    }
-    let data;
-    try {
-      data = this.codec.decode(msg.data);
-    } catch (err) {
-      if (!isOrdered) msg.term("Decode error");
-      this.logger.error(`Decode error for ${msg.subject}:`, err);
-      return null;
-    }
-    this.eventBus.emitMessageRouted(msg.subject, "event" /* Event */);
-    return { handler, data, ctx: new RpcContext([msg]) };
-  }
-  /** Execute handler, then ack on success or nak/dead-letter on failure. */
-  async executeHandler(handler, data, ctx, msg, ackExtensionInterval) {
-    const stopAckExtension = startAckExtensionTimer(msg, ackExtensionInterval);
-    try {
-      await unwrapResult(handler(data, ctx));
-      if (ctx.shouldTerminate) {
-        msg.term(ctx.terminateReason);
-      } else if (ctx.shouldRetry) {
-        msg.nak(ctx.retryDelay);
-      } else {
-        msg.ack();
-      }
-    } catch (err) {
-      this.logger.error(`Event handler error (${msg.subject}):`, err);
-      if (this.isDeadLetter(msg)) {
-        await this.handleDeadLetter(msg, data, err);
-      } else {
-        msg.nak();
-      }
-    } finally {
-      stopAckExtension?.();
-    }
-  }
-  /** Check if the message has exhausted all delivery attempts. */
-  isDeadLetter(msg) {
-    if (!this.deadLetterConfig) return false;
-    const maxDeliver = this.deadLetterConfig.maxDeliverByStream.get(msg.info.stream);
-    if (maxDeliver === void 0 || maxDeliver <= 0) return false;
-    return msg.info.deliveryCount >= maxDeliver;
-  }
-  /** Handle a dead letter: invoke callback, then term or nak based on result. */
   /**
-   * Fallback execution for a dead letter when DLQ is disabled, or when
-   * publishing to the DLQ stream fails (due to network or NATS errors).
-   *
-   * Triggers the user-provided `onDeadLetter` hook for logging/alerting.
-   * On success, terminates the message. On error, leaves it unacknowledged (nak)
-   * so NATS can retry the delivery on the next cycle.
+   * Last-resort path for a dead letter: invoke `onDeadLetter`, then `term` on
+   * success or `nak` on hook failure so NATS retries on the next delivery
+   * cycle. Used when DLQ stream isn't configured, or when publishing to it
+   * failed and we still have to surface the message somewhere observable.
    */
   async fallbackToOnDeadLetterCallback(info, msg) {
     if (!this.deadLetterConfig) {
@@ -2884,21 +4297,37 @@ var EventRouter = class {
       streamSequence: msg.info.streamSequence,
       timestamp: new Date(msg.info.timestampNanos / 1e6).toISOString()
     };
-    this.eventBus.emit("deadLetter" /* DeadLetter */, info);
-    if (!this.options?.dlq) {
-      await this.fallbackToOnDeadLetterCallback(info, msg);
-    } else {
-      await this.publishToDlq(msg, info, error);
-    }
+    await withDeadLetterSpan(
+      {
+        msg,
+        // Pattern resolution mirrors event-routing: when a registered
+        // pattern matches, surface it on the DLQ span so APM can filter
+        // dead letters by handler without parsing the subject. Falls back
+        // to the subject itself when no glob handler is in play.
+        pattern: this.patternRegistry.getHandler(msg.subject) ? msg.subject : void 0,
+        finalDeliveryCount: msg.info.deliveryCount,
+        reason: error instanceof Error ? error.message : String(error),
+        serviceName: this.serviceName,
+        endpoint: this.serverEndpoint
+      },
+      this.otel,
+      async () => {
+        this.eventBus.emit("deadLetter" /* DeadLetter */, info);
+        if (!this.options?.dlq) {
+          await this.fallbackToOnDeadLetterCallback(info, msg);
+        } else {
+          await this.publishToDlq(msg, info, error);
+        }
+      }
+    );
   }
 };
 
 // src/server/routing/rpc.router.ts
-var import_common12 = require("@nestjs/common");
+var import_common16 = require("@nestjs/common");
 var import_transport_node5 = require("@nats-io/transport-node");
-var import_rxjs5 = require("rxjs");
 var RpcRouter = class {
-  constructor(messageProvider, patternRegistry, connection, codec, eventBus, rpcOptions, ackWaitMap) {
+  constructor(messageProvider, patternRegistry, connection, codec, eventBus, rpcOptions, ackWaitMap, options) {
     this.messageProvider = messageProvider;
     this.patternRegistry = patternRegistry;
     this.connection = connection;
@@ -2908,13 +4337,26 @@ var RpcRouter = class {
     this.ackWaitMap = ackWaitMap;
     this.timeout = rpcOptions?.timeout ?? DEFAULT_JETSTREAM_RPC_TIMEOUT;
     this.concurrency = rpcOptions?.concurrency;
+    if (options) {
+      const derived = deriveOtelAttrs(options);
+      this.otel = derived.otel;
+      this.serviceName = derived.serviceName;
+      this.serverEndpoint = derived.serverEndpoint;
+    } else {
+      this.otel = resolveOtelOptions({ enabled: false });
+      this.serviceName = "";
+      this.serverEndpoint = null;
+    }
   }
-  logger = new import_common12.Logger("Jetstream:RpcRouter");
+  logger = new import_common16.Logger("Jetstream:RpcRouter");
   timeout;
   concurrency;
   resolvedAckExtensionInterval;
   subscription = null;
   cachedNc = null;
+  otel;
+  serviceName;
+  serverEndpoint;
   /** Lazily resolve the ack extension interval (needs ackWaitMap populated at runtime). */
   get ackExtensionInterval() {
     if (this.resolvedAckExtensionInterval !== void 0) return this.resolvedAckExtensionInterval;
@@ -2927,99 +4369,213 @@ var RpcRouter = class {
   /** Start routing command messages to handlers. */
   async start() {
     this.cachedNc = await this.connection.getConnection();
-    this.subscription = this.messageProvider.commands$.pipe((0, import_rxjs5.mergeMap)((msg) => (0, import_rxjs5.from)(this.handleSafe(msg)), this.concurrency)).subscribe();
-  }
-  /** Stop routing and unsubscribe. */
-  destroy() {
-    this.subscription?.unsubscribe();
-    this.subscription = null;
-  }
-  /** Handle a single RPC command message with error isolation. */
-  async handleSafe(msg) {
-    try {
-      const handler = this.patternRegistry.getHandler(msg.subject);
-      if (!handler) {
-        msg.term(`No handler for RPC: ${msg.subject}`);
-        this.logger.error(`No handler for RPC subject: ${msg.subject}`);
-        return;
-      }
-      const { headers: msgHeaders } = msg;
-      const replyTo = msgHeaders?.get("x-reply-to" /* ReplyTo */);
-      const correlationId = msgHeaders?.get("x-correlation-id" /* CorrelationId */);
-      if (!replyTo || !correlationId) {
-        msg.term("Missing required headers (reply-to or correlation-id)");
-        this.logger.error(`Missing headers for RPC: ${msg.subject}`);
-        return;
-      }
-      let data;
-      try {
-        data = this.codec.decode(msg.data);
-      } catch (err) {
-        msg.term("Decode error");
-        this.logger.error(`Decode error for RPC ${msg.subject}:`, err);
-        return;
-      }
-      this.eventBus.emitMessageRouted(msg.subject, "rpc" /* Rpc */);
-      await this.executeHandler(handler, data, msg, replyTo, correlationId);
-    } catch (err) {
-      this.logger.error("Unexpected error in RPC router", err);
-    }
-  }
-  /** Execute handler, publish response, settle message. */
-  async executeHandler(handler, data, msg, replyTo, correlationId) {
-    const nc = this.cachedNc ?? await this.connection.getConnection();
-    const ctx = new RpcContext([msg]);
-    let settled = false;
-    const stopAckExtension = startAckExtensionTimer(msg, this.ackExtensionInterval);
-    const timeoutId = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      stopAckExtension?.();
-      this.logger.error(`RPC timeout (${this.timeout}ms): ${msg.subject}`);
-      this.eventBus.emit("rpcTimeout" /* RpcTimeout */, msg.subject, correlationId);
-      msg.term("Handler timeout");
-    }, this.timeout);
-    try {
-      const result = await unwrapResult(handler(data, ctx));
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeoutId);
-      stopAckExtension?.();
-      msg.ack();
+    const nc = this.cachedNc;
+    const patternRegistry = this.patternRegistry;
+    const codec = this.codec;
+    const eventBus = this.eventBus;
+    const logger5 = this.logger;
+    const timeout = this.timeout;
+    const ackExtensionInterval = this.ackExtensionInterval;
+    const hasAckExtension = ackExtensionInterval !== null && ackExtensionInterval > 0;
+    const maxActive = this.concurrency ?? Number.POSITIVE_INFINITY;
+    const otel = this.otel;
+    const serviceName = this.serviceName;
+    const serverEndpoint = this.serverEndpoint;
+    const emitRpcTimeout = (subject, correlationId) => {
+      eventBus.emit("rpcTimeout" /* RpcTimeout */, subject, correlationId);
+    };
+    const publishReply = (replyTo, correlationId, payload) => {
       try {
         const hdrs = (0, import_transport_node5.headers)();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
-        nc.publish(replyTo, this.codec.encode(result), { headers: hdrs });
+        nc.publish(replyTo, codec.encode(payload), { headers: hdrs });
       } catch (publishErr) {
-        this.logger.error(`Failed to publish RPC response for ${msg.subject}`, publishErr);
+        logger5.error(`Failed to publish RPC response`, publishErr);
       }
-    } catch (err) {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeoutId);
-      stopAckExtension?.();
+    };
+    const publishErrorReply = (replyTo, correlationId, subject, err) => {
       try {
         const hdrs = (0, import_transport_node5.headers)();
         hdrs.set("x-correlation-id" /* CorrelationId */, correlationId);
         hdrs.set("x-error" /* Error */, "true");
-        nc.publish(replyTo, this.codec.encode(serializeError(err)), { headers: hdrs });
+        nc.publish(replyTo, codec.encode(serializeError(err)), { headers: hdrs });
       } catch (encodeErr) {
-        this.logger.error(`Failed to encode RPC error for ${msg.subject}`, encodeErr);
+        logger5.error(`Failed to encode RPC error for ${subject}`, encodeErr);
       }
-      msg.term(`Handler error: ${msg.subject}`);
-    }
+    };
+    const resolveCommand = (msg) => {
+      const subject = msg.subject;
+      try {
+        const handler = patternRegistry.getHandler(subject);
+        if (!handler) {
+          msg.term(`No handler for RPC: ${subject}`);
+          logger5.error(`No handler for RPC subject: ${subject}`);
+          return null;
+        }
+        const msgHeaders = msg.headers;
+        const replyTo = msgHeaders?.get("x-reply-to" /* ReplyTo */);
+        const correlationId = msgHeaders?.get("x-correlation-id" /* CorrelationId */);
+        if (!replyTo || !correlationId) {
+          msg.term("Missing required headers (reply-to or correlation-id)");
+          logger5.error(`Missing headers for RPC: ${subject}`);
+          return null;
+        }
+        let data;
+        try {
+          data = codec.decode(msg.data);
+        } catch (err) {
+          msg.term("Decode error");
+          logger5.error(`Decode error for RPC ${subject}:`, err);
+          return null;
+        }
+        eventBus.emitMessageRouted(subject, "rpc" /* Rpc */);
+        return { handler, data, replyTo, correlationId };
+      } catch (err) {
+        logger5.error("Unexpected error in RPC router", err);
+        try {
+          msg.term("Unexpected router error");
+        } catch (termErr) {
+          logger5.error(`Failed to terminate RPC message ${subject}:`, termErr);
+        }
+        return null;
+      }
+    };
+    const handleSafe = (msg) => {
+      const resolved = resolveCommand(msg);
+      if (resolved === null) return void 0;
+      const { handler, data, replyTo, correlationId } = resolved;
+      const subject = msg.subject;
+      const ctx = new RpcContext([msg]);
+      const stopAckExtension = hasAckExtension ? startAckExtensionTimer(msg, ackExtensionInterval) : null;
+      const reportHandlerError = (err) => {
+        eventBus.emit(
+          "error" /* Error */,
+          err instanceof Error ? err : new Error(String(err)),
+          `rpc-handler:${subject}`
+        );
+        publishErrorReply(replyTo, correlationId, subject, err);
+        msg.term(`Handler error: ${subject}`);
+      };
+      const abortController = new AbortController();
+      let pending;
+      try {
+        pending = withConsumeSpan(
+          {
+            subject,
+            msg,
+            info: msg.info,
+            kind: "rpc" /* Rpc */,
+            payloadBytes: msg.data.length,
+            handlerMetadata: { pattern: subject },
+            serviceName,
+            endpoint: serverEndpoint
+          },
+          otel,
+          () => unwrapResult(handler(data, ctx)),
+          { signal: abortController.signal, timeoutLabel: "rpc.handler.timeout" }
+        );
+      } catch (err) {
+        if (stopAckExtension !== null) stopAckExtension();
+        reportHandlerError(err);
+        return void 0;
+      }
+      if (!isPromiseLike2(pending)) {
+        if (stopAckExtension !== null) stopAckExtension();
+        msg.ack();
+        publishReply(replyTo, correlationId, pending);
+        return void 0;
+      }
+      let settled = false;
+      const timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        if (stopAckExtension !== null) stopAckExtension();
+        abortController.abort();
+        emitRpcTimeout(subject, correlationId);
+        msg.term("Handler timeout");
+      }, timeout);
+      return pending.then(
+        (result) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeoutId);
+          if (stopAckExtension !== null) stopAckExtension();
+          msg.ack();
+          publishReply(replyTo, correlationId, result);
+        },
+        (err) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeoutId);
+          if (stopAckExtension !== null) stopAckExtension();
+          reportHandlerError(err);
+        }
+      );
+    };
+    const backlogWarnThreshold = 1e3;
+    let active = 0;
+    let backlogWarned = false;
+    const backlog = [];
+    const onAsyncDone = () => {
+      active--;
+      drainBacklog();
+    };
+    const drainBacklog = () => {
+      while (active < maxActive) {
+        const next = backlog.shift();
+        if (next === void 0) return;
+        active++;
+        const result = handleSafe(next);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+        }
+      }
+      if (backlog.length < backlogWarnThreshold) backlogWarned = false;
+    };
+    this.subscription = this.messageProvider.commands$.subscribe({
+      next: (msg) => {
+        if (active >= maxActive) {
+          backlog.push(msg);
+          if (!backlogWarned && backlog.length >= backlogWarnThreshold) {
+            backlogWarned = true;
+            logger5.warn(
+              `RPC backlog reached ${backlog.length} messages \u2014 consumer may be falling behind`
+            );
+          }
+          return;
+        }
+        active++;
+        const result = handleSafe(msg);
+        if (result !== void 0) {
+          void result.finally(onAsyncDone);
+        } else {
+          active--;
+          if (backlog.length > 0) drainBacklog();
+        }
+      },
+      error: (err) => {
+        logger5.error("Stream error in RPC router", err);
+      }
+    });
+  }
+  /** Stop routing and unsubscribe. */
+  destroy() {
+    this.subscription?.unsubscribe();
+    this.subscription = null;
   }
 };
 
 // src/shutdown/shutdown.manager.ts
-var import_common13 = require("@nestjs/common");
+var import_common17 = require("@nestjs/common");
 var ShutdownManager = class {
   constructor(connection, eventBus, timeout) {
     this.connection = connection;
     this.eventBus = eventBus;
     this.timeout = timeout;
   }
-  logger = new import_common13.Logger("Jetstream:Shutdown");
+  logger = new import_common17.Logger("Jetstream:Shutdown");
   shutdownPromise;
   /**
    * Execute the full shutdown sequence.
@@ -3059,9 +4615,6 @@ var JetstreamModule = class {
     this.shutdownManager = shutdownManager;
     this.strategy = strategy;
   }
-  // -------------------------------------------------------------------
-  // forRoot — global module registration
-  // -------------------------------------------------------------------
   /**
    * Register the JetStream transport globally.
    *
@@ -3088,9 +4641,6 @@ var JetstreamModule = class {
       ]
     };
   }
-  // -------------------------------------------------------------------
-  // forRootAsync — async global module registration
-  // -------------------------------------------------------------------
   /**
    * Register the JetStream transport globally with async configuration.
    *
@@ -3119,9 +4669,6 @@ var JetstreamModule = class {
       ]
     };
   }
-  // -------------------------------------------------------------------
-  // forFeature — per-module client registration
-  // -------------------------------------------------------------------
   /**
    * Register a lightweight client proxy for a target service.
    *
@@ -3147,9 +4694,6 @@ var JetstreamModule = class {
       exports: [clientToken]
     };
   }
-  // -------------------------------------------------------------------
-  // Provider factories
-  // -------------------------------------------------------------------
   static createCoreProviders(options) {
     return [
       {
@@ -3167,8 +4711,8 @@ var JetstreamModule = class {
         provide: JETSTREAM_EVENT_BUS,
         inject: [JETSTREAM_OPTIONS],
         useFactory: (options) => {
-          const logger = new import_common14.Logger("Jetstream:Module");
-          return new EventBus(logger, options.hooks);
+          const logger5 = new import_common18.Logger("Jetstream:Module");
+          return new EventBus(logger5, options.hooks);
         }
       },
       // Codec — global encode/decode
@@ -3207,10 +4751,8 @@ var JetstreamModule = class {
           );
         }
       },
-      // ---------------------------------------------------------------
       // Consumer infrastructure — only created when consumer !== false.
       // Providers return null when consumer is disabled (publisher-only mode).
-      // ---------------------------------------------------------------
       // PatternRegistry — subject-to-handler mapping
       {
         provide: PatternRegistry,
@@ -3246,8 +4788,14 @@ var JetstreamModule = class {
       // MessageProvider — pull-based message consumption
       {
         provide: MessageProvider,
-        inject: [JETSTREAM_OPTIONS, JETSTREAM_CONNECTION, JETSTREAM_EVENT_BUS, ConsumerProvider],
-        useFactory: (options, connection, eventBus, consumerProvider) => {
+        inject: [
+          JETSTREAM_OPTIONS,
+          JETSTREAM_CONNECTION,
+          JETSTREAM_EVENT_BUS,
+          ConsumerProvider,
+          StreamProvider
+        ],
+        useFactory: (options, connection, eventBus, consumerProvider, streamProvider) => {
           if (options.consumer === false) return null;
           const consumeOptionsMap = /* @__PURE__ */ new Map();
           if (options.events?.consume)
@@ -3257,10 +4805,22 @@ var JetstreamModule = class {
           if (options.rpc?.mode === "jetstream" && options.rpc.consume) {
             consumeOptionsMap.set("cmd" /* Command */, options.rpc.consume);
           }
-          const consumerRecoveryFn = consumerProvider ? async (kind) => {
-            const jsm = await connection.getJetStreamManager();
-            return consumerProvider.recoverConsumer(jsm, kind);
-          } : void 0;
+          const derived = deriveOtelAttrs(options);
+          const { otel, serverEndpoint: otelEndpoint, serviceName: otelServiceName } = derived;
+          const consumerRecoveryFn = consumerProvider && streamProvider ? async (kind) => withSelfHealingSpan(
+            otel,
+            {
+              serviceName: otelServiceName,
+              endpoint: otelEndpoint,
+              consumer: consumerProvider.getConsumerName(kind),
+              stream: streamProvider.getStreamName(kind),
+              reason: "consumer not found"
+            },
+            async () => {
+              const jsm = await connection.getJetStreamManager();
+              return consumerProvider.recoverConsumer(jsm, kind);
+            }
+          ) : void 0;
           return new MessageProvider(connection, eventBus, consumeOptionsMap, consumerRecoveryFn);
         }
       },
@@ -3331,7 +4891,8 @@ var JetstreamModule = class {
             codec,
             eventBus,
             rpcOptions,
-            ackWaitMap
+            ackWaitMap,
+            options
           );
         }
       },
@@ -3434,9 +4995,6 @@ var JetstreamModule = class {
       }
     ];
   }
-  // -------------------------------------------------------------------
-  // Lifecycle hooks
-  // -------------------------------------------------------------------
   /**
    * Gracefully shut down the transport on application termination.
    */
@@ -3447,23 +5005,34 @@ var JetstreamModule = class {
   }
 };
 JetstreamModule = __decorateClass([
-  (0, import_common14.Global)(),
-  (0, import_common14.Module)({}),
-  __decorateParam(0, (0, import_common14.Optional)()),
-  __decorateParam(0, (0, import_common14.Inject)(ShutdownManager)),
-  __decorateParam(1, (0, import_common14.Optional)()),
-  __decorateParam(1, (0, import_common14.Inject)(JetstreamStrategy))
+  (0, import_common18.Global)(),
+  (0, import_common18.Module)({}),
+  __decorateParam(0, (0, import_common18.Optional)()),
+  __decorateParam(0, (0, import_common18.Inject)(ShutdownManager)),
+  __decorateParam(1, (0, import_common18.Optional)()),
+  __decorateParam(1, (0, import_common18.Inject)(JetstreamStrategy))
 ], JetstreamModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConsumeKind,
+  DEFAULT_BROADCAST_CONSUMER_CONFIG,
+  DEFAULT_BROADCAST_STREAM_CONFIG,
+  DEFAULT_COMMAND_CONSUMER_CONFIG,
+  DEFAULT_COMMAND_STREAM_CONFIG,
+  DEFAULT_DLQ_STREAM_CONFIG,
+  DEFAULT_EVENT_CONSUMER_CONFIG,
+  DEFAULT_EVENT_STREAM_CONFIG,
+  DEFAULT_JETSTREAM_RPC_TIMEOUT,
   DEFAULT_METADATA_BUCKET,
   DEFAULT_METADATA_HISTORY,
   DEFAULT_METADATA_REPLICAS,
   DEFAULT_METADATA_TTL,
-  EventBus,
+  DEFAULT_ORDERED_STREAM_CONFIG,
+  DEFAULT_RPC_TIMEOUT,
+  DEFAULT_SHUTDOWN_TIMEOUT,
+  DEFAULT_TRACES,
   JETSTREAM_CODEC,
   JETSTREAM_CONNECTION,
-  JETSTREAM_EVENT_BUS,
   JETSTREAM_OPTIONS,
   JetstreamClient,
   JetstreamDlqHeader,
@@ -3473,12 +5042,18 @@ JetstreamModule = __decorateClass([
   JetstreamRecord,
   JetstreamRecordBuilder,
   JetstreamStrategy,
+  JetstreamTrace,
   JsonCodec,
   MIN_METADATA_TTL,
   MessageKind,
+  MsgpackCodec,
+  NatsErrorCode,
   PatternPrefix,
+  PublishKind,
+  RESERVED_HEADERS,
   RpcContext,
   StreamKind,
+  TRACER_NAME,
   TransportEvent,
   buildBroadcastSubject,
   buildSubject,