@horizon-republic/nestjs-jetstream 2.9.1 → 2.10.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { ModuleMetadata, FactoryProvider, Type, Logger, OnApplicationShutdown, DynamicModule } from '@nestjs/common';
-import { MsgHdrs, ConnectionOptions, NatsConnection, Status, Msg } from '@nats-io/transport-node';
-import { StreamConfig, ConsumerConfig, ConsumeOptions, DeliverPolicy, ReplayPolicy, JetStreamManager, JetStreamClient, ConsumerInfo, JsMsg } from '@nats-io/jetstream';
-import { MessageHandler, Server, CustomTransportStrategy, ClientProxy, ReadPacket, WritePacket, BaseRpcContext } from '@nestjs/microservices';
+import { Logger, ModuleMetadata, FactoryProvider, Type, OnApplicationShutdown, DynamicModule } from '@nestjs/common';
+import { MsgHdrs, NatsConnection, Status, ConnectionOptions, Msg } from '@nats-io/transport-node';
+import { JetStreamManager, JetStreamClient, StreamConfig, ConsumerConfig, ConsumeOptions, DeliverPolicy, ReplayPolicy, ConsumerInfo, JsMsg } from '@nats-io/jetstream';
+import { Span } from '@opentelemetry/api';
+import { ClientProxy, ReadPacket, WritePacket, MessageHandler, Server, CustomTransportStrategy, BaseRpcContext } from '@nestjs/microservices';
 import { Observable } from 'rxjs';
 
 /**
@@ -118,176 +119,859 @@ interface JetstreamHealthStatus {
 }
 
 /**
- * Stream config overrides exposed to users.
- *
- * `retention` is excluded because it is controlled by the transport layer
- * (Workqueue for events/commands, Limits for broadcast/ordered).
- * Any `retention` value provided at runtime is silently stripped.
+ * Instrumentation scope name reported on every span the library emits.
+ * Matches the npm package name — the convention used by
+ * `@opentelemetry/instrumentation-*` and most third-party instrumentations.
  */
-type StreamConfigOverrides = Partial<Omit<StreamConfig, 'retention'>>;
+declare const TRACER_NAME = "@horizon-republic/nestjs-jetstream";
+
 /**
- * RPC transport configuration.
+ * Enumeration of OpenTelemetry trace kinds this library can emit.
  *
- * Discriminated union on `mode`:
- * - `'core'`      — NATS native request/reply. Lowest latency.
- * - `'jetstream'`  — Commands persisted in JetStream. Responses via Core NATS inbox.
+ * Each identifier is toggleable via `otel.traces`. Functional kinds (publish,
+ * consume, RPC client round-trip, dead letter) are enabled by default;
+ * infrastructure kinds (connection lifecycle, self-healing, provisioning,
+ * migration, shutdown) are opt-in.
  *
- * When `mode` is `'core'`, only `timeout` is available.
- * When `mode` is `'jetstream'`, additional stream/consumer overrides are exposed.
+ * @example
+ *   JetstreamModule.forRoot({
+ *     otel: {
+ *       traces: [JetstreamTrace.Publish, JetstreamTrace.Consume, JetstreamTrace.ConnectionLifecycle],
+ *     },
+ *   })
  */
-type RpcConfig = {
-    mode: 'core';
-    /** Request timeout in ms. Default: 30_000. */
-    timeout?: number;
-} | {
-    mode: 'jetstream';
-    /** Handler timeout in ms. Default: 180_000 (3 min). */
-    timeout?: number;
-    /** Raw NATS StreamConfig overrides for the command stream. */
-    stream?: StreamConfigOverrides;
-    /** Raw NATS ConsumerConfig overrides for the command consumer. */
-    consumer?: Partial<ConsumerConfig>;
-    /** Options passed to the nats.js `consumer.consume()` call for the command consumer. */
-    consume?: Partial<ConsumeOptions>;
-    /** Maximum number of concurrent RPC handler executions. */
-    concurrency?: number;
+declare enum JetstreamTrace {
+    /** `PRODUCER` span around each `emit()` / `send()` publish operation. Default: ON. */
+    Publish = "publish",
     /**
-     * Auto-extend ack deadline via `msg.working()` during RPC handler execution.
-     * The RPC handler timeout (`setTimeout` + `msg.term()`) still acts as the hard cap.
+     * `CONSUMER` span around each message delivery to a handler. Retries
+     * produce separate spans with `messaging.nats.message.delivery_count > 1`.
+     * Default: ON.
      */
-    ackExtension?: boolean | number;
-};
-/** Overrides for JetStream stream and consumer configuration. */
-interface StreamConsumerOverrides {
-    stream?: StreamConfigOverrides;
-    consumer?: Partial<ConsumerConfig>;
+    Consume = "consume",
     /**
-     * Options passed to the nats.js `consumer.consume()` call.
-     * Controls prefetch buffer size, idle heartbeat interval, and auto-refill thresholds.
-     *
-     * nats.js supports two consumption modes (message-based and byte-based).
-     * Do not mix `max_bytes`/`threshold_bytes` with `threshold_messages` —
-     * use one mode or the other.
-     *
-     * @see https://github.com/nats-io/nats.js — ConsumeOptions
+     * `CLIENT` span covering a full RPC round-trip on the caller side
+     * (`client.send()` → reply received). Wraps the inner publish.
+     * Default: ON.
      */
-    consume?: Partial<ConsumeOptions>;
+    RpcClientSend = "rpc.client.send",
     /**
-     * Maximum number of concurrent handler executions (RxJS `mergeMap` limit).
-     *
-     * Default: `undefined` (unlimited — naturally bounded by `max_ack_pending`).
-     * Set this to protect downstream systems from overload.
-     *
-     * **Important:** if `concurrency < max_ack_pending`, messages buffer in RxJS
-     * while their NATS ack timer ticks. Increase `ack_wait` proportionally to
-     * prevent unnecessary redeliveries.
+     * `INTERNAL` span emitted when a message exhausts `maxDeliver` and is
+     * dead-lettered. Captures the duration of the `onDeadLetter` callback.
+     * Default: ON.
      */
-    concurrency?: number;
+    DeadLetter = "dead_letter",
     /**
-     * Auto-extend the NATS ack deadline via `msg.working()` during handler execution.
-     *
-     * - `false` (default): disabled — NATS redelivers after `ack_wait` if not acked.
-     * - `true`: auto-extend at `ack_wait / 2` interval (calculated from consumer config).
-     * - `number`: explicit extension interval in milliseconds.
+     * `INTERNAL` span spanning one NATS connection session. Emits events on
+     * connect, reconnect, disconnect. Default: OFF.
      */
-    ackExtension?: boolean | number;
+    ConnectionLifecycle = "connection.lifecycle",
+    /**
+     * `INTERNAL` span per consumer recovery attempt following a transient
+     * failure (deleted consumer, missed heartbeat). Default: OFF.
+     */
+    SelfHealing = "self_healing",
+    /** `INTERNAL` span per stream or consumer provisioning / update at startup. Default: OFF. */
+    Provisioning = "provisioning",
+    /** `INTERNAL` span covering a destructive migration flow. Default: OFF. */
+    Migration = "migration",
+    /** `INTERNAL` span covering the graceful shutdown sequence. Default: OFF. */
+    Shutdown = "shutdown"
 }
 /**
- * Configuration for ordered event consumers.
+ * The set of trace kinds enabled when `otel.traces` is not configured
+ * (or set to `'default'`). Covers message-flow operations; infrastructure
+ * spans are opt-in.
+ */
+declare const DEFAULT_TRACES: readonly JetstreamTrace[];
+
+/**
+ * Central event bus for transport lifecycle notifications.
  *
- * Ordered consumers use Limits retention and deliver messages in strict
- * sequential order with at-most-once delivery. No ack/nak/DLQ.
+ * Dispatches events to user-provided hooks. Events without a
+ * registered hook are silently ignored — no default logging.
  *
- * Only a subset of consumer options applies — ordered consumers are
- * ephemeral and auto-managed by nats.js.
+ * @example
+ * ```typescript
+ * const bus = new EventBus(logger, {
+ *   [TransportEvent.Error]: (err) => sentry.captureException(err),
+ * });
+ *
+ * bus.emit(TransportEvent.Error, new Error('timeout'), 'rpc-router');
+ * // → calls sentry
+ *
+ * bus.emit(TransportEvent.Connect, 'nats://localhost:4222');
+ * // → no-op (no hook registered)
+ * ```
  */
-interface OrderedEventOverrides {
-    /** Stream overrides (e.g. `max_age`, `max_bytes`). */
-    stream?: StreamConfigOverrides;
-    /**
-     * Where to start reading when the consumer is (re)created.
-     * @default DeliverPolicy.All
-     */
-    deliverPolicy?: DeliverPolicy;
+declare class EventBus {
+    private readonly hooks;
+    private readonly logger;
+    constructor(logger: Logger, hooks?: Partial<TransportHooks>);
     /**
-     * Start sequence number. Only used when `deliverPolicy` is `StartSequence`.
+     * Emit a lifecycle event. Dispatches to custom hook if registered, otherwise no-op.
+     *
+     * @param event - The {@link TransportEvent} to emit.
+     * @param args - Arguments matching the hook signature for this event.
      */
-    optStartSeq?: number;
+    emit<K extends keyof TransportHooks>(event: K, ...args: Parameters<TransportHooks[K]>): void;
     /**
-     * Start time (ISO string). Only used when `deliverPolicy` is `StartTime`.
+     * Hot-path optimized emit for MessageRouted events.
+     * Avoids rest/spread overhead of the generic `emit()`.
      */
-    optStartTime?: string;
+    emitMessageRouted(subject: string, kind: MessageKind): void;
     /**
-     * Replay policy for historical messages.
-     * @default ReplayPolicy.Instant
+     * 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.
      */
-    replayPolicy?: ReplayPolicy;
+    hasHook(event: keyof TransportHooks): boolean;
+    private callHook;
 }
+
 /**
- * Configuration for the handler metadata KV registry.
+ * Manages the lifecycle of a single NATS connection shared across the application.
  *
- * When any handler has `meta` in its extras, the transport writes metadata
- * entries to a NATS KV bucket at startup. External services (API gateways,
- * dashboards) can watch the bucket for service discovery.
+ * Provides both Promise-based and Observable-based access to the connection:
+ * - `connect()` / `getConnection()` — async/await for one-time setup
+ * - `nc$` — cached observable (shareReplay) for reactive consumers
+ * - `status$` — live connection status event stream
  *
- * All fields are optional — sensible defaults are applied.
+ * One instance per application, created by `JetstreamModule.forRoot()`.
  */
-interface MetadataRegistryOptions {
+declare class ConnectionProvider {
+    private readonly options;
+    private readonly eventBus;
+    /** Cached observable that replays the established connection to new subscribers. */
+    readonly nc$: Observable<NatsConnection>;
+    /** Live stream of connection status events (no replay). */
+    readonly status$: Observable<Status>;
+    private readonly logger;
+    private connection;
+    private connectionPromise;
+    private jsClient;
+    private jsmInstance;
+    private jsmPromise;
+    private readonly otel;
+    private readonly otelServiceName;
+    private readonly otelEndpoint;
+    private lifecycleSpan;
+    constructor(options: JetstreamModuleOptions, eventBus: EventBus);
     /**
-     * KV bucket name.
-     * @default 'handler_registry'
+     * Establish NATS connection. Idempotent — returns cached connection on subsequent calls.
+     *
+     * @throws Error if connection is refused (fail fast).
      */
-    bucket?: string;
+    getConnection(): Promise<NatsConnection>;
     /**
-     * Number of KV bucket replicas. Must be an odd number (1, 3, 5, 7, ...).
-     * Requires a NATS cluster with at least this many nodes.
-     * @default 1
+     * Get the JetStream manager. Cached after first call.
+     *
+     * @returns The JetStreamManager for stream/consumer administration.
      */
-    replicas?: number;
+    getJetStreamManager(): Promise<JetStreamManager>;
     /**
-     * KV bucket TTL in milliseconds.
+     * Get a cached JetStream client.
      *
-     * Entries expire automatically unless refreshed by a heartbeat.
-     * The transport refreshes entries every `ttl / 2` while the pod is alive.
-     * When the pod stops (graceful or crash), entries expire after this duration.
+     * Invalidated automatically on reconnect and shutdown so consumers always
+     * operate against the live connection.
      *
-     * @default 30_000 (30 seconds)
+     * @returns The cached JetStreamClient.
+     * @throws Error if the connection has not been established yet.
      */
-    ttl?: number;
+    getJetStreamClient(): JetStreamClient;
+    /** Direct access to the raw NATS connection, or `null` if not yet connected. */
+    get unwrap(): NatsConnection | null;
+    /**
+     * Gracefully shut down the connection.
+     *
+     * Sequence: drain → wait for close. Falls back to force-close on error.
+     */
+    shutdown(): Promise<void>;
+    private initJetStreamManager;
+    /** Internal: establish the physical connection with reconnect monitoring. */
+    private establish;
+    /** Handle a single `nc.status()` event, emitting hooks and span events. */
+    private handleStatusEvent;
+    /** Subscribe to connection status events and emit hooks. */
+    private monitorStatus;
 }
+
 /**
- * Root module configuration for `JetstreamModule.forRoot()`.
+ * NestJS ClientProxy implementation for the JetStream transport.
  *
- * Minimal usage requires only `name` and `servers`.
- * All other fields have production-ready defaults.
+ * Supports two operational modes:
+ * - **Core mode** (default): Uses `nc.request()` for RPC, `nc.publish()` for events.
+ * - **JetStream mode**: Uses `js.publish()` for RPC commands + inbox for responses.
+ *
+ * Events always go through JetStream publish for guaranteed delivery.
+ * The mode only affects RPC (request/reply) behavior.
+ *
+ * Clients are lightweight — they share the NATS connection from `forRoot()`.
  */
-interface JetstreamModuleOptions {
-    /** Service name. Used for stream/consumer/subject naming. */
-    name: string;
-    /** NATS server URLs. */
-    servers: string[];
+declare class JetstreamClient extends ClientProxy {
+    private readonly rootOptions;
+    private readonly connection;
+    private readonly codec;
+    private readonly eventBus;
+    private readonly logger;
+    /** Target service name this client sends messages to. */
+    private readonly targetName;
+    /** Pre-cached caller name derived from rootOptions.name, computed once in constructor. */
+    private readonly callerName;
     /**
-     * Global message codec.
-     * @default JsonCodec
+     * 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.
      */
-    codec?: Codec;
+    private readonly eventSubjectPrefix;
+    private readonly commandSubjectPrefix;
+    private readonly orderedSubjectPrefix;
     /**
-     * RPC transport mode and configuration.
-     * @default { mode: 'core' }
+     * 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.
      */
-    rpc?: RpcConfig;
+    private readonly isCoreMode;
+    private readonly defaultRpcTimeout;
+    /** Resolved OpenTelemetry configuration, computed once in the constructor. */
+    private readonly otel;
+    /** Server endpoint parts used for `server.address` / `server.port` span attributes. */
+    private readonly serverEndpoint;
+    /** Shared inbox for JetStream-mode RPC responses. */
+    private inbox;
+    private inboxSubscription;
+    /** Pending JetStream-mode RPC callbacks, keyed by correlation ID. */
+    private readonly pendingMessages;
+    /** Pending JetStream-mode RPC timeouts, keyed by correlation ID. */
+    private readonly pendingTimeouts;
+    /** Subscription to connection status events for disconnect handling. */
+    private statusSubscription;
     /**
-     * Enable consumer infrastructure (streams, consumers, message routing).
-     * Set to `false` for publisher-only services (e.g., API gateways).
-     * @default true
+     * 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.
      */
-    consumer?: boolean;
-    /** Workqueue event stream/consumer overrides. */
-    events?: StreamConsumerOverrides;
-    /** Broadcast event stream/consumer overrides. */
-    broadcast?: StreamConsumerOverrides;
+    private readyForPublish;
+    constructor(rootOptions: JetstreamModuleOptions, targetServiceName: string, connection: ConnectionProvider, codec: Codec, eventBus: EventBus);
     /**
-     * Ordered event consumer configuration.
+     * Establish connection. Called automatically by NestJS on first use.
+     *
+     * Sets up the JetStream RPC inbox (if in JetStream mode) and subscribes
+     * to connection status events for fail-fast disconnect handling.
+     *
+     * @returns The underlying NATS connection.
+     */
+    connect(): Promise<NatsConnection>;
+    /** Clean up resources: reject pending RPCs, unsubscribe from status events. */
+    close(): Promise<void>;
+    /**
+     * Direct access to the raw NATS connection.
+     *
+     * @throws Error if not connected.
+     */
+    unwrap<T = NatsConnection>(): T;
+    /**
+     * Publish a fire-and-forget event to JetStream.
+     *
+     * Events are published to either the workqueue stream or broadcast stream
+     * depending on the subject prefix. When a schedule is present the message
+     * is published to a `_sch` subject within the same stream, with the target
+     * set to the original event subject.
+     */
+    protected dispatchEvent<T = unknown>(packet: ReadPacket): Promise<T>;
+    /**
+     * Publish an RPC command and register callback for response.
+     *
+     * Core mode: uses nc.request() with timeout.
+     * JetStream mode: publishes to stream + waits for inbox response.
+     */
+    protected publish(packet: ReadPacket, callback: (p: WritePacket) => void): () => void;
+    /** Core mode: nc.request() with timeout. */
+    private publishCoreRpc;
+    /** JetStream mode: publish to stream + wait for inbox response. */
+    private publishJetStreamRpc;
+    /** Fail-fast all pending JetStream RPC callbacks on connection loss. */
+    private handleDisconnect;
+    /** Reject all pending RPC callbacks, clear timeouts, and tear down inbox. */
+    private rejectPendingRpcs;
+    /** Setup shared inbox subscription for JetStream RPC responses. */
+    private setupInbox;
+    /** Route an inbox reply to the matching pending callback. */
+    private routeInboxReply;
+    /**
+     * 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.
+     */
+    private buildEventSubject;
+    /** Build NATS headers merging custom headers with transport headers. */
+    private buildHeaders;
+    /** Extract data, headers, timeout, and schedule from raw packet data or JetstreamRecord. */
+    private extractRecordData;
+    /**
+     * Build a schedule-holder subject for NATS message scheduling.
+     *
+     * The schedule-holder subject resides in the same stream as the target but
+     * uses a separate `_sch` namespace that is NOT matched by any consumer filter.
+     * NATS holds the message and publishes it to the target subject after the delay.
+     *
+     * Examples:
+     * - `{svc}__microservice.ev.order.reminder` → `{svc}__microservice._sch.order.reminder`
+     * - `broadcast.config.updated` → `broadcast._sch.config.updated`
+     */
+    private buildScheduleSubject;
+}
+
+/**
+ * Immutable message record for JetStream transport.
+ *
+ * Compatible with NestJS record builder pattern (like RmqRecord, NatsRecord).
+ * Pass as the second argument to `client.send()` or `client.emit()`.
+ *
+ * @example
+ * ```typescript
+ * const record = new JetstreamRecordBuilder({ id: 1 })
+ *   .setHeader('x-tenant', 'acme')
+ *   .setTimeout(5000)
+ *   .build();
+ *
+ * client.send('get.user', record);
+ * ```
+ */
+declare class JetstreamRecord<TData = unknown> {
+    /** Message payload. */
+    readonly data: TData;
+    /** Custom headers set via {@link JetstreamRecordBuilder.setHeader}. */
+    readonly headers: ReadonlyMap<string, string>;
+    /** Per-request RPC timeout override in ms. */
+    readonly timeout?: number | undefined;
+    /** Custom message ID for JetStream deduplication. */
+    readonly messageId?: string | undefined;
+    /** Schedule options for delayed delivery. */
+    readonly schedule?: ScheduleRecordOptions | undefined;
+    /** Per-message TTL as Go duration string (e.g. "30s", "5m"). */
+    readonly ttl?: string | undefined;
+    constructor(
+    /** Message payload. */
+    data: TData, 
+    /** Custom headers set via {@link JetstreamRecordBuilder.setHeader}. */
+    headers: ReadonlyMap<string, string>, 
+    /** Per-request RPC timeout override in ms. */
+    timeout?: number | undefined, 
+    /** Custom message ID for JetStream deduplication. */
+    messageId?: string | undefined, 
+    /** Schedule options for delayed delivery. */
+    schedule?: ScheduleRecordOptions | undefined, 
+    /** Per-message TTL as Go duration string (e.g. "30s", "5m"). */
+    ttl?: string | undefined);
+}
+/**
+ * Fluent builder for constructing JetstreamRecord instances.
+ *
+ * Protected headers (`correlation-id`, `reply-to`, `error`) cannot be
+ * set by the user — attempting to do so throws an error at build time.
+ */
+declare class JetstreamRecordBuilder<TData = unknown> {
+    private data;
+    private readonly headers;
+    private timeout;
+    private messageId;
+    private scheduleOptions;
+    private ttlDuration;
+    constructor(data?: TData);
+    /**
+     * Set the message payload.
+     *
+     * @param data - Payload to serialize via the configured {@link Codec}.
+     */
+    setData(data: TData): this;
+    /**
+     * Set a single custom header.
+     *
+     * @param key - Header name (e.g. `'x-tenant'`).
+     * @param value - Header value.
+     * @throws Error if the header name is reserved by the transport.
+     */
+    setHeader(key: string, value: string): this;
+    /**
+     * Set multiple custom headers at once.
+     *
+     * @param headers - Key-value pairs to set as headers.
+     * @throws Error if any header name is reserved by the transport.
+     */
+    setHeaders(headers: Record<string, string>): this;
+    /**
+     * Set a custom message ID for JetStream deduplication.
+     *
+     * NATS JetStream uses this ID to detect duplicate publishes within the
+     * stream's `duplicate_window`. If two messages with the same ID arrive
+     * within the window, the second is silently dropped.
+     *
+     * When not set, a random UUID is generated automatically.
+     *
+     * @param id - Unique message identifier (e.g. order ID, idempotency key).
+     *
+     * @example
+     * ```typescript
+     * new JetstreamRecordBuilder(data)
+     *   .setMessageId(`order-${order.id}`)
+     *   .build();
+     * ```
+     */
+    setMessageId(id: string): this;
+    /**
+     * Set per-request RPC timeout.
+     *
+     * @param ms - Timeout in milliseconds. Overrides the global RPC timeout for this request only.
+     */
+    setTimeout(ms: number): this;
+    /**
+     * Schedule one-shot delayed delivery.
+     *
+     * The message is held by NATS and delivered to the event consumer
+     * at the specified time. Requires NATS >= 2.12 and `allow_msg_schedules: true`
+     * on the event stream (via `events: { stream: { allow_msg_schedules: true } }`).
+     *
+     * Only meaningful for events (`client.emit()`). If used with RPC
+     * (`client.send()`), a warning is logged and the schedule is ignored.
+     *
+     * @param date - Delivery time. Must be in the future.
+     * @throws Error if the date is not in the future.
+     */
+    scheduleAt(date: Date): this;
+    /**
+     * Set per-message TTL (time-to-live).
+     *
+     * The message expires individually after the specified duration,
+     * independent of the stream's `max_age`. Requires NATS >= 2.11 and
+     * `allow_msg_ttl: true` on the stream.
+     *
+     * Only meaningful for events (`client.emit()`). If used with RPC
+     * (`client.send()`), a warning is logged and the TTL is ignored.
+     *
+     * @param nanos - TTL in nanoseconds. Use {@link toNanos} for human-readable values.
+     *
+     * @example
+     * ```typescript
+     * import { toNanos } from '@horizon-republic/nestjs-jetstream';
+     *
+     * new JetstreamRecordBuilder(payload).ttl(toNanos(30, 'minutes')).build();
+     * new JetstreamRecordBuilder(payload).ttl(toNanos(24, 'hours')).build();
+     * ```
+     */
+    ttl(nanos: number): this;
+    /**
+     * Build the immutable {@link JetstreamRecord}.
+     *
+     * @returns A frozen record ready to pass to `client.send()` or `client.emit()`.
+     */
+    build(): JetstreamRecord<TData>;
+    /**
+     * 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.
+     */
+    private validateHeaderKey;
+}
+
+/** Tag attached to every outgoing publish span so consumers can distinguish event / RPC / broadcast / ordered flows. */
+declare enum PublishKind {
+    Event = "event",
+    RpcRequest = "rpc.request",
+    Broadcast = "broadcast",
+    Ordered = "ordered"
+}
+/** Tag attached to every incoming consume span. `Rpc` covers both Core and JetStream RPC handlers. */
+declare enum ConsumeKind {
+    Event = "event",
+    Rpc = "rpc",
+    Broadcast = "broadcast",
+    Ordered = "ordered"
+}
+/**
+ * Handler metadata for the dispatched message. `pattern` is always set;
+ * `className` / `methodName` come from NestJS reflection when available.
+ */
+interface HandlerMetadata {
+    readonly pattern: string;
+    readonly className?: string;
+    readonly methodName?: string;
+}
+/**
+ * Host / port pair surfaced as `server.address` / `server.port` span
+ * attributes. `port` is optional — OTel semconv makes it conditional on
+ * being different from the protocol default, and we'd rather emit nothing
+ * than invent a number the user never configured.
+ */
+interface ServerEndpoint {
+    readonly host: string;
+    readonly port?: number;
+}
+/**
+ * Minimum message shape the consume span helper requires. Both `JsMsg`
+ * (JetStream) and Core NATS `Msg` satisfy it structurally; JetStream-only
+ * delivery metadata (`info`) is read separately and omitted on the Core
+ * RPC path.
+ */
+interface ConsumeSourceMsg {
+    readonly subject: string;
+    readonly data: Uint8Array;
+    readonly headers?: MsgHdrs;
+}
+/** Context passed to {@link OtelOptions.publishHook} for an outgoing publish. */
+interface JetstreamPublishContext {
+    /** Fully-resolved subject the message is being published to. */
+    readonly subject: string;
+    /** The record being published (payload, headers, builder-supplied options). */
+    readonly record: JetstreamRecord;
+    /** Classification of the outgoing operation. */
+    readonly kind: PublishKind;
+}
+/** Context passed to {@link OtelOptions.consumeHook} for an incoming dispatch. */
+interface JetstreamConsumeContext {
+    /** Fully-resolved subject of the incoming message. */
+    readonly subject: string;
+    /**
+     * The incoming NATS message. JetStream messages (events, broadcast,
+     * ordered, JetStream RPC) satisfy `JsMsg`; Core RPC messages satisfy
+     * the looser {@link ConsumeSourceMsg} shape only. Narrow on `kind` to
+     * decide which fields are safe to access.
+     */
+    readonly msg: ConsumeSourceMsg;
+    /** Handler metadata; see {@link HandlerMetadata}. */
+    readonly handlerMetadata: HandlerMetadata;
+    /** Classification of the incoming operation. */
+    readonly kind: ConsumeKind;
+}
+/** Context passed to {@link OtelOptions.responseHook} once an outcome is known, just before the span ends. */
+interface JetstreamResponseContext {
+    /** Subject the operation targeted. */
+    readonly subject: string;
+    /** Wall-clock duration of the operation in milliseconds. */
+    readonly durationMs: number;
+    /** Decoded reply payload for RPC client spans when available. */
+    readonly reply?: unknown;
+    /** Error instance if the operation failed. */
+    readonly error?: Error;
+}
+/**
+ * Classification outcome for a thrown error. Affects span status and
+ * attributes only — reply envelopes and internal logging are unchanged.
+ */
+type ErrorClassification = 'expected' | 'unexpected';
+/** Object form of {@link OtelOptions.captureBody}. */
+interface CaptureBodyOptions {
+    /**
+     * Maximum number of bytes to capture. Payloads longer than this are
+     * truncated; a `messaging.nats.message.body.truncated` attribute is
+     * added to indicate truncation occurred.
+     *
+     * @default 4096
+     */
+    readonly maxBytes?: number;
+    /**
+     * Only capture body for subjects matching these glob patterns. Each
+     * pattern supports `*` wildcards and an optional leading `!` for
+     * exclusion. When omitted, body capture applies to all subjects.
+     */
+    readonly subjectAllowlist?: readonly string[];
+}
+/**
+ * OpenTelemetry configuration for `JetstreamModule.forRoot({ otel: … })`.
+ * All fields are optional; when the host app has not registered an OTel
+ * SDK, every call made by the library is a no-op regardless of config.
+ */
+interface OtelOptions {
+    /**
+     * Global kill switch. When `false`, no spans are emitted, no propagation
+     * is attempted, and no hooks fire.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Which trace kinds to emit.
+     *
+     * - `'default'` — publish, consume, RPC client round-trip, dead letter
+     * - `'all'` — every trace kind defined in {@link JetstreamTrace}
+     * - `'none'` — emit no spans at all (useful with `enabled: true` for
+     *   pure trace-context propagation without the span overhead)
+     * - `JetstreamTrace[]` — explicit selection
+     *
+     * @default 'default'
+     */
+    readonly traces?: readonly JetstreamTrace[] | 'default' | 'all' | 'none';
+    /**
+     * Header names to capture as span attributes (`messaging.header.<name>`).
+     * Match is case-insensitive. Glob wildcards (`*`) and negation (`!prefix-*`)
+     * are supported in the per-pattern form.
+     *
+     * SECURITY / GDPR: headers may contain authentication tokens, session
+     * identifiers, or other sensitive data. Captured values are exported to
+     * the configured OTel backend. Use an explicit allowlist in production.
+     * Setting this to `true` captures every header and is intended for
+     * development environments only.
+     *
+     * Transport-internal headers (`x-correlation-id`, `x-reply-to`, `x-error`,
+     * `x-subject`, `x-caller-name`) and propagator-owned headers
+     * (`traceparent`, `tracestate`, `baggage`, `sentry-trace`, `b3`, …) are
+     * always suppressed regardless of the allowlist.
+     *
+     * @default ['x-request-id']
+     */
+    readonly captureHeaders?: readonly string[] | boolean;
+    /**
+     * Capture the message payload as the `messaging.nats.message.body` span
+     * attribute. Defaults to `false` for privacy and cost reasons.
+     *
+     * Passing `true` captures up to 4 KiB per message. Use the object form
+     * for finer control over size and subject scope.
+     *
+     * SECURITY / GDPR: payloads commonly contain PII, credentials, financial
+     * data, or content regulated by HIPAA / PCI-DSS. Enabling body capture
+     * in production is almost always a policy violation. Prefer enabling
+     * only in development, or pair with a custom `SpanProcessor` that
+     * scrubs or drops the attribute before export.
+     *
+     * @default false
+     */
+    readonly captureBody?: boolean | CaptureBodyOptions;
+    /**
+     * Invoked after a publish span has been started and before the actual
+     * publish call executes. Use to enrich the span with custom attributes.
+     * Must be synchronous — thrown errors are caught and logged at debug
+     * level without affecting the publish path.
+     */
+    publishHook?(span: Span, ctx: JetstreamPublishContext): void;
+    /**
+     * Invoked after a consume span has been started and before the handler
+     * is dispatched. Use to enrich the span with custom attributes derived
+     * from the incoming message or handler metadata.
+     */
+    consumeHook?(span: Span, ctx: JetstreamConsumeContext): void;
+    /**
+     * Invoked once an operation's outcome is known (success, error, or
+     * timeout) and the span status has been set, just before the span ends.
+     * Fires for publish, consume, and RPC client spans.
+     */
+    responseHook?(span: Span, ctx: JetstreamResponseContext): void;
+    /**
+     * Predicate evaluated at the top of every outgoing publish. Returning
+     * `false` skips span creation for that publish; propagation of trace
+     * context through headers still occurs, so downstream consumers are
+     * unaffected. Useful for suppressing noise from health-check or
+     * internal-only subjects.
+     */
+    shouldTracePublish?(subject: string, record: JetstreamRecord): boolean;
+    /**
+     * Predicate evaluated at the top of every incoming message delivery.
+     * Returning `false` skips span creation for that delivery; the handler
+     * still executes normally and trace context is still extracted from
+     * headers for downstream calls.
+     */
+    shouldTraceConsume?(subject: string, msg: ConsumeSourceMsg): boolean;
+    /**
+     * Classify a thrown error as `'expected'` (business error, part of the
+     * RPC contract) or `'unexpected'` (infrastructure failure or bug). Drives
+     * OpenTelemetry span status and attributes only.
+     *
+     * - `'expected'` → span status `OK` with `jetstream.rpc.reply.has_error`
+     *   and `jetstream.rpc.reply.error.code` attributes
+     * - `'unexpected'` → span status `ERROR` with `span.recordException(err)`
+     *
+     * Reply envelopes delivered to RPC clients are identical in both cases.
+     * This classification affects only the observability artifact.
+     *
+     * The default recognizes NestJS-idiomatic primitives for business errors:
+     * `RpcException` and `HttpException`. Teams with custom error hierarchies
+     * override to recognize their own types.
+     *
+     * @example
+     *   errorClassifier: (err) => {
+     *     if (err instanceof MyDomainError) return 'expected';
+     *     if (err?.code?.startsWith('BIZ_')) return 'expected';
+     *     return 'unexpected';
+     *   }
+     */
+    errorClassifier?(err: unknown): ErrorClassification;
+}
+
+/**
+ * Stream config overrides exposed to users.
+ *
+ * `retention` is excluded because it is controlled by the transport layer
+ * (Workqueue for events/commands, Limits for broadcast/ordered).
+ * Any `retention` value provided at runtime is silently stripped.
+ */
+type StreamConfigOverrides = Partial<Omit<StreamConfig, 'retention'>>;
+/**
+ * RPC transport configuration.
+ *
+ * Discriminated union on `mode`:
+ * - `'core'`      — NATS native request/reply. Lowest latency.
+ * - `'jetstream'`  — Commands persisted in JetStream. Responses via Core NATS inbox.
+ *
+ * When `mode` is `'core'`, only `timeout` is available.
+ * When `mode` is `'jetstream'`, additional stream/consumer overrides are exposed.
+ */
+type RpcConfig = {
+    mode: 'core';
+    /** Request timeout in ms. Default: 30_000. */
+    timeout?: number;
+} | {
+    mode: 'jetstream';
+    /** Handler timeout in ms. Default: 180_000 (3 min). */
+    timeout?: number;
+    /** Raw NATS StreamConfig overrides for the command stream. */
+    stream?: StreamConfigOverrides;
+    /** Raw NATS ConsumerConfig overrides for the command consumer. */
+    consumer?: Partial<ConsumerConfig>;
+    /** Options passed to the nats.js `consumer.consume()` call for the command consumer. */
+    consume?: Partial<ConsumeOptions>;
+    /** Maximum number of concurrent RPC handler executions. */
+    concurrency?: number;
+    /**
+     * Auto-extend ack deadline via `msg.working()` during RPC handler execution.
+     * The RPC handler timeout (`setTimeout` + `msg.term()`) still acts as the hard cap.
+     */
+    ackExtension?: boolean | number;
+};
+/** Overrides for JetStream stream and consumer configuration. */
+interface StreamConsumerOverrides {
+    stream?: StreamConfigOverrides;
+    consumer?: Partial<ConsumerConfig>;
+    /**
+     * Options passed to the nats.js `consumer.consume()` call.
+     * Controls prefetch buffer size, idle heartbeat interval, and auto-refill thresholds.
+     *
+     * nats.js supports two consumption modes (message-based and byte-based).
+     * Do not mix `max_bytes`/`threshold_bytes` with `threshold_messages` —
+     * use one mode or the other.
+     *
+     * @see https://github.com/nats-io/nats.js — ConsumeOptions
+     */
+    consume?: Partial<ConsumeOptions>;
+    /**
+     * Maximum number of concurrent handler executions (RxJS `mergeMap` limit).
+     *
+     * Default: `undefined` (unlimited — naturally bounded by `max_ack_pending`).
+     * Set this to protect downstream systems from overload.
+     *
+     * **Important:** if `concurrency < max_ack_pending`, messages buffer in RxJS
+     * while their NATS ack timer ticks. Increase `ack_wait` proportionally to
+     * prevent unnecessary redeliveries.
+     */
+    concurrency?: number;
+    /**
+     * Auto-extend the NATS ack deadline via `msg.working()` during handler execution.
+     *
+     * - `false` (default): disabled — NATS redelivers after `ack_wait` if not acked.
+     * - `true`: auto-extend at `ack_wait / 2` interval (calculated from consumer config).
+     * - `number`: explicit extension interval in milliseconds.
+     */
+    ackExtension?: boolean | number;
+}
+/**
+ * Configuration for ordered event consumers.
+ *
+ * Ordered consumers use Limits retention and deliver messages in strict
+ * sequential order with at-most-once delivery. No ack/nak/DLQ.
+ *
+ * Only a subset of consumer options applies — ordered consumers are
+ * ephemeral and auto-managed by nats.js.
+ */
+interface OrderedEventOverrides {
+    /** Stream overrides (e.g. `max_age`, `max_bytes`). */
+    stream?: StreamConfigOverrides;
+    /**
+     * Where to start reading when the consumer is (re)created.
+     * @default DeliverPolicy.All
+     */
+    deliverPolicy?: DeliverPolicy;
+    /**
+     * Start sequence number. Only used when `deliverPolicy` is `StartSequence`.
+     */
+    optStartSeq?: number;
+    /**
+     * Start time (ISO string). Only used when `deliverPolicy` is `StartTime`.
+     */
+    optStartTime?: string;
+    /**
+     * Replay policy for historical messages.
+     * @default ReplayPolicy.Instant
+     */
+    replayPolicy?: ReplayPolicy;
+}
+/**
+ * Configuration for the handler metadata KV registry.
+ *
+ * When any handler has `meta` in its extras, the transport writes metadata
+ * entries to a NATS KV bucket at startup. External services (API gateways,
+ * dashboards) can watch the bucket for service discovery.
+ *
+ * All fields are optional — sensible defaults are applied.
+ */
+interface MetadataRegistryOptions {
+    /**
+     * KV bucket name.
+     * @default 'handler_registry'
+     */
+    bucket?: string;
+    /**
+     * Number of KV bucket replicas. Must be an odd number (1, 3, 5, 7, ...).
+     * Requires a NATS cluster with at least this many nodes.
+     * @default 1
+     */
+    replicas?: number;
+    /**
+     * KV bucket TTL in milliseconds.
+     *
+     * Entries expire automatically unless refreshed by a heartbeat.
+     * The transport refreshes entries every `ttl / 2` while the pod is alive.
+     * When the pod stops (graceful or crash), entries expire after this duration.
+     *
+     * @default 30_000 (30 seconds)
+     */
+    ttl?: number;
+}
+/**
+ * Root module configuration for `JetstreamModule.forRoot()`.
+ *
+ * Minimal usage requires only `name` and `servers`.
+ * All other fields have production-ready defaults.
+ */
+interface JetstreamModuleOptions {
+    /** Service name. Used for stream/consumer/subject naming. */
+    name: string;
+    /** NATS server URLs. */
+    servers: string[];
+    /**
+     * Global message codec.
+     * @default JsonCodec
+     */
+    codec?: Codec;
+    /**
+     * RPC transport mode and configuration.
+     * @default { mode: 'core' }
+     */
+    rpc?: RpcConfig;
+    /**
+     * Enable consumer infrastructure (streams, consumers, message routing).
+     * Set to `false` for publisher-only services (e.g., API gateways).
+     * @default true
+     */
+    consumer?: boolean;
+    /** Workqueue event stream/consumer overrides. */
+    events?: StreamConsumerOverrides;
+    /** Broadcast event stream/consumer overrides. */
+    broadcast?: StreamConsumerOverrides;
+    /**
+     * Ordered event consumer configuration.
      *
      * Ordered events use a separate stream with Limits retention and deliver
      * messages in strict sequential order. Use `ordered:` prefix when publishing.
@@ -385,6 +1069,16 @@ interface JetstreamModuleOptions {
      * Merged with `name` and `servers` — those take precedence.
      */
     connectionOptions?: Partial<ConnectionOptions>;
+    /**
+     * OpenTelemetry integration. When omitted, sensible defaults are applied:
+     * tracing is enabled, default trace kinds are emitted, only standard
+     * correlation headers are captured. If no OTel SDK is registered in the
+     * consuming application, all tracer calls are no-ops — there is no
+     * runtime cost.
+     *
+     * @see OtelOptions
+     */
+    otel?: OtelOptions;
 }
 /** Options for `JetstreamModule.forFeature()`. */
 interface JetstreamFeatureOptions {
@@ -462,138 +1156,32 @@ interface PatternsByKind {
     /** Ordered event patterns (strict sequential delivery). */
     ordered: string[];
 }
-/** Options for configuring event/broadcast processing behavior. */
-interface EventProcessingConfig {
-    events?: {
-        concurrency?: number;
-        ackExtension?: boolean | number;
-    };
-    broadcast?: {
-        concurrency?: number;
-        ackExtension?: boolean | number;
-    };
-}
-/** Options for dead letter queue handling. */
-interface DeadLetterConfig {
-    /**
-     * Map of stream name -> max_deliver value.
-     * Used to detect when a message from a given stream has exhausted all delivery attempts.
-     */
-    maxDeliverByStream: Map<string, number>;
-    /** Async callback invoked when a message exhausts all deliveries. */
-    onDeadLetter(info: DeadLetterInfo): Promise<void>;
-}
-/** Options for configuring RPC processing behavior. */
-interface RpcRouterOptions {
-    timeout?: number;
-    concurrency?: number;
-    ackExtension?: boolean | number;
-}
-
-/**
- * Central event bus for transport lifecycle notifications.
- *
- * Dispatches events to user-provided hooks. Events without a
- * registered hook are silently ignored — no default logging.
- *
- * @example
- * ```typescript
- * const bus = new EventBus(logger, {
- *   [TransportEvent.Error]: (err) => sentry.captureException(err),
- * });
- *
- * bus.emit(TransportEvent.Error, new Error('timeout'), 'rpc-router');
- * // → calls sentry
- *
- * bus.emit(TransportEvent.Connect, 'nats://localhost:4222');
- * // → no-op (no hook registered)
- * ```
- */
-declare class EventBus {
-    private readonly hooks;
-    private readonly logger;
-    constructor(logger: Logger, hooks?: Partial<TransportHooks>);
-    /**
-     * Emit a lifecycle event. Dispatches to custom hook if registered, otherwise no-op.
-     *
-     * @param event - The {@link TransportEvent} to emit.
-     * @param args - Arguments matching the hook signature for this event.
-     */
-    emit<K extends keyof TransportHooks>(event: K, ...args: Parameters<TransportHooks[K]>): void;
-    /**
-     * Hot-path optimized emit for MessageRouted events.
-     * Avoids rest/spread overhead of the generic `emit()`.
-     */
-    emitMessageRouted(subject: string, kind: MessageKind): void;
-    /**
-     * 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: keyof TransportHooks): boolean;
-    private callHook;
-}
-
-/**
- * Manages the lifecycle of a single NATS connection shared across the application.
- *
- * Provides both Promise-based and Observable-based access to the connection:
- * - `connect()` / `getConnection()` — async/await for one-time setup
- * - `nc$` — cached observable (shareReplay) for reactive consumers
- * - `status$` — live connection status event stream
- *
- * One instance per application, created by `JetstreamModule.forRoot()`.
- */
-declare class ConnectionProvider {
-    private readonly options;
-    private readonly eventBus;
-    /** Cached observable that replays the established connection to new subscribers. */
-    readonly nc$: Observable<NatsConnection>;
-    /** Live stream of connection status events (no replay). */
-    readonly status$: Observable<Status>;
-    private readonly logger;
-    private connection;
-    private connectionPromise;
-    private jsClient;
-    private jsmInstance;
-    private jsmPromise;
-    constructor(options: JetstreamModuleOptions, eventBus: EventBus);
-    /**
-     * Establish NATS connection. Idempotent — returns cached connection on subsequent calls.
-     *
-     * @throws Error if connection is refused (fail fast).
-     */
-    getConnection(): Promise<NatsConnection>;
-    /**
-     * Get the JetStream manager. Cached after first call.
-     *
-     * @returns The JetStreamManager for stream/consumer administration.
-     */
-    getJetStreamManager(): Promise<JetStreamManager>;
-    /**
-     * Get a cached JetStream client.
-     *
-     * Invalidated automatically on reconnect and shutdown so consumers always
-     * operate against the live connection.
-     *
-     * @returns The cached JetStreamClient.
-     * @throws Error if the connection has not been established yet.
-     */
-    getJetStreamClient(): JetStreamClient;
-    /** Direct access to the raw NATS connection, or `null` if not yet connected. */
-    get unwrap(): NatsConnection | null;
+/** Options for configuring event/broadcast processing behavior. */
+interface EventProcessingConfig {
+    events?: {
+        concurrency?: number;
+        ackExtension?: boolean | number;
+    };
+    broadcast?: {
+        concurrency?: number;
+        ackExtension?: boolean | number;
+    };
+}
+/** Options for dead letter queue handling. */
+interface DeadLetterConfig {
     /**
-     * Gracefully shut down the connection.
-     *
-     * Sequence: drain → wait for close. Falls back to force-close on error.
+     * Map of stream name -> max_deliver value.
+     * Used to detect when a message from a given stream has exhausted all delivery attempts.
      */
-    shutdown(): Promise<void>;
-    private initJetStreamManager;
-    /** Internal: establish the physical connection with reconnect monitoring. */
-    private establish;
-    /** Subscribe to connection status events and emit hooks. */
-    private monitorStatus;
+    maxDeliverByStream: Map<string, number>;
+    /** Async callback invoked when a message exhausts all deliveries. */
+    onDeadLetter(info: DeadLetterInfo): Promise<void>;
+}
+/** Options for configuring RPC processing behavior. */
+interface RpcRouterOptions {
+    timeout?: number;
+    concurrency?: number;
+    ackExtension?: boolean | number;
 }
 
 /**
@@ -658,13 +1246,15 @@ declare class PatternRegistry {
  * This is the default RPC mode — lowest latency, no persistence overhead.
  */
 declare class CoreRpcServer {
-    private readonly options;
     private readonly connection;
     private readonly patternRegistry;
     private readonly codec;
     private readonly eventBus;
     private readonly logger;
     private subscription;
+    private readonly otel;
+    private readonly serviceName;
+    private readonly serverEndpoint;
     constructor(options: JetstreamModuleOptions, connection: ConnectionProvider, patternRegistry: PatternRegistry, codec: Codec, eventBus: EventBus);
     /** Start listening for RPC requests on the command subject. */
     start(): Promise<void>;
@@ -691,6 +1281,9 @@ declare class StreamProvider {
     private readonly connection;
     private readonly logger;
     private readonly migration;
+    private readonly otel;
+    private readonly otelServiceName;
+    private readonly otelEndpoint;
     constructor(options: JetstreamModuleOptions, connection: ConnectionProvider);
     /**
      * Ensure all required streams exist with correct configuration.
@@ -734,21 +1327,6 @@ declare class StreamProvider {
     private stripTransportControlled;
 }
 
-/**
- * Routes incoming event messages (workqueue, broadcast, and ordered) to NestJS handlers.
- *
- * **Workqueue & Broadcast** — at-least-once delivery:
- * - Success -> ack | Error -> nak (retry) | Dead letter -> term
- *
- * **Ordered** — strict sequential delivery:
- * - No ack/nak/DLQ — nats.js auto-acknowledges ordered consumer messages.
- * - Handler errors are logged but do not affect delivery.
- *
- * **Dead-Letter Queue (DLQ) - for handling failed message deliveries**
- * - If `options.dlq` is configured, messages that exhaust their max delivery attempts are published to a DLQ stream.
- * - The DLQ stream name is derived from the service name (e.g., `orders__microservice_dlq-stream`).
- * - Original message data and metadata are preserved in the DLQ message, with additional headers indicating the reason for failure.
- */
 declare class EventRouter {
     private readonly messageProvider;
     private readonly patternRegistry;
@@ -761,6 +1339,9 @@ declare class EventRouter {
     private readonly options?;
     private readonly logger;
     private readonly subscriptions;
+    private readonly otel;
+    private readonly serviceName;
+    private readonly serverEndpoint;
     constructor(messageProvider: MessageProvider, patternRegistry: PatternRegistry, codec: Codec, eventBus: EventBus, deadLetterConfig?: DeadLetterConfig | undefined, processingConfig?: EventProcessingConfig | undefined, ackWaitMap?: Map<StreamKind, number> | undefined, connection?: ConnectionProvider | undefined, options?: JetstreamModuleOptions | undefined);
     /**
      * Update the max_deliver thresholds from actual NATS consumer configs.
@@ -775,14 +1356,11 @@ declare class EventRouter {
     private subscribeToStream;
     private getConcurrency;
     private getAckExtensionConfig;
-    /** 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.
      */
     private fallbackToOnDeadLetterCallback;
     /**
@@ -829,7 +1407,10 @@ declare class RpcRouter {
     private resolvedAckExtensionInterval;
     private subscription;
     private cachedNc;
-    constructor(messageProvider: MessageProvider, patternRegistry: PatternRegistry, connection: ConnectionProvider, codec: Codec, eventBus: EventBus, rpcOptions?: RpcRouterOptions | undefined, ackWaitMap?: Map<StreamKind, number> | undefined);
+    private readonly otel;
+    private readonly serviceName;
+    private readonly serverEndpoint;
+    constructor(messageProvider: MessageProvider, patternRegistry: PatternRegistry, connection: ConnectionProvider, codec: Codec, eventBus: EventBus, rpcOptions?: RpcRouterOptions | undefined, ackWaitMap?: Map<StreamKind, number> | undefined, options?: JetstreamModuleOptions);
     /** Lazily resolve the ack extension interval (needs ackWaitMap populated at runtime). */
     private get ackExtensionInterval();
     /** Start routing command messages to handlers. */
@@ -850,6 +1431,9 @@ declare class ConsumerProvider {
     private readonly streamProvider;
     private readonly patternRegistry;
     private readonly logger;
+    private readonly otel;
+    private readonly otelServiceName;
+    private readonly otelEndpoint;
     constructor(options: JetstreamModuleOptions, connection: ConnectionProvider, streamProvider: StreamProvider, patternRegistry: PatternRegistry);
     /**
      * Ensure consumers exist for the specified kinds.
@@ -1079,411 +1663,138 @@ declare class JetstreamStrategy extends Server implements CustomTransportStrateg
     /**
      * Register event listener (required by Server base class).
      *
-     * Stores callbacks for client use. Primary lifecycle events
-     * are routed through EventBus.
-     */
-    on(event: string, callback: Function): void;
-    /**
-     * Unwrap the underlying NATS connection.
-     *
-     * @throws Error if the transport has not started.
-     */
-    unwrap<T>(): T;
-    /** Access the pattern registry (for module-level introspection). */
-    getPatternRegistry(): PatternRegistry;
-    /** Determine which streams and durable consumers are needed. */
-    private resolveRequiredKinds;
-    /** Populate the shared ack_wait map from actual NATS consumer configs. */
-    private populateAckWaitMap;
-    /** Build max_deliver map from actual NATS consumer configs (not options). */
-    private buildMaxDeliverMap;
-}
-
-/** Minimal interface for anything that can be stopped during shutdown. */
-interface Stoppable {
-    close(): void;
-}
-/**
- * Orchestrates graceful transport shutdown.
- *
- * Shutdown sequence:
- * 1. Emit onShutdownStart hook
- * 2. Stop accepting new messages (close subscriptions, stop consumers)
- * 3. Drain and close NATS connection (with timeout safety net)
- * 4. Emit onShutdownComplete hook
- *
- * Idempotent — concurrent or repeated calls return the same promise.
- * This is critical because NestJS may call `onApplicationShutdown` on
- * multiple module instances (forRoot + forFeature) that share this
- * singleton, and the call order is not guaranteed.
- */
-declare class ShutdownManager {
-    private readonly connection;
-    private readonly eventBus;
-    private readonly timeout;
-    private readonly logger;
-    private shutdownPromise?;
-    constructor(connection: ConnectionProvider, eventBus: EventBus, timeout: number);
-    /**
-     * Execute the full shutdown sequence.
-     *
-     * Idempotent — concurrent or repeated calls return the same promise.
-     *
-     * @param strategy Optional stoppable to close (stops consumers and subscriptions).
-     */
-    shutdown(strategy?: Stoppable): Promise<void>;
-    private doShutdown;
-}
-
-/**
- * Root module for the NestJS JetStream transport.
- *
- * - `forRoot()` / `forRootAsync()` — registers once in AppModule.
- *   Creates shared NATS connection, codec, event bus, and optionally
- *   the consumer infrastructure.
- *
- * - `forFeature()` — registers in feature modules.
- *   Creates a lightweight client proxy targeting a specific service.
- *
- * @example
- * ```typescript
- * // AppModule — global setup
- * @Module({
- *   imports: [
- *     JetstreamModule.forRoot({
- *       name: 'orders',
- *       servers: ['nats://localhost:4222'],
- *     }),
- *   ],
- * })
- * export class AppModule {}
- *
- * // Feature module — per-service clients
- * @Module({
- *   imports: [
- *     JetstreamModule.forFeature({ name: 'users' }),
- *     JetstreamModule.forFeature({ name: 'payments' }),
- *   ],
- * })
- * export class OrdersModule {}
- * ```
- */
-declare class JetstreamModule implements OnApplicationShutdown {
-    private readonly shutdownManager?;
-    private readonly strategy?;
-    constructor(shutdownManager?: ShutdownManager | undefined, strategy?: (JetstreamStrategy | null) | undefined);
-    /**
-     * Register the JetStream transport globally.
-     *
-     * Creates a shared NATS connection, codec, event bus, and optionally
-     * the full consumer infrastructure (streams, consumers, routers).
-     *
-     * @param options Module configuration.
-     * @returns Dynamic module ready to be imported.
-     */
-    static forRoot(options: JetstreamModuleOptions): DynamicModule;
-    /**
-     * Register the JetStream transport globally with async configuration.
-     *
-     * Supports `useFactory`, `useExisting`, and `useClass` patterns
-     * for loading configuration from ConfigService, environment, etc.
-     *
-     * @param asyncOptions Async configuration.
-     * @returns Dynamic module ready to be imported.
-     */
-    static forRootAsync(asyncOptions: JetstreamModuleAsyncOptions): DynamicModule;
-    /**
-     * Register a lightweight client proxy for a target service.
-     *
-     * Reuses the shared NATS connection from `forRoot()`.
-     * Import in each feature module that needs to communicate with a specific service.
-     *
-     * @param options Feature options with target service name.
-     * @returns Dynamic module with the client provider.
-     */
-    static forFeature(options: JetstreamFeatureOptions): DynamicModule;
-    private static createCoreProviders;
-    /** Create providers that depend on JETSTREAM_OPTIONS (shared by sync and async). */
-    private static createCoreDependentProviders;
-    /** Create async options provider from useFactory/useExisting/useClass. */
-    private static createAsyncOptionsProvider;
-    /**
-     * Gracefully shut down the transport on application termination.
-     */
-    onApplicationShutdown(): Promise<void>;
-}
-
-/**
- * NestJS ClientProxy implementation for the JetStream transport.
- *
- * Supports two operational modes:
- * - **Core mode** (default): Uses `nc.request()` for RPC, `nc.publish()` for events.
- * - **JetStream mode**: Uses `js.publish()` for RPC commands + inbox for responses.
- *
- * Events always go through JetStream publish for guaranteed delivery.
- * The mode only affects RPC (request/reply) behavior.
- *
- * Clients are lightweight — they share the NATS connection from `forRoot()`.
- */
-declare class JetstreamClient extends ClientProxy {
-    private readonly rootOptions;
-    private readonly connection;
-    private readonly codec;
-    private readonly eventBus;
-    private readonly logger;
-    /** Target service name this client sends messages to. */
-    private readonly targetName;
-    /** Pre-cached caller name derived from rootOptions.name, computed once in constructor. */
-    private readonly 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.
-     */
-    private readonly eventSubjectPrefix;
-    private readonly commandSubjectPrefix;
-    private readonly 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.
-     */
-    private readonly isCoreMode;
-    private readonly defaultRpcTimeout;
-    /** Shared inbox for JetStream-mode RPC responses. */
-    private inbox;
-    private inboxSubscription;
-    /** Pending JetStream-mode RPC callbacks, keyed by correlation ID. */
-    private readonly pendingMessages;
-    /** Pending JetStream-mode RPC timeouts, keyed by correlation ID. */
-    private readonly pendingTimeouts;
-    /** Subscription to connection status events for disconnect handling. */
-    private statusSubscription;
-    /**
-     * 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.
-     */
-    private readyForPublish;
-    constructor(rootOptions: JetstreamModuleOptions, targetServiceName: string, connection: ConnectionProvider, codec: Codec, eventBus: EventBus);
-    /**
-     * Establish connection. Called automatically by NestJS on first use.
-     *
-     * Sets up the JetStream RPC inbox (if in JetStream mode) and subscribes
-     * to connection status events for fail-fast disconnect handling.
-     *
-     * @returns The underlying NATS connection.
-     */
-    connect(): Promise<NatsConnection>;
-    /** Clean up resources: reject pending RPCs, unsubscribe from status events. */
-    close(): Promise<void>;
-    /**
-     * Direct access to the raw NATS connection.
-     *
-     * @throws Error if not connected.
-     */
-    unwrap<T = NatsConnection>(): T;
-    /**
-     * Publish a fire-and-forget event to JetStream.
-     *
-     * Events are published to either the workqueue stream or broadcast stream
-     * depending on the subject prefix. When a schedule is present the message
-     * is published to a `_sch` subject within the same stream, with the target
-     * set to the original event subject.
-     */
-    protected dispatchEvent<T = unknown>(packet: ReadPacket): Promise<T>;
-    /**
-     * Publish an RPC command and register callback for response.
-     *
-     * Core mode: uses nc.request() with timeout.
-     * JetStream mode: publishes to stream + waits for inbox response.
+     * Stores callbacks for client use. Primary lifecycle events
+     * are routed through EventBus.
      */
-    protected publish(packet: ReadPacket, callback: (p: WritePacket) => void): () => void;
-    /** Core mode: nc.request() with timeout. */
-    private publishCoreRpc;
-    /** JetStream mode: publish to stream + wait for inbox response. */
-    private publishJetStreamRpc;
-    /** Fail-fast all pending JetStream RPC callbacks on connection loss. */
-    private handleDisconnect;
-    /** Reject all pending RPC callbacks, clear timeouts, and tear down inbox. */
-    private rejectPendingRpcs;
-    /** Setup shared inbox subscription for JetStream RPC responses. */
-    private setupInbox;
-    /** Route an inbox reply to the matching pending callback. */
-    private routeInboxReply;
+    on(event: string, callback: Function): void;
     /**
-     * Resolve a user pattern to a fully-qualified NATS subject, dispatching
-     * between the event, broadcast, and ordered prefixes.
+     * Unwrap the underlying NATS connection.
      *
-     * 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.
+     * @throws Error if the transport has not started.
      */
-    private buildEventSubject;
-    /** Build NATS headers merging custom headers with transport headers. */
-    private buildHeaders;
-    /** Extract data, headers, timeout, and schedule from raw packet data or JetstreamRecord. */
-    private extractRecordData;
+    unwrap<T>(): T;
+    /** Access the pattern registry (for module-level introspection). */
+    getPatternRegistry(): PatternRegistry;
+    /** Determine which streams and durable consumers are needed. */
+    private resolveRequiredKinds;
+    /** Populate the shared ack_wait map from actual NATS consumer configs. */
+    private populateAckWaitMap;
+    /** Build max_deliver map from actual NATS consumer configs (not options). */
+    private buildMaxDeliverMap;
+}
+
+/** Minimal interface for anything that can be stopped during shutdown. */
+interface Stoppable {
+    close(): void;
+}
+/**
+ * Orchestrates graceful transport shutdown.
+ *
+ * Shutdown sequence:
+ * 1. Emit onShutdownStart hook
+ * 2. Stop accepting new messages (close subscriptions, stop consumers)
+ * 3. Drain and close NATS connection (with timeout safety net)
+ * 4. Emit onShutdownComplete hook
+ *
+ * Idempotent — concurrent or repeated calls return the same promise.
+ * This is critical because NestJS may call `onApplicationShutdown` on
+ * multiple module instances (forRoot + forFeature) that share this
+ * singleton, and the call order is not guaranteed.
+ */
+declare class ShutdownManager {
+    private readonly connection;
+    private readonly eventBus;
+    private readonly timeout;
+    private readonly logger;
+    private shutdownPromise?;
+    constructor(connection: ConnectionProvider, eventBus: EventBus, timeout: number);
     /**
-     * Build a schedule-holder subject for NATS message scheduling.
+     * Execute the full shutdown sequence.
      *
-     * The schedule-holder subject resides in the same stream as the target but
-     * uses a separate `_sch` namespace that is NOT matched by any consumer filter.
-     * NATS holds the message and publishes it to the target subject after the delay.
+     * Idempotent — concurrent or repeated calls return the same promise.
      *
-     * Examples:
-     * - `{svc}__microservice.ev.order.reminder` → `{svc}__microservice._sch.order.reminder`
-     * - `broadcast.config.updated` → `broadcast._sch.config.updated`
+     * @param strategy Optional stoppable to close (stops consumers and subscriptions).
      */
-    private buildScheduleSubject;
+    shutdown(strategy?: Stoppable): Promise<void>;
+    private doShutdown;
 }
 
 /**
- * Immutable message record for JetStream transport.
+ * Root module for the NestJS JetStream transport.
  *
- * Compatible with NestJS record builder pattern (like RmqRecord, NatsRecord).
- * Pass as the second argument to `client.send()` or `client.emit()`.
+ * - `forRoot()` / `forRootAsync()` — registers once in AppModule.
+ *   Creates shared NATS connection, codec, event bus, and optionally
+ *   the consumer infrastructure.
+ *
+ * - `forFeature()` — registers in feature modules.
+ *   Creates a lightweight client proxy targeting a specific service.
  *
  * @example
  * ```typescript
- * const record = new JetstreamRecordBuilder({ id: 1 })
- *   .setHeader('x-tenant', 'acme')
- *   .setTimeout(5000)
- *   .build();
+ * // AppModule — global setup
+ * @Module({
+ *   imports: [
+ *     JetstreamModule.forRoot({
+ *       name: 'orders',
+ *       servers: ['nats://localhost:4222'],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
  *
- * client.send('get.user', record);
+ * // Feature module — per-service clients
+ * @Module({
+ *   imports: [
+ *     JetstreamModule.forFeature({ name: 'users' }),
+ *     JetstreamModule.forFeature({ name: 'payments' }),
+ *   ],
+ * })
+ * export class OrdersModule {}
  * ```
  */
-declare class JetstreamRecord<TData = unknown> {
-    /** Message payload. */
-    readonly data: TData;
-    /** Custom headers set via {@link JetstreamRecordBuilder.setHeader}. */
-    readonly headers: ReadonlyMap<string, string>;
-    /** Per-request RPC timeout override in ms. */
-    readonly timeout?: number | undefined;
-    /** Custom message ID for JetStream deduplication. */
-    readonly messageId?: string | undefined;
-    /** Schedule options for delayed delivery. */
-    readonly schedule?: ScheduleRecordOptions | undefined;
-    /** Per-message TTL as Go duration string (e.g. "30s", "5m"). */
-    readonly ttl?: string | undefined;
-    constructor(
-    /** Message payload. */
-    data: TData, 
-    /** Custom headers set via {@link JetstreamRecordBuilder.setHeader}. */
-    headers: ReadonlyMap<string, string>, 
-    /** Per-request RPC timeout override in ms. */
-    timeout?: number | undefined, 
-    /** Custom message ID for JetStream deduplication. */
-    messageId?: string | undefined, 
-    /** Schedule options for delayed delivery. */
-    schedule?: ScheduleRecordOptions | undefined, 
-    /** Per-message TTL as Go duration string (e.g. "30s", "5m"). */
-    ttl?: string | undefined);
-}
-/**
- * Fluent builder for constructing JetstreamRecord instances.
- *
- * Protected headers (`correlation-id`, `reply-to`, `error`) cannot be
- * set by the user — attempting to do so throws an error at build time.
- */
-declare class JetstreamRecordBuilder<TData = unknown> {
-    private data;
-    private readonly headers;
-    private timeout;
-    private messageId;
-    private scheduleOptions;
-    private ttlDuration;
-    constructor(data?: TData);
-    /**
-     * Set the message payload.
-     *
-     * @param data - Payload to serialize via the configured {@link Codec}.
-     */
-    setData(data: TData): this;
-    /**
-     * Set a single custom header.
-     *
-     * @param key - Header name (e.g. `'x-tenant'`).
-     * @param value - Header value.
-     * @throws Error if the header name is reserved by the transport.
-     */
-    setHeader(key: string, value: string): this;
-    /**
-     * Set multiple custom headers at once.
-     *
-     * @param headers - Key-value pairs to set as headers.
-     * @throws Error if any header name is reserved by the transport.
-     */
-    setHeaders(headers: Record<string, string>): this;
+declare class JetstreamModule implements OnApplicationShutdown {
+    private readonly shutdownManager?;
+    private readonly strategy?;
+    constructor(shutdownManager?: ShutdownManager | undefined, strategy?: (JetstreamStrategy | null) | undefined);
     /**
-     * Set a custom message ID for JetStream deduplication.
-     *
-     * NATS JetStream uses this ID to detect duplicate publishes within the
-     * stream's `duplicate_window`. If two messages with the same ID arrive
-     * within the window, the second is silently dropped.
-     *
-     * When not set, a random UUID is generated automatically.
-     *
-     * @param id - Unique message identifier (e.g. order ID, idempotency key).
+     * Register the JetStream transport globally.
      *
-     * @example
-     * ```typescript
-     * new JetstreamRecordBuilder(data)
-     *   .setMessageId(`order-${order.id}`)
-     *   .build();
-     * ```
-     */
-    setMessageId(id: string): this;
-    /**
-     * Set per-request RPC timeout.
+     * Creates a shared NATS connection, codec, event bus, and optionally
+     * the full consumer infrastructure (streams, consumers, routers).
      *
-     * @param ms - Timeout in milliseconds. Overrides the global RPC timeout for this request only.
+     * @param options Module configuration.
+     * @returns Dynamic module ready to be imported.
      */
-    setTimeout(ms: number): this;
+    static forRoot(options: JetstreamModuleOptions): DynamicModule;
     /**
-     * Schedule one-shot delayed delivery.
-     *
-     * The message is held by NATS and delivered to the event consumer
-     * at the specified time. Requires NATS >= 2.12 and `allow_msg_schedules: true`
-     * on the event stream (via `events: { stream: { allow_msg_schedules: true } }`).
+     * Register the JetStream transport globally with async configuration.
      *
-     * Only meaningful for events (`client.emit()`). If used with RPC
-     * (`client.send()`), a warning is logged and the schedule is ignored.
+     * Supports `useFactory`, `useExisting`, and `useClass` patterns
+     * for loading configuration from ConfigService, environment, etc.
      *
-     * @param date - Delivery time. Must be in the future.
-     * @throws Error if the date is not in the future.
+     * @param asyncOptions Async configuration.
+     * @returns Dynamic module ready to be imported.
      */
-    scheduleAt(date: Date): this;
+    static forRootAsync(asyncOptions: JetstreamModuleAsyncOptions): DynamicModule;
     /**
-     * Set per-message TTL (time-to-live).
-     *
-     * The message expires individually after the specified duration,
-     * independent of the stream's `max_age`. Requires NATS >= 2.11 and
-     * `allow_msg_ttl: true` on the stream.
-     *
-     * Only meaningful for events (`client.emit()`). If used with RPC
-     * (`client.send()`), a warning is logged and the TTL is ignored.
-     *
-     * @param nanos - TTL in nanoseconds. Use {@link toNanos} for human-readable values.
+     * Register a lightweight client proxy for a target service.
      *
-     * @example
-     * ```typescript
-     * import { toNanos } from '@horizon-republic/nestjs-jetstream';
+     * Reuses the shared NATS connection from `forRoot()`.
+     * Import in each feature module that needs to communicate with a specific service.
      *
-     * new JetstreamRecordBuilder(payload).ttl(toNanos(30, 'minutes')).build();
-     * new JetstreamRecordBuilder(payload).ttl(toNanos(24, 'hours')).build();
-     * ```
+     * @param options Feature options with target service name.
+     * @returns Dynamic module with the client provider.
      */
-    ttl(nanos: number): this;
+    static forFeature(options: JetstreamFeatureOptions): DynamicModule;
+    private static createCoreProviders;
+    /** Create providers that depend on JETSTREAM_OPTIONS (shared by sync and async). */
+    private static createCoreDependentProviders;
+    /** Create async options provider from useFactory/useExisting/useClass. */
+    private static createAsyncOptionsProvider;
     /**
-     * Build the immutable {@link JetstreamRecord}.
-     *
-     * @returns A frozen record ready to pass to `client.send()` or `client.emit()`.
+     * Gracefully shut down the transport on application termination.
      */
-    build(): JetstreamRecord<TData>;
-    /** Validate that a header key is not reserved. */
-    private validateHeaderKey;
+    onApplicationShutdown(): Promise<void>;
 }
 
 /**
@@ -1873,4 +2184,4 @@ declare const isJetStreamRpcMode: (rpc: RpcConfig | undefined) => boolean;
 /** Check if the RPC config specifies Core mode (default). */
 declare const isCoreRpcMode: (rpc: RpcConfig | undefined) => boolean;
 
-export { type Codec, 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, DEFAULT_ORDERED_STREAM_CONFIG, DEFAULT_RPC_TIMEOUT, DEFAULT_SHUTDOWN_TIMEOUT, type DeadLetterInfo, JETSTREAM_CODEC, JETSTREAM_CONNECTION, JETSTREAM_OPTIONS, JetstreamClient, JetstreamDlqHeader, type JetstreamFeatureOptions, JetstreamHeader, JetstreamHealthIndicator, type JetstreamHealthStatus, JetstreamModule, type JetstreamModuleAsyncOptions, type JetstreamModuleOptions, JetstreamRecord, JetstreamRecordBuilder, JetstreamStrategy, JsonCodec, MIN_METADATA_TTL, MessageKind, type MetadataRegistryOptions, MsgpackCodec, NatsErrorCode, type OrderedEventOverrides, PatternPrefix, RESERVED_HEADERS, type RpcConfig, RpcContext, type ScheduleRecordOptions, type StreamConfigOverrides, type StreamConsumerOverrides, StreamKind, TransportEvent, type TransportHooks, buildBroadcastSubject, buildSubject, consumerName, dlqStreamName, getClientToken, internalName, isCoreRpcMode, isJetStreamRpcMode, metadataKey, streamName, toNanos };
+export { type CaptureBodyOptions, type Codec, ConsumeKind, type ConsumeSourceMsg, 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, DEFAULT_ORDERED_STREAM_CONFIG, DEFAULT_RPC_TIMEOUT, DEFAULT_SHUTDOWN_TIMEOUT, DEFAULT_TRACES, type DeadLetterInfo, type ErrorClassification, type HandlerMetadata, JETSTREAM_CODEC, JETSTREAM_CONNECTION, JETSTREAM_OPTIONS, JetstreamClient, type JetstreamConsumeContext, JetstreamDlqHeader, type JetstreamFeatureOptions, JetstreamHeader, JetstreamHealthIndicator, type JetstreamHealthStatus, JetstreamModule, type JetstreamModuleAsyncOptions, type JetstreamModuleOptions, type JetstreamPublishContext, JetstreamRecord, JetstreamRecordBuilder, type JetstreamResponseContext, JetstreamStrategy, JetstreamTrace, JsonCodec, MIN_METADATA_TTL, MessageKind, type MetadataRegistryOptions, MsgpackCodec, NatsErrorCode, type OrderedEventOverrides, type OtelOptions, PatternPrefix, PublishKind, RESERVED_HEADERS, type RpcConfig, RpcContext, type ScheduleRecordOptions, type ServerEndpoint, type StreamConfigOverrides, type StreamConsumerOverrides, StreamKind, TRACER_NAME, TransportEvent, type TransportHooks, buildBroadcastSubject, buildSubject, consumerName, dlqStreamName, getClientToken, internalName, isCoreRpcMode, isJetStreamRpcMode, metadataKey, streamName, toNanos };