@burdenoff/be-sdk 2026.512.103 → 2026.513.1

package/dist/chunk-BQRXB4CW.js

@@ -0,0 +1,2183 @@
+import { QueueType } from './chunk-UVYDP6P6.js';
+import { NatsConnectionManager } from './chunk-COSUYUCB.js';
+import { DEFAULT_LAYER_RESOURCES } from './chunk-NGMEI42S.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __name } from './chunk-XE4OXN2W.js';
+import { RetentionPolicy, StorageType, AckPolicy, DeliverPolicy, headers } from 'nats';
+import { randomUUID } from 'crypto';
+import { hostname } from 'os';
+
+// src/event-queue/implementations/nats/trace-context.ts
+var otelApiPromise = null;
+async function loadOtelApi() {
+  if (otelApiPromise) {
+    return otelApiPromise;
+  }
+  otelApiPromise = (async () => {
+    try {
+      const mod = await import('./esm-M2M7HGV4.js');
+      return mod;
+    } catch {
+      logger.debug("[trace-context] @opentelemetry/api not available; NATS traces disabled");
+      return null;
+    }
+  })();
+  return otelApiPromise;
+}
+__name(loadOtelApi, "loadOtelApi");
+var setter = {
+  set(carrier, key, value) {
+    carrier[key] = value;
+  }
+};
+var getter = {
+  get(carrier, key) {
+    return carrier[key];
+  },
+  keys(carrier) {
+    return Object.keys(carrier);
+  }
+};
+async function injectW3CTraceContext(hdrs) {
+  const api = await loadOtelApi();
+  if (!api) return;
+  try {
+    const carrier = {};
+    api.propagation.inject(api.context.active(), carrier, setter);
+    for (const [key, value] of Object.entries(carrier)) {
+      if (value) hdrs.set(key, value);
+    }
+  } catch (err) {
+    logger.debug("[trace-context] injection failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+__name(injectW3CTraceContext, "injectW3CTraceContext");
+async function extractW3CTraceContext(hdrs) {
+  const api = await loadOtelApi();
+  if (!api || !hdrs) return void 0;
+  try {
+    const carrier = {};
+    for (const key of [
+      "traceparent",
+      "tracestate",
+      "baggage"
+    ]) {
+      const value = hdrs.get(key);
+      if (value) carrier[key] = value;
+    }
+    return api.propagation.extract(api.context.active(), carrier, getter);
+  } catch (err) {
+    logger.debug("[trace-context] extraction failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
+}
+__name(extractW3CTraceContext, "extractW3CTraceContext");
+async function runWithConsumerSpan(subject, hdrs, handler) {
+  const api = await loadOtelApi();
+  if (!api) return handler();
+  try {
+    const parentCtx = await extractW3CTraceContext(hdrs);
+    const tracer = api.trace.getTracer("@burdenoff/be-sdk/nats");
+    return await new Promise((resolve, reject) => {
+      tracer.startActiveSpan(`nats.consume ${subject}`, {
+        kind: 5,
+        attributes: {
+          "messaging.system": "nats",
+          "messaging.destination.name": subject
+        }
+      }, parentCtx, async (span) => {
+        try {
+          const result = await handler();
+          span.setStatus({
+            code: 1
+          });
+          span.end();
+          resolve(result);
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({
+            code: 2,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          span.end();
+          reject(err);
+        }
+      });
+    });
+  } catch (err) {
+    logger.debug("[trace-context] consumer span failed to start; running without span", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return handler();
+  }
+}
+__name(runWithConsumerSpan, "runWithConsumerSpan");
+var DEFAULT_STREAM_MAX_BYTES = 10 * 1024 * 1024;
+var NatsSubscription = class NatsSubscription2 {
+  static {
+    __name(this, "NatsSubscription");
+  }
+  id;
+  subject;
+  stopFn;
+  active = true;
+  stats = {
+    messagesReceived: 0,
+    messagesProcessed: 0,
+    messagesFailed: 0,
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  constructor(id, subject, stopFn) {
+    this.id = id;
+    this.subject = subject;
+    this.stopFn = stopFn;
+  }
+  async unsubscribe() {
+    if (!this.active) {
+      return Promise.resolve();
+    }
+    this.active = false;
+    this.stopFn();
+    return Promise.resolve();
+  }
+  isActive() {
+    return this.active;
+  }
+  getStats() {
+    return {
+      messagesReceived: this.stats.messagesReceived,
+      messagesProcessed: this.stats.messagesProcessed,
+      messagesFailed: this.stats.messagesFailed,
+      lastActivity: this.stats.lastActivity
+    };
+  }
+  incrementReceived() {
+    this.stats.messagesReceived++;
+    this.stats.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  incrementProcessed() {
+    this.stats.messagesProcessed++;
+    this.stats.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  incrementFailed() {
+    this.stats.messagesFailed++;
+    this.stats.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+var NatsEventConsumer = class {
+  static {
+    __name(this, "NatsEventConsumer");
+  }
+  config;
+  connectionManager;
+  subscriptions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    const baseConfig = {
+      type: config.type || "nats",
+      url: config.url || "nats://localhost:4222",
+      user: config.user,
+      password: config.password,
+      token: config.token,
+      creds: config.creds,
+      credsFile: config.credsFile,
+      maxReconnectAttempts: config.maxReconnectAttempts,
+      reconnectTimeWait: config.reconnectTimeWait,
+      connectionTimeout: config.connectionTimeout,
+      name: config.name
+    };
+    this.connectionManager = new NatsConnectionManager(baseConfig);
+  }
+  /**
+  * Connect to NATS server
+  */
+  async connect() {
+    await this.connectionManager.connect();
+  }
+  /**
+  * Disconnect from NATS server
+  */
+  async disconnect() {
+    await this.unsubscribeAll();
+    await this.connectionManager.disconnect();
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.connectionManager.isConnected();
+  }
+  /**
+  * Health check
+  */
+  async healthCheck() {
+    await Promise.resolve();
+    const isConnected = this.isConnected();
+    return {
+      status: isConnected ? "healthy" : "unhealthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      connected: isConnected,
+      details: {
+        type: "nats",
+        url: this.config.url,
+        activeSubscriptions: this.subscriptions.size
+      }
+    };
+  }
+  /**
+  * Get queue statistics
+  */
+  async getStatistics() {
+    await Promise.resolve();
+    let totalReceived = 0;
+    let totalProcessed = 0;
+    let totalFailed = 0;
+    let lastActivity = null;
+    for (const subscription of this.subscriptions.values()) {
+      const stats = subscription.getStats();
+      totalReceived += stats.messagesReceived;
+      totalProcessed += stats.messagesProcessed;
+      totalFailed += stats.messagesFailed;
+      if (stats.lastActivity && (!lastActivity || stats.lastActivity > lastActivity)) {
+        lastActivity = stats.lastActivity;
+      }
+    }
+    return {
+      messagesPublished: 0,
+      messagesConsumed: totalProcessed,
+      messagesFailed: totalFailed,
+      activeConsumers: this.subscriptions.size,
+      activePublishers: 0,
+      queueSize: 0,
+      lastActivity,
+      details: {
+        totalReceived,
+        type: "nats"
+      }
+    };
+  }
+  /**
+  * Ensure a stream exists
+  */
+  async ensureStream(config) {
+    const jsm = this.connectionManager.getJetStreamManager();
+    try {
+      try {
+        await jsm.streams.info(config.name);
+        logger.debug("[NatsEventConsumer] Stream already exists", {
+          stream: config.name
+        });
+        return;
+      } catch {
+      }
+      const streamConfig = {
+        name: config.name,
+        subjects: config.subjects,
+        retention: this.mapRetentionPolicy(config.retention),
+        storage: this.mapStorageType(config.storage),
+        max_consumers: config.maxConsumers,
+        max_msgs: config.maxMsgs,
+        max_bytes: config.maxBytes ?? DEFAULT_STREAM_MAX_BYTES,
+        max_age: config.maxAge,
+        duplicate_window: config.duplicateWindow
+      };
+      await jsm.streams.add(streamConfig);
+      logger.info("[NatsEventConsumer] Stream created successfully", {
+        stream: config.name,
+        subjects: config.subjects
+      });
+    } catch (error) {
+      logger.error("[NatsEventConsumer] Failed to ensure stream", {
+        stream: config.name,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Ensure a consumer exists
+  */
+  async ensureConsumer(config) {
+    const jsm = this.connectionManager.getJetStreamManager();
+    try {
+      await jsm.consumers.add(config.stream, {
+        name: config.consumer,
+        durable_name: config.consumer,
+        filter_subject: config.filterSubject,
+        ack_policy: this.mapAckPolicy(config.ackPolicy),
+        deliver_policy: this.mapDeliverPolicy(config.deliverPolicy),
+        max_deliver: config.maxDeliver || 3,
+        ack_wait: config.ackWait || 3e10,
+        max_ack_pending: config.maxAckPending || 100
+      });
+      logger.info("[NatsEventConsumer] Consumer created successfully", {
+        stream: config.stream,
+        consumer: config.consumer
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message?.includes("already exists")) {
+        logger.debug("[NatsEventConsumer] Consumer already exists", {
+          stream: config.stream,
+          consumer: config.consumer
+        });
+      } else {
+        logger.error("[NatsEventConsumer] Failed to ensure consumer", {
+          stream: config.stream,
+          consumer: config.consumer,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        throw error;
+      }
+    }
+  }
+  /**
+  * Derive stream subject pattern from subscription subject
+  * Examples:
+  *   - "channel.conversation.message" → ["channel.>"]
+  *   - "wspace.tags.created" → ["wspace.>"]
+  *   - "global.auth.login" → ["global.>"]
+  */
+  deriveStreamSubjects(subject) {
+    const firstSegment = subject.split(".")[0];
+    if (firstSegment) {
+      return [
+        `${firstSegment}.>`
+      ];
+    }
+    return [
+      `${subject.replace(/\.[^.]+$/, ".>")}`
+    ];
+  }
+  /**
+  * Subscribe to a subject
+  */
+  async subscribe(options) {
+    const js = this.connectionManager.getJetStream();
+    const jsm = this.connectionManager.getJetStreamManager();
+    try {
+      let streamName = options.options?.stream || this.config.stream;
+      const consumerName = options.options?.consumer || `${this.config.consumer}-${options.subject.replace(/\./g, "-")}`;
+      const streamSubjects = options.options?.streamSubjects || this.deriveStreamSubjects(options.subject);
+      try {
+        await this.ensureStream({
+          name: streamName,
+          subjects: streamSubjects,
+          retention: options.options?.retention || "limits",
+          storage: options.options?.storage || "file"
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!errorMessage.includes("subjects overlap")) {
+          throw error;
+        }
+        streamName = await jsm.streams.find(options.subject);
+        logger.info("[NatsEventConsumer] Using existing stream for overlapping subject", {
+          requestedStream: options.options?.stream || this.config.stream,
+          stream: streamName,
+          subject: options.subject
+        });
+      }
+      await this.ensureConsumer({
+        type: this.config.type,
+        url: this.config.url,
+        consumer: consumerName,
+        stream: streamName,
+        filterSubject: options.subject,
+        ackPolicy: options.options?.ackPolicy,
+        deliverPolicy: options.options?.deliverPolicy,
+        maxDeliver: options.options?.maxDeliver || this.config.maxDeliver,
+        ackWait: options.options?.ackWait || this.config.ackWait,
+        maxAckPending: options.options?.maxAckPending
+      });
+      const consumer = await js.consumers.get(streamName, consumerName);
+      const subscriptionId = `sub_${Date.now()}_${crypto.randomUUID().substring(0, 7)}`;
+      let stopRequested = false;
+      const stopFn = /* @__PURE__ */ __name(() => {
+        stopRequested = true;
+      }, "stopFn");
+      const subscription = new NatsSubscription(subscriptionId, options.subject, stopFn);
+      this.subscriptions.set(subscriptionId, subscription);
+      this.consumeMessages(consumer, subscription, options.handler, options.options?.maxConcurrent || this.config.maxConcurrent || 1, () => stopRequested).catch((error) => {
+        logger.error("[NatsEventConsumer] Error in message consumption loop", {
+          subject: options.subject,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      });
+      logger.info("[NatsEventConsumer] Subscription created", {
+        subscriptionId,
+        subject: options.subject
+      });
+      return subscription;
+    } catch (error) {
+      logger.error("[NatsEventConsumer] Failed to subscribe", {
+        subject: options.subject,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Subscribe to multiple subjects
+  */
+  async subscribeMultiple(subjects, handler, options) {
+    const subscriptions = [];
+    for (const subject of subjects) {
+      const subscription = await this.subscribe({
+        subject,
+        handler,
+        options
+      });
+      subscriptions.push(subscription);
+    }
+    return subscriptions;
+  }
+  /**
+  * Pull messages manually
+  */
+  async pull(options) {
+    const js = this.connectionManager.getJetStream();
+    try {
+      const consumer = await js.consumers.get(this.config.stream, this.config.consumer);
+      const messages = await consumer.fetch({
+        max_messages: options.batch || 10,
+        expires: options.timeout || 3e4
+      });
+      const events = [];
+      for await (const msg of messages) {
+        const event = this.wrapMessage(msg);
+        events.push(event);
+      }
+      return events;
+    } catch (error) {
+      logger.error("[NatsEventConsumer] Failed to pull messages", {
+        subject: options.subject,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Unsubscribe from all active subscriptions
+  */
+  async unsubscribeAll() {
+    const unsubscribePromises = Array.from(this.subscriptions.values()).map(async (subscription) => subscription.unsubscribe());
+    await Promise.all(unsubscribePromises);
+    this.subscriptions.clear();
+    logger.info("[NatsEventConsumer] All subscriptions unsubscribed");
+  }
+  /**
+  * Get all active subscriptions
+  */
+  getSubscriptions() {
+    return Array.from(this.subscriptions.values());
+  }
+  /**
+  * Process pending messages in dead letter queue
+  */
+  async processDLQ(_handler) {
+    await Promise.resolve();
+    logger.warn("[NatsEventConsumer] DLQ processing not yet implemented");
+  }
+  /**
+  * List subjects for the configured stream
+  */
+  async listSubjects(streamName) {
+    const jsm = this.connectionManager.getJetStreamManager();
+    const info = await jsm.streams.info(streamName || this.config.stream);
+    return info.config.subjects || [];
+  }
+  /**
+  * Consume messages from consumer
+  */
+  async consumeMessages(consumer, subscription, handler, maxConcurrent, stopRequested) {
+    try {
+      const messages = await consumer.consume({
+        max_messages: maxConcurrent,
+        expires: 3e4
+      });
+      for await (const msg of messages) {
+        if (stopRequested()) {
+          break;
+        }
+        subscription.incrementReceived();
+        try {
+          const event = this.wrapMessage(msg);
+          await runWithConsumerSpan(msg.subject, msg.headers, async () => handler(event));
+          subscription.incrementProcessed();
+        } catch (error) {
+          subscription.incrementFailed();
+          logger.error("[NatsEventConsumer] Error processing message", {
+            subject: msg.subject,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+          msg.nak();
+        }
+      }
+    } catch (error) {
+      logger.error("[NatsEventConsumer] Error consuming messages", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+  * Wrap NATS message in AcknowledgeableEvent
+  */
+  wrapMessage(msg) {
+    const eventMessage = JSON.parse(msg.data.toString());
+    return {
+      ...eventMessage,
+      sequence: msg.seq,
+      ack: /* @__PURE__ */ __name(async () => {
+        await Promise.resolve();
+        msg.ack();
+      }, "ack"),
+      nak: /* @__PURE__ */ __name(async (delay) => {
+        await Promise.resolve();
+        if (delay) {
+          msg.nak(delay);
+        } else {
+          msg.nak();
+        }
+      }, "nak"),
+      term: /* @__PURE__ */ __name(async () => {
+        await Promise.resolve();
+        msg.term();
+      }, "term"),
+      isRedelivered: /* @__PURE__ */ __name(() => {
+        return msg.redelivered;
+      }, "isRedelivered"),
+      getDeliveryAttempt: /* @__PURE__ */ __name(() => {
+        return msg.info.deliveryCount;
+      }, "getDeliveryAttempt")
+    };
+  }
+  /**
+  * Map retention policy string to NATS enum
+  */
+  mapRetentionPolicy(policy) {
+    switch (policy?.toLowerCase()) {
+      case "limits":
+        return RetentionPolicy.Limits;
+      case "interest":
+        return RetentionPolicy.Interest;
+      case "workqueue":
+      default:
+        return RetentionPolicy.Workqueue;
+    }
+  }
+  /**
+  * Map storage type string to NATS enum
+  */
+  mapStorageType(storage) {
+    switch (storage?.toLowerCase()) {
+      case "memory":
+        return StorageType.Memory;
+      case "file":
+      default:
+        return StorageType.File;
+    }
+  }
+  /**
+  * Map ack policy string to NATS enum
+  */
+  mapAckPolicy(policy) {
+    switch (policy?.toLowerCase()) {
+      case "none":
+        return AckPolicy.None;
+      case "all":
+        return AckPolicy.All;
+      case "explicit":
+      default:
+        return AckPolicy.Explicit;
+    }
+  }
+  /**
+  * Map deliver policy string to NATS enum
+  */
+  mapDeliverPolicy(policy) {
+    switch (policy?.toLowerCase()) {
+      case "new":
+        return DeliverPolicy.New;
+      case "last":
+        return DeliverPolicy.Last;
+      case "lastpersubject":
+        return DeliverPolicy.LastPerSubject;
+      case "all":
+      default:
+        return DeliverPolicy.All;
+    }
+  }
+};
+var DEFAULT_STREAM_MAX_BYTES2 = 10 * 1024 * 1024;
+var NatsEventPublisher = class {
+  static {
+    __name(this, "NatsEventPublisher");
+  }
+  config;
+  connectionManager;
+  publishCount = 0;
+  lastPublishTime = null;
+  constructor(config) {
+    this.config = config;
+    this.connectionManager = new NatsConnectionManager(config);
+  }
+  /**
+  * Connect to NATS server
+  */
+  async connect() {
+    await this.connectionManager.connect();
+  }
+  /**
+  * Disconnect from NATS server
+  */
+  async disconnect() {
+    await this.connectionManager.disconnect();
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.connectionManager.isConnected();
+  }
+  /**
+  * Health check
+  */
+  async healthCheck() {
+    await Promise.resolve();
+    const isConnected = this.isConnected();
+    return {
+      status: isConnected ? "healthy" : "unhealthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      details: {
+        connected: isConnected,
+        type: "nats",
+        url: this.config.url
+      }
+    };
+  }
+  /**
+  * Get queue statistics
+  */
+  async getStatistics() {
+    const jsm = this.connectionManager.getJetStreamManager();
+    try {
+      const streams = await jsm.streams.list().next();
+      const streamCount = streams.length;
+      return {
+        messagesPublished: this.publishCount,
+        messagesConsumed: 0,
+        messagesFailed: 0,
+        activeConsumers: 0,
+        activePublishers: 1,
+        queueSize: 0,
+        lastActivity: this.lastPublishTime?.toISOString() || null,
+        details: {
+          streamCount,
+          type: "nats"
+        }
+      };
+    } catch (error) {
+      logger.error("[NatsEventPublisher] Failed to get statistics", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Ensure a stream exists
+  */
+  async ensureStream(config) {
+    const jsm = this.connectionManager.getJetStreamManager();
+    try {
+      try {
+        await jsm.streams.info(config.name);
+        logger.debug("[NatsEventPublisher] Stream already exists", {
+          stream: config.name
+        });
+        return;
+      } catch {
+      }
+      const streamConfig = {
+        name: config.name,
+        subjects: config.subjects,
+        retention: this.mapRetentionPolicy(config.retention),
+        storage: this.mapStorageType(config.storage),
+        max_consumers: config.maxConsumers,
+        max_msgs: config.maxMsgs,
+        max_bytes: config.maxBytes ?? DEFAULT_STREAM_MAX_BYTES2,
+        max_age: config.maxAge,
+        duplicate_window: config.duplicateWindow
+      };
+      await jsm.streams.add(streamConfig);
+      logger.info("[NatsEventPublisher] Stream created successfully", {
+        stream: config.name,
+        subjects: config.subjects
+      });
+    } catch (error) {
+      logger.error("[NatsEventPublisher] Failed to ensure stream", {
+        stream: config.name,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Derive stream subject pattern from subscription subject
+  * Examples:
+  *   - "channel.conversation.message" → ["channel.>"]
+  *   - "wspace.tags.created" → ["wspace.>"]
+  *   - "global.auth.login" → ["global.>"]
+  */
+  deriveStreamSubjects(subject) {
+    const firstSegment = subject.split(".")[0];
+    if (firstSegment) {
+      return [
+        `${firstSegment}.>`
+      ];
+    }
+    return [
+      `${subject.replace(/\.[^.]+$/, ".>")}`
+    ];
+  }
+  /**
+  * Derive stream name from subject
+  * Examples:
+  *   - "channel.conversation.message" → "CHANNEL_EVENTS"
+  *   - "wspace.tags.created" → "WSPACE_EVENTS"
+  *   - "global.auth.login" → "GLOBAL_EVENTS"
+  */
+  deriveStreamName(subject) {
+    const firstSegment = subject.split(".")[0];
+    if (firstSegment) {
+      return `${firstSegment.toUpperCase()}_EVENTS`;
+    }
+    return "EVENTS";
+  }
+  /**
+  * Publish an event to a subject
+  */
+  async publish(options) {
+    const js = this.connectionManager.getJetStream();
+    try {
+      const streamName = options.options?.stream || this.deriveStreamName(options.subject);
+      const streamSubjects = options.options?.streamSubjects || this.deriveStreamSubjects(options.subject);
+      await this.ensureStream({
+        name: streamName,
+        subjects: streamSubjects,
+        retention: options.options?.retention || "limits",
+        storage: options.options?.storage || "file"
+      });
+      const message = {
+        id: options.options?.messageId || this.generateMessageId(),
+        subject: options.subject,
+        data: options.data,
+        metadata: {
+          source: options.metadata?.source || "workspaces-backend",
+          correlationId: options.metadata?.correlationId || this.generateCorrelationId(),
+          userId: options.metadata?.userId,
+          workspaceId: options.metadata?.workspaceId,
+          priority: options.options?.priority || this.config.defaultPriority || "normal",
+          ...options.metadata
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const hdrs = headers();
+      hdrs.set("message-id", message.id);
+      hdrs.set("correlation-id", message.metadata.correlationId);
+      if (message.metadata.source) {
+        hdrs.set("source", message.metadata.source);
+      }
+      if (message.metadata["priority"] && typeof message.metadata["priority"] === "string") {
+        hdrs.set("priority", message.metadata["priority"]);
+      }
+      if (message.metadata.userId) {
+        hdrs.set("user-id", message.metadata.userId);
+      }
+      if (message.metadata.workspaceId) {
+        hdrs.set("workspace-id", message.metadata.workspaceId);
+      }
+      await injectW3CTraceContext(hdrs);
+      const publishOpts = {
+        msgID: this.config.enableDeduplication ? message.id : void 0,
+        headers: hdrs
+      };
+      if (options.options?.ttl) {
+        logger.warn("[NatsEventPublisher] Per-message TTL not supported in NATS", {
+          subject: options.subject,
+          ttl: options.options.ttl
+        });
+      }
+      if (options.options?.delay) {
+        logger.warn("[NatsEventPublisher] Message delay not supported in NATS", {
+          subject: options.subject,
+          delay: options.options.delay
+        });
+      }
+      const ack = await js.publish(options.subject, JSON.stringify(message), publishOpts);
+      this.publishCount++;
+      this.lastPublishTime = /* @__PURE__ */ new Date();
+      logger.debug("[NatsEventPublisher] Event published", {
+        subject: options.subject,
+        messageId: message.id,
+        sequence: ack.seq
+      });
+      return ack.seq;
+    } catch (error) {
+      logger.error("[NatsEventPublisher] Failed to publish event", {
+        subject: options.subject,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Publish multiple events in a batch
+  */
+  async publishBatch(events) {
+    const results = [];
+    for (const event of events) {
+      const seq = await this.publish(event);
+      results.push(seq);
+    }
+    return results;
+  }
+  /**
+  * Publish an event and wait for acknowledgment
+  * Note: This is not natively supported by NATS JetStream
+  * Would require implementing request-reply pattern
+  */
+  async publishWithAck(options) {
+    const nc = this.connectionManager.getNatsConnection();
+    try {
+      const message = {
+        id: this.generateMessageId(),
+        subject: options.subject,
+        data: options.data,
+        metadata: {
+          source: options.metadata?.source || "workspaces-backend",
+          correlationId: options.metadata?.correlationId || this.generateCorrelationId(),
+          userId: options.metadata?.userId,
+          workspaceId: options.metadata?.workspaceId,
+          ...options.metadata
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const response = await nc.request(options.subject, JSON.stringify(message), {
+        timeout: options.timeout || 3e4
+      });
+      const result = JSON.parse(response.data.toString());
+      logger.debug("[NatsEventPublisher] Event published with ack", {
+        subject: options.subject,
+        messageId: message.id
+      });
+      return result;
+    } catch (error) {
+      logger.error("[NatsEventPublisher] Failed to publish event with ack", {
+        subject: options.subject,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+  * Map retention policy string to NATS enum
+  */
+  mapRetentionPolicy(policy) {
+    switch (policy?.toLowerCase()) {
+      case "limits":
+        return RetentionPolicy.Limits;
+      case "interest":
+        return RetentionPolicy.Interest;
+      case "workqueue":
+      default:
+        return RetentionPolicy.Workqueue;
+    }
+  }
+  /**
+  * Map storage type string to NATS enum
+  */
+  mapStorageType(storage) {
+    switch (storage?.toLowerCase()) {
+      case "memory":
+        return StorageType.Memory;
+      case "file":
+      default:
+        return StorageType.File;
+    }
+  }
+  /**
+  * Generate unique message ID
+  */
+  generateMessageId() {
+    return `msg_${Date.now()}_${crypto.randomUUID().substring(0, 13)}`;
+  }
+  /**
+  * Generate correlation ID
+  */
+  generateCorrelationId() {
+    return `corr_${Date.now()}_${crypto.randomUUID().substring(0, 13)}`;
+  }
+};
+
+// src/event-queue/implementations/redis-streams/RedisStreamsConnection.ts
+var ioredisModulePromise = null;
+async function loadIoRedis() {
+  if (!ioredisModulePromise) {
+    ioredisModulePromise = (async () => {
+      try {
+        const mod = await import('ioredis');
+        return mod.default ?? mod.Redis ?? null;
+      } catch (err) {
+        logger.error("[RedisStreamsConnection] ioredis not installed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return null;
+      }
+    })();
+  }
+  const ctor = await ioredisModulePromise;
+  if (!ctor) {
+    throw new Error("[RedisStreamsConnection] ioredis is required for the redis-streams event-queue backend. Install it with: bun add ioredis  (or  npm i ioredis)");
+  }
+  return ctor;
+}
+__name(loadIoRedis, "loadIoRedis");
+function normaliseUrl(rawUrl) {
+  let url = rawUrl;
+  let tls = false;
+  if (/^valkeys:\/\//.test(url)) {
+    tls = true;
+    url = url.replace(/^valkeys:\/\//, "rediss://");
+  } else if (/^valkey:\/\//.test(url)) {
+    url = url.replace(/^valkey:\/\//, "redis://");
+  } else if (/^rediss:\/\//.test(url)) {
+    tls = true;
+  }
+  let host = "localhost";
+  try {
+    const parsed = new URL(url);
+    host = parsed.hostname || host;
+  } catch {
+  }
+  return {
+    url,
+    tls,
+    host
+  };
+}
+__name(normaliseUrl, "normaliseUrl");
+var RedisStreamsConnection = class {
+  static {
+    __name(this, "RedisStreamsConnection");
+  }
+  config;
+  client = null;
+  connecting = null;
+  tls;
+  host;
+  normalisedUrl;
+  constructor(config) {
+    this.config = config;
+    const { url, tls, host } = normaliseUrl(config.url);
+    this.normalisedUrl = url;
+    this.tls = tls || process.env["REDIS_TLS"] === "true";
+    this.host = host;
+  }
+  /** True once `connect()` has resolved and ioredis is in `ready` state. */
+  isConnected() {
+    return this.client !== null && this.client.status === "ready";
+  }
+  /** Connect lazily; subsequent calls await the in-flight promise. */
+  async connect() {
+    if (this.isConnected()) return;
+    if (this.connecting) {
+      await this.connecting;
+      return;
+    }
+    this.connecting = this.doConnect().finally(() => {
+      this.connecting = null;
+    });
+    await this.connecting;
+  }
+  async doConnect() {
+    const Redis = await loadIoRedis();
+    const opts = {
+      lazyConnect: true,
+      maxRetriesPerRequest: null,
+      enableReadyCheck: true,
+      connectTimeout: this.config.connectionTimeout ?? 15e3,
+      reconnectOnError: /* @__PURE__ */ __name(() => true, "reconnectOnError"),
+      retryStrategy: /* @__PURE__ */ __name((times) => Math.min(times * 200, 2e3), "retryStrategy")
+    };
+    if (this.config.password) opts["password"] = this.config.password;
+    if (this.config.user) opts["username"] = this.config.user;
+    if (this.tls) {
+      opts["tls"] = {
+        servername: this.host
+      };
+    }
+    this.client = new Redis(this.normalisedUrl, opts);
+    this.client.on("error", (...args) => {
+      const err = args[0];
+      logger.warn("[RedisStreamsConnection] redis error", {
+        error: err?.message ?? "unknown"
+      });
+    });
+    this.client.on("reconnecting", () => {
+      logger.info("[RedisStreamsConnection] reconnecting");
+    });
+    await this.client.connect();
+    logger.info("[RedisStreamsConnection] connected", {
+      url: this.normalisedUrl.replace(/:[^:@/]*@/, ":***@"),
+      tls: this.tls
+    });
+  }
+  async disconnect() {
+    if (!this.client) return;
+    try {
+      await this.client.quit();
+    } catch {
+      this.client.disconnect();
+    }
+    this.client = null;
+  }
+  /** The shared command client. Throws if not connected. */
+  getClient() {
+    if (!this.client) {
+      throw new Error("[RedisStreamsConnection] not connected \u2014 call connect() first");
+    }
+    return this.client;
+  }
+  /** Make a dedicated client (e.g. for a blocking XREADGROUP loop). */
+  async makeBlockingClient() {
+    await this.connect();
+    const dup = this.getClient().duplicate();
+    if ("connect" in dup && typeof dup.connect === "function") {
+      try {
+        await dup.connect();
+      } catch {
+      }
+    }
+    return dup;
+  }
+  async ping() {
+    await this.connect();
+    return this.getClient().ping();
+  }
+};
+
+// src/event-queue/implementations/redis-streams/keyspace.ts
+var DEFAULT_PREFIX = "boff:events";
+var REGISTRY_PREFIX = "boff:registry:subjects";
+var DELAYQ_PREFIX = "boff:delayq";
+var DELAYQ_LOCK_PREFIX = "boff:lock:delayq";
+var DLQ_PREFIX = "boff:dlq";
+var DEDUP_PREFIX = "boff:dedup";
+var REPLY_PREFIX = "boff:replies";
+function subjectToKey(subject) {
+  return subject.replace(/\./g, ":");
+}
+__name(subjectToKey, "subjectToKey");
+function streamKey(subject, opts = {}) {
+  const prefix = opts.prefix ?? DEFAULT_PREFIX;
+  return `${prefix}:${subjectToKey(subject)}`;
+}
+__name(streamKey, "streamKey");
+function registryKey(boundary) {
+  return `${REGISTRY_PREFIX}:${boundary}`;
+}
+__name(registryKey, "registryKey");
+function boundaryOf(subject) {
+  const first = subject.split(".")[0];
+  return first ?? subject;
+}
+__name(boundaryOf, "boundaryOf");
+function delayQueueKey(stream) {
+  return `${DELAYQ_PREFIX}:${stream}`;
+}
+__name(delayQueueKey, "delayQueueKey");
+function delayLockKey(stream) {
+  return `${DELAYQ_LOCK_PREFIX}:${stream}`;
+}
+__name(delayLockKey, "delayLockKey");
+function dlqKey(stream) {
+  return `${DLQ_PREFIX}:${stream}`;
+}
+__name(dlqKey, "dlqKey");
+function dedupKey(stream, msgId) {
+  return `${DEDUP_PREFIX}:${stream}:${msgId}`;
+}
+__name(dedupKey, "dedupKey");
+function replyKey(correlationId) {
+  return `${REPLY_PREFIX}:${correlationId}`;
+}
+__name(replyKey, "replyKey");
+function matchSubject(pattern, subject) {
+  if (pattern === subject) return true;
+  const pParts = pattern.split(".");
+  const sParts = subject.split(".");
+  const last = pParts[pParts.length - 1];
+  if (last === ">") {
+    if (sParts.length < pParts.length) return false;
+    for (let i = 0; i < pParts.length - 1; i++) {
+      if (pParts[i] !== sParts[i]) return false;
+    }
+    return true;
+  }
+  if (pParts.length !== sParts.length) return false;
+  for (let i = 0; i < pParts.length; i++) {
+    if (pParts[i] !== "*" && pParts[i] !== sParts[i]) return false;
+  }
+  return true;
+}
+__name(matchSubject, "matchSubject");
+function isWildcard(pattern) {
+  return pattern.includes("*") || pattern.includes(">");
+}
+__name(isWildcard, "isWildcard");
+
+// src/event-queue/implementations/redis-streams/trace-context.ts
+var otelApiPromise2 = null;
+async function loadOtelApi2() {
+  if (otelApiPromise2) return otelApiPromise2;
+  otelApiPromise2 = (async () => {
+    try {
+      const mod = await import('./esm-M2M7HGV4.js');
+      return mod;
+    } catch {
+      logger.debug("[redis-streams/trace-context] @opentelemetry/api not available; tracing disabled");
+      return null;
+    }
+  })();
+  return otelApiPromise2;
+}
+__name(loadOtelApi2, "loadOtelApi");
+var TRACE_KEYS = [
+  "traceparent",
+  "tracestate",
+  "baggage"
+];
+async function injectTraceFields() {
+  const api = await loadOtelApi2();
+  if (!api) return {};
+  const carrier = {};
+  try {
+    api.propagation.inject(api.context.active(), carrier, {
+      set(c, k, v) {
+        c[k] = v;
+      }
+    });
+  } catch (err) {
+    logger.debug("[redis-streams/trace-context] inject failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return carrier;
+}
+__name(injectTraceFields, "injectTraceFields");
+async function extractTraceContext(fields) {
+  const api = await loadOtelApi2();
+  if (!api) return void 0;
+  const carrier = {};
+  for (const key of TRACE_KEYS) {
+    const value = fields[key];
+    if (value) carrier[key] = value;
+  }
+  try {
+    return api.propagation.extract(api.context.active(), carrier, {
+      get(c, k) {
+        return c[k];
+      },
+      keys(c) {
+        return Object.keys(c);
+      }
+    });
+  } catch {
+    return void 0;
+  }
+}
+__name(extractTraceContext, "extractTraceContext");
+async function runWithConsumerSpan2(subject, fields, handler) {
+  const api = await loadOtelApi2();
+  if (!api) return handler();
+  try {
+    const parentCtx = await extractTraceContext(fields);
+    const tracer = api.trace.getTracer("@burdenoff/be-sdk/redis-streams");
+    return await new Promise((resolve, reject) => {
+      tracer.startActiveSpan(`redis-streams.consume ${subject}`, {
+        kind: 5,
+        attributes: {
+          "messaging.system": "redis",
+          "messaging.destination.name": subject
+        }
+      }, parentCtx, async (span) => {
+        try {
+          const result = await handler();
+          span.setStatus({
+            code: 1
+          });
+          span.end();
+          resolve(result);
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({
+            code: 2,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          span.end();
+          reject(err);
+        }
+      });
+    });
+  } catch {
+    return handler();
+  }
+}
+__name(runWithConsumerSpan2, "runWithConsumerSpan");
+
+// src/event-queue/implementations/redis-streams/RedisStreamsEventConsumer.ts
+var DEFAULT_BLOCK_MS = 5e3;
+var DEFAULT_BATCH = 10;
+var REGISTRY_REFRESH_MS = 1e4;
+var DEFAULT_ACK_WAIT_MS = 3e4;
+var DEFAULT_MAX_DELIVER = 3;
+var SWEEP_INTERVAL_MS = 15e3;
+var DELAYQ_INTERVAL_MS = 1e3;
+var RedisStreamsSubscription = class RedisStreamsSubscription2 {
+  static {
+    __name(this, "RedisStreamsSubscription");
+  }
+  subject;
+  unsubscribeFn;
+  id = randomUUID();
+  active = true;
+  receivedCount = 0;
+  processedCount = 0;
+  failedCount = 0;
+  lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  constructor(subject, unsubscribeFn) {
+    this.subject = subject;
+    this.unsubscribeFn = unsubscribeFn;
+  }
+  async unsubscribe() {
+    if (!this.active) return;
+    this.active = false;
+    await this.unsubscribeFn();
+  }
+  isActive() {
+    return this.active;
+  }
+  getStats() {
+    return {
+      messagesReceived: this.receivedCount,
+      messagesProcessed: this.processedCount,
+      messagesFailed: this.failedCount,
+      lastActivity: this.lastActivity
+    };
+  }
+  recordReceived() {
+    this.receivedCount++;
+    this.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  recordProcessed() {
+    this.processedCount++;
+    this.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  recordFailed() {
+    this.failedCount++;
+    this.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+var RedisStreamsEventConsumer = class {
+  static {
+    __name(this, "RedisStreamsEventConsumer");
+  }
+  connection;
+  subscriptions = [];
+  subscriptionLoops = /* @__PURE__ */ new Set();
+  keyPrefix;
+  consumerName;
+  group;
+  maxDeliver;
+  ackWaitMs;
+  maxConcurrent;
+  consumedCount = 0;
+  failedCount = 0;
+  lastActivity = null;
+  stopped = false;
+  sweepTimer = null;
+  delayqTimer = null;
+  knownStreams = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.connection = new RedisStreamsConnection({
+      type: "redis-streams",
+      url: config.url ?? process.env["REDIS_URL"] ?? "redis://localhost:6379",
+      user: config.user,
+      password: config.password,
+      name: config.name,
+      connectionTimeout: config.connectionTimeout
+    });
+    this.keyPrefix = config.keyPrefix ?? process.env["REDIS_STREAMS_KEY_PREFIX"] ?? "boff:events";
+    this.group = config.consumer || config.name || "default-consumer";
+    this.consumerName = `${this.group}:${hostname()}:${process.pid}`;
+    this.maxDeliver = config.maxDeliver ?? DEFAULT_MAX_DELIVER;
+    this.ackWaitMs = config.ackWait ? Math.max(1e3, Math.round(config.ackWait / 1e6)) : DEFAULT_ACK_WAIT_MS;
+    this.maxConcurrent = config.maxConcurrent ?? 5;
+  }
+  async connect() {
+    await this.connection.connect();
+    if (!this.sweepTimer) {
+      const t = setInterval(() => {
+        void this.sweepPending().catch((err) => {
+          logger.debug("[RedisStreamsEventConsumer] sweep error", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }, SWEEP_INTERVAL_MS);
+      t.unref?.();
+      this.sweepTimer = t;
+    }
+    if (!this.delayqTimer) {
+      const t = setInterval(() => {
+        void this.drainDelayQueues().catch(() => void 0);
+      }, DELAYQ_INTERVAL_MS);
+      t.unref?.();
+      this.delayqTimer = t;
+    }
+  }
+  async disconnect() {
+    this.stopped = true;
+    if (this.sweepTimer) clearInterval(this.sweepTimer);
+    if (this.delayqTimer) clearInterval(this.delayqTimer);
+    await this.unsubscribeAll();
+    await this.connection.disconnect();
+  }
+  isConnected() {
+    return this.connection.isConnected();
+  }
+  async healthCheck() {
+    try {
+      const t0 = Date.now();
+      const pong = await this.connection.ping();
+      return {
+        status: pong === "PONG" ? "healthy" : "degraded",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: this.isConnected(),
+        latencyMs: Date.now() - t0,
+        details: {
+          type: "redis-streams",
+          subscriptions: this.subscriptions.length
+        }
+      };
+    } catch (err) {
+      return {
+        status: "unhealthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: false,
+        details: {
+          type: "redis-streams"
+        },
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async getStatistics() {
+    return Promise.resolve({
+      messagesConsumed: this.consumedCount,
+      messagesFailed: this.failedCount,
+      messagesPublished: 0,
+      activeConsumers: this.subscriptions.length,
+      lastActivity: this.lastActivity?.toISOString() ?? null,
+      details: {
+        type: "redis-streams",
+        group: this.group
+      }
+    });
+  }
+  async ensureStream(_config) {
+    return Promise.resolve();
+  }
+  async ensureConsumer(_config) {
+    return Promise.resolve();
+  }
+  async subscribe(opts) {
+    await this.connect();
+    const sub = new RedisStreamsSubscription(opts.subject, async () => {
+      this.subscriptions = this.subscriptions.filter((s) => s !== sub);
+    });
+    this.subscriptions.push(sub);
+    const startId = this.resolveStartId(opts.options?.deliverPolicy);
+    const wildcard = isWildcard(opts.subject);
+    const handlerFn = opts.handler;
+    if (!wildcard) {
+      const stream = streamKey(opts.subject, {
+        prefix: this.keyPrefix
+      });
+      await this.ensureGroup(stream, startId);
+      this.knownStreams.set(stream, opts.subject);
+      this.spawnLoop(sub, stream, opts.subject, handlerFn);
+    } else {
+      const boundary = boundaryOf(opts.subject);
+      const refresh = /* @__PURE__ */ __name(async () => {
+        const client = this.connection.getClient();
+        const subjects = await client.smembers(registryKey(boundary));
+        for (const s of subjects) {
+          if (!matchSubject(opts.subject, s)) continue;
+          const stream = streamKey(s, {
+            prefix: this.keyPrefix
+          });
+          if (this.knownStreams.has(stream)) continue;
+          await this.ensureGroup(stream, startId);
+          this.knownStreams.set(stream, s);
+          this.spawnLoop(sub, stream, s, handlerFn);
+        }
+      }, "refresh");
+      await refresh();
+      const t = setInterval(() => {
+        if (this.stopped || !sub.isActive()) {
+          clearInterval(t);
+          return;
+        }
+        void refresh().catch(() => void 0);
+      }, REGISTRY_REFRESH_MS);
+      t.unref?.();
+    }
+    return sub;
+  }
+  async subscribeMultiple(subjects, handler, options) {
+    const out = [];
+    for (const subject of subjects) {
+      out.push(await this.subscribe({
+        subject,
+        handler,
+        options
+      }));
+    }
+    return out;
+  }
+  async pull(opts) {
+    await this.connect();
+    const stream = streamKey(opts.subject, {
+      prefix: this.keyPrefix
+    });
+    await this.ensureGroup(stream, "$");
+    const client = this.connection.getClient();
+    const raw = await client.xreadgroup("GROUP", this.group, this.consumerName, "COUNT", opts.batch ?? DEFAULT_BATCH, "BLOCK", opts.timeout ?? DEFAULT_BLOCK_MS, "STREAMS", stream, ">");
+    if (!raw) return [];
+    const out = [];
+    for (const [streamName, entries] of raw) {
+      for (const [id, rawFields] of entries) {
+        const parsed = this.parseEntry(streamName, id, rawFields);
+        out.push(this.toAcknowledgeable(streamName, id, parsed));
+      }
+    }
+    return out;
+  }
+  async unsubscribeAll() {
+    for (const sub of [
+      ...this.subscriptions
+    ]) {
+      await sub.unsubscribe();
+    }
+    this.subscriptions = [];
+    this.subscriptionLoops.clear();
+  }
+  getSubscriptions() {
+    return [
+      ...this.subscriptions
+    ];
+  }
+  async processDLQ(handler) {
+    await this.connect();
+    const client = this.connection.getClient();
+    const dlqGroup = `${this.group}-dlq`;
+    for (const [stream] of this.knownStreams) {
+      const dlq = dlqKey(stream);
+      try {
+        await client.xgroup("CREATE", dlq, dlqGroup, "0", "MKSTREAM");
+      } catch {
+      }
+      const res = await client.xreadgroup("GROUP", dlqGroup, this.consumerName, "COUNT", 50, "BLOCK", 100, "STREAMS", dlq, ">");
+      if (!res) continue;
+      for (const [, entries] of res) {
+        for (const [id, rawFields] of entries) {
+          const parsed = this.parseEntry(dlq, id, rawFields);
+          const evt = this.toAcknowledgeable(dlq, id, parsed, dlqGroup);
+          try {
+            await handler(evt);
+          } catch (err) {
+            logger.error("[RedisStreamsEventConsumer] DLQ handler error", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      }
+    }
+  }
+  async listSubjects(_stream) {
+    await this.connect();
+    const client = this.connection.getClient();
+    const seen = /* @__PURE__ */ new Set();
+    for (const subject of this.knownStreams.values()) {
+      const members = await client.smembers(registryKey(boundaryOf(subject)));
+      for (const m of members) seen.add(m);
+    }
+    return [
+      ...seen
+    ];
+  }
+  // ---- internals ----
+  resolveStartId(policy) {
+    switch (policy) {
+      case "all":
+        return "0";
+      case "new":
+        return "$";
+      case "last":
+        return "$";
+      default:
+        return "$";
+    }
+  }
+  async ensureGroup(stream, startId) {
+    const client = this.connection.getClient();
+    try {
+      await client.xgroup("CREATE", stream, this.group, startId, "MKSTREAM");
+      logger.debug("[RedisStreamsEventConsumer] group created", {
+        stream,
+        group: this.group,
+        startId
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("BUSYGROUP")) {
+        throw err;
+      }
+    }
+  }
+  spawnLoop(sub, stream, subject, handler) {
+    const loop = /* @__PURE__ */ __name(async () => {
+      const client = await this.connection.makeBlockingClient();
+      try {
+        while (!this.stopped && sub.isActive()) {
+          let raw = null;
+          try {
+            raw = await client.xreadgroup("GROUP", this.group, this.consumerName, "COUNT", this.maxConcurrent, "BLOCK", DEFAULT_BLOCK_MS, "STREAMS", stream, ">");
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("NOGROUP")) {
+              await this.ensureGroup(stream, "$");
+              continue;
+            }
+            logger.warn("[RedisStreamsEventConsumer] read error", {
+              stream,
+              error: msg
+            });
+            await new Promise((res) => setTimeout(res, 1e3));
+            continue;
+          }
+          if (!raw) continue;
+          for (const [, entries] of raw) {
+            for (const [id, rawFields] of entries) {
+              sub.recordReceived();
+              this.consumedCount++;
+              this.lastActivity = /* @__PURE__ */ new Date();
+              const parsed = this.parseEntry(stream, id, rawFields);
+              const evt = this.toAcknowledgeable(stream, id, parsed);
+              try {
+                await runWithConsumerSpan2(subject, parsed.fields, () => handler(evt));
+                sub.recordProcessed();
+              } catch (err) {
+                sub.recordFailed();
+                this.failedCount++;
+                logger.error("[RedisStreamsEventConsumer] handler error", {
+                  subject,
+                  id,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+                try {
+                  await evt.nak();
+                } catch {
+                }
+              }
+            }
+          }
+        }
+      } finally {
+        try {
+          client.disconnect();
+        } catch {
+        }
+      }
+    }, "loop");
+    void loop().catch((err) => {
+      logger.error("[RedisStreamsEventConsumer] loop crashed", {
+        stream,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+  parseEntry(stream, id, rawFields) {
+    const fields = {};
+    for (let i = 0; i + 1 < rawFields.length; i += 2) {
+      const key = rawFields[i];
+      const val = rawFields[i + 1];
+      if (key === void 0 || val === void 0) continue;
+      fields[key] = val;
+    }
+    let data;
+    try {
+      data = JSON.parse(fields["payload"] ?? "null");
+    } catch {
+      data = fields["payload"];
+    }
+    let metadata;
+    try {
+      metadata = JSON.parse(fields["metadata"] ?? "{}");
+    } catch {
+      metadata = {
+        correlationId: fields["correlation-id"] ?? ""
+      };
+    }
+    if (!metadata.correlationId) metadata.correlationId = fields["correlation-id"] ?? "";
+    return {
+      id,
+      stream,
+      subject: fields["subject"] ?? "",
+      data,
+      metadata,
+      timestamp: fields["timestamp"] ?? (/* @__PURE__ */ new Date()).toISOString(),
+      fields,
+      deliveryCount: 1
+    };
+  }
+  toAcknowledgeable(stream, id, parsed, group = this.group) {
+    const connection = this.connection;
+    let acked = false;
+    return {
+      id,
+      subject: parsed.subject,
+      data: parsed.data,
+      metadata: parsed.metadata,
+      timestamp: parsed.timestamp,
+      async ack() {
+        if (acked) return;
+        acked = true;
+        const client = connection.getClient();
+        await client.xack(stream, group, id);
+        await client.xdel(stream, id).catch(() => void 0);
+      },
+      async nak(delay = 0) {
+        if (acked) return;
+        acked = true;
+        const client = connection.getClient();
+        if (delay > 0) {
+          const score = Date.now() + delay;
+          const payload = JSON.stringify(parsed.fields);
+          await client.zadd(delayQueueKey(stream), score, `${id}|${payload}`);
+          await client.xack(stream, group, id);
+          await client.xdel(stream, id).catch(() => void 0);
+        }
+      },
+      async term() {
+        if (acked) return;
+        acked = true;
+        const client = connection.getClient();
+        const dlq = dlqKey(stream);
+        const flat = [];
+        for (const [k, v] of Object.entries(parsed.fields)) flat.push(k, v);
+        await client.xadd(dlq, "MAXLEN", "~", 1e4, "*", ...flat);
+        await client.xack(stream, group, id);
+        await client.xdel(stream, id).catch(() => void 0);
+      },
+      isRedelivered() {
+        return parsed.deliveryCount > 1;
+      },
+      getDeliveryAttempt() {
+        return parsed.deliveryCount;
+      }
+    };
+  }
+  async sweepPending() {
+    if (this.stopped || this.knownStreams.size === 0) return;
+    const client = this.connection.getClient();
+    for (const [stream] of this.knownStreams) {
+      try {
+        const claimed = await client.xautoclaim(stream, this.group, this.consumerName, this.ackWaitMs, "0", "COUNT", 50);
+        if (!claimed) continue;
+        const entries = claimed[1] ?? [];
+        for (const [id, rawFields] of entries) {
+          const pending = await client.xpending(stream, this.group, "IDLE", 0, "-", "+", 1, this.consumerName);
+          const deliveryCount = Array.isArray(pending) && pending[0] ? pending[0][3] : 1;
+          if (deliveryCount > this.maxDeliver) {
+            const flat = [];
+            for (let i = 0; i + 1 < rawFields.length; i += 2) {
+              flat.push(rawFields[i], rawFields[i + 1]);
+            }
+            flat.push("dlq-reason", "max-deliver-exceeded");
+            flat.push("dlq-deliveries", String(deliveryCount));
+            await client.xadd(dlqKey(stream), "MAXLEN", "~", 1e4, "*", ...flat);
+            await client.xack(stream, this.group, id);
+            await client.xdel(stream, id).catch(() => void 0);
+            logger.warn("[RedisStreamsEventConsumer] message moved to DLQ", {
+              stream,
+              id,
+              deliveryCount
+            });
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("NOGROUP")) continue;
+        logger.debug("[RedisStreamsEventConsumer] sweep iteration error", {
+          stream,
+          error: msg
+        });
+      }
+    }
+  }
+  async drainDelayQueues() {
+    if (this.stopped || this.knownStreams.size === 0) return;
+    const client = this.connection.getClient();
+    for (const [stream] of this.knownStreams) {
+      const lockKey = delayLockKey(stream);
+      const got = await client.set(lockKey, this.consumerName, "NX", "EX", 30).catch(() => null);
+      if (got !== "OK") continue;
+      try {
+        const due = await client.zrangebyscore(delayQueueKey(stream), 0, Date.now(), "LIMIT", 0, 50);
+        for (const member of due) {
+          const split = member.indexOf("|");
+          if (split < 0) continue;
+          const payload = member.slice(split + 1);
+          let fields = {};
+          try {
+            fields = JSON.parse(payload);
+          } catch {
+            continue;
+          }
+          const flat = [];
+          for (const [k, v] of Object.entries(fields)) flat.push(k, v);
+          await client.xadd(stream, "MAXLEN", "~", 1e5, "*", ...flat);
+          await client.zrem(delayQueueKey(stream), member);
+        }
+      } finally {
+        await client.del(lockKey).catch(() => void 0);
+      }
+    }
+  }
+};
+var RedisStreamsEventPublisher = class {
+  static {
+    __name(this, "RedisStreamsEventPublisher");
+  }
+  config;
+  connection;
+  publishCount = 0;
+  lastPublishTime = null;
+  maxLen;
+  dedupTtl;
+  keyPrefix;
+  constructor(config) {
+    this.config = config;
+    this.connection = new RedisStreamsConnection(config);
+    this.maxLen = config.maxLen ?? parseInt(process.env["REDIS_STREAMS_MAXLEN"] ?? "100000", 10);
+    this.dedupTtl = config.dedupTtlSeconds ?? parseInt(process.env["REDIS_STREAMS_DEDUP_TTL"] ?? "120", 10);
+    this.keyPrefix = config.keyPrefix ?? process.env["REDIS_STREAMS_KEY_PREFIX"] ?? "boff:events";
+  }
+  async connect() {
+    await this.connection.connect();
+  }
+  async disconnect() {
+    await this.connection.disconnect();
+  }
+  isConnected() {
+    return this.connection.isConnected();
+  }
+  async healthCheck() {
+    try {
+      const t0 = Date.now();
+      const pong = await this.connection.ping();
+      return {
+        status: pong === "PONG" ? "healthy" : "degraded",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: this.isConnected(),
+        latencyMs: Date.now() - t0,
+        details: {
+          type: "redis-streams",
+          url: this.config.url
+        }
+      };
+    } catch (err) {
+      return {
+        status: "unhealthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: false,
+        details: {
+          type: "redis-streams"
+        },
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async getStatistics() {
+    return {
+      messagesPublished: this.publishCount,
+      messagesConsumed: 0,
+      messagesFailed: 0,
+      activePublishers: 1,
+      activeConsumers: 0,
+      lastActivity: this.lastPublishTime?.toISOString() ?? null,
+      details: {
+        type: "redis-streams"
+      }
+    };
+  }
+  async ensureStream(_config) {
+    return Promise.resolve();
+  }
+  async publish(options) {
+    return this.publishInternal(options);
+  }
+  async publishInternal(opts) {
+    await this.connect();
+    const client = this.connection.getClient();
+    const stream = streamKey(opts.subject, {
+      prefix: this.keyPrefix
+    });
+    const msgId = opts.options?.messageId ?? randomUUID();
+    const correlationId = opts.metadata?.correlationId ?? randomUUID();
+    const enableDedup = this.config.enableDeduplication === true || opts.options?.messageId !== void 0;
+    if (enableDedup) {
+      const ok = await client.set(dedupKey(stream, msgId), "1", "NX", "EX", this.dedupTtl);
+      if (ok !== "OK") {
+        logger.debug("[RedisStreamsEventPublisher] dedup hit; skipping publish", {
+          subject: opts.subject,
+          msgId
+        });
+        return msgId;
+      }
+    }
+    const trace = await injectTraceFields();
+    const fields = {
+      "msg-id": msgId,
+      subject: opts.subject,
+      "correlation-id": correlationId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      priority: opts.options?.priority ?? this.config.defaultPriority ?? "normal",
+      source: opts.metadata?.source ?? this.config.name ?? "unknown",
+      payload: JSON.stringify(opts.data ?? null),
+      metadata: JSON.stringify(opts.metadata ?? {}),
+      ...trace
+    };
+    if (opts.metadata?.userId) fields["user-id"] = String(opts.metadata.userId);
+    if (opts.metadata?.workspaceId) fields["workspace-id"] = String(opts.metadata.workspaceId);
+    if (opts.metadata?.tenantId) fields["tenant-id"] = String(opts.metadata.tenantId);
+    const flat = [];
+    for (const [k, v] of Object.entries(fields)) {
+      flat.push(k, v);
+    }
+    const id = await client.xadd(stream, "MAXLEN", "~", this.maxLen, "*", ...flat);
+    void client.sadd(registryKey(boundaryOf(opts.subject)), opts.subject).catch(() => void 0);
+    this.publishCount++;
+    this.lastPublishTime = /* @__PURE__ */ new Date();
+    logger.debug("[RedisStreamsEventPublisher] published", {
+      subject: opts.subject,
+      stream,
+      id
+    });
+    return id;
+  }
+  async publishBatch(events) {
+    const out = [];
+    for (const e of events) {
+      out.push(await this.publishInternal(e));
+    }
+    return out;
+  }
+  /**
+  * Emulated request/response: writer XADDs onto its own subject, then
+  * blocks on a one-shot reply stream keyed by correlationId.
+  */
+  async publishWithAck(opts) {
+    await this.connect();
+    const client = this.connection.getClient();
+    const correlationId = opts.metadata?.correlationId ?? randomUUID();
+    const reply = replyKey(correlationId);
+    await this.publishInternal({
+      subject: opts.subject,
+      data: opts.data,
+      metadata: {
+        ...opts.metadata,
+        correlationId,
+        replyTo: reply
+      }
+    });
+    const timeoutMs = opts.timeout ?? 5e3;
+    const t0 = Date.now();
+    while (Date.now() - t0 < timeoutMs) {
+      const entries = await client.xrange(reply, "-", "+");
+      if (Array.isArray(entries) && entries.length > 0) {
+        const last = entries[entries.length - 1];
+        if (!last) break;
+        const rawFields = last[1];
+        const payloadIdx = rawFields.indexOf("payload");
+        const payload = payloadIdx >= 0 ? rawFields[payloadIdx + 1] : "{}";
+        await client.del(reply);
+        return JSON.parse(payload ?? "{}");
+      }
+      await new Promise((res) => setTimeout(res, 50));
+    }
+    await client.del(reply).catch(() => void 0);
+    throw new Error(`[RedisStreamsEventPublisher] publishWithAck timed out for subject=${opts.subject}`);
+  }
+  /** Internal helper used by the consumer's reply path. */
+  async sendReply(correlationId, data) {
+    await this.connect();
+    const client = this.connection.getClient();
+    const key = replyKey(correlationId);
+    await client.xadd(key, "*", "payload", JSON.stringify(data ?? null));
+    await client.expire(key, 60);
+  }
+};
+
+// src/event-queue/factory/EventQueueFactory.ts
+function resolveQueueType() {
+  const raw = (process.env["EVENT_QUEUE_TYPE"] ?? process.env["QUEUE_TYPE"] ?? "").toLowerCase();
+  if (raw === "redis-streams" || raw === "redis" || raw === "streams") return QueueType.REDIS_STREAMS;
+  if (raw === "nats") return QueueType.NATS;
+  if (!process.env["NATS_URL"] && !process.env["NATS_SERVERS"] && process.env["REDIS_URL"]) {
+    return QueueType.REDIS_STREAMS;
+  }
+  return QueueType.NATS;
+}
+__name(resolveQueueType, "resolveQueueType");
+var EventQueueFactory = class _EventQueueFactory {
+  static {
+    __name(this, "EventQueueFactory");
+  }
+  /**
+  * Create an event publisher based on configuration
+  */
+  static createPublisher(config) {
+    logger.info("[EventQueueFactory] Creating event publisher", {
+      type: config.type,
+      url: config.url
+    });
+    if (config.type === QueueType.NATS) {
+      return new NatsEventPublisher(config);
+    }
+    if (config.type === QueueType.REDIS_STREAMS) {
+      return new RedisStreamsEventPublisher(config);
+    }
+    throw new Error(`Unsupported queue type: ${config.type}`);
+  }
+  /**
+  * Create an event consumer based on configuration
+  */
+  static createConsumer(config) {
+    logger.info("[EventQueueFactory] Creating event consumer", {
+      type: config.type,
+      url: config.url,
+      stream: config.stream,
+      consumer: config.consumer
+    });
+    if (config.type === QueueType.NATS) {
+      return new NatsEventConsumer(config);
+    }
+    if (config.type === QueueType.REDIS_STREAMS) {
+      return new RedisStreamsEventConsumer(config);
+    }
+    throw new Error(`Unsupported queue type: ${config.type}`);
+  }
+  /**
+  * Create a publisher from environment variables
+  */
+  static createPublisherFromEnv() {
+    const type = resolveQueueType();
+    if (type === QueueType.REDIS_STREAMS) {
+      return _EventQueueFactory.createPublisher({
+        type,
+        url: process.env["REDIS_URL"] ?? "redis://localhost:6379",
+        password: process.env["REDIS_PASSWORD"],
+        name: process.env["QUEUE_CLIENT_NAME"] ?? process.env["SERVICE_NAME"] ?? "be-sdk-publisher",
+        enableDeduplication: process.env["QUEUE_ENABLE_DEDUPLICATION"] === "true",
+        defaultPriority: process.env["QUEUE_DEFAULT_PRIORITY"] ?? "normal"
+      });
+    }
+    const config = {
+      type,
+      url: process.env["NATS_URL"] || "nats://localhost:4222",
+      user: process.env["NATS_USER"],
+      password: process.env["NATS_PASSWORD"],
+      token: process.env["NATS_TOKEN"],
+      creds: process.env["NATS_CREDS"],
+      credsFile: process.env["NATS_CREDS_FILE"],
+      name: process.env["QUEUE_CLIENT_NAME"] || "workspaces-backend-publisher",
+      maxReconnectAttempts: process.env["NATS_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["NATS_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["NATS_RECONNECT_TIME_WAIT"] ? parseInt(process.env["NATS_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      enableDeduplication: process.env["QUEUE_ENABLE_DEDUPLICATION"] === "true",
+      defaultPriority: process.env["QUEUE_DEFAULT_PRIORITY"] || "normal",
+      defaultTTL: process.env["QUEUE_DEFAULT_TTL"] ? parseInt(process.env["QUEUE_DEFAULT_TTL"], 10) : void 0
+    };
+    return _EventQueueFactory.createPublisher(config);
+  }
+  /**
+  * Create a consumer from environment variables
+  */
+  static createConsumerFromEnv(stream, consumer) {
+    const type = resolveQueueType();
+    if (type === QueueType.REDIS_STREAMS) {
+      return _EventQueueFactory.createConsumer({
+        type,
+        url: process.env["REDIS_URL"] ?? "redis://localhost:6379",
+        password: process.env["REDIS_PASSWORD"],
+        name: process.env["QUEUE_CLIENT_NAME"] ?? process.env["SERVICE_NAME"] ?? consumer,
+        stream,
+        consumer,
+        maxConcurrent: process.env["QUEUE_MAX_CONCURRENT"] ? parseInt(process.env["QUEUE_MAX_CONCURRENT"], 10) : 5,
+        maxDeliver: process.env["QUEUE_MAX_DELIVER"] ? parseInt(process.env["QUEUE_MAX_DELIVER"], 10) : 3,
+        ackWait: process.env["QUEUE_ACK_WAIT"] ? parseInt(process.env["QUEUE_ACK_WAIT"], 10) * 1e9 : 3e10
+      });
+    }
+    const config = {
+      type,
+      url: process.env["NATS_URL"] || "nats://localhost:4222",
+      user: process.env["NATS_USER"],
+      password: process.env["NATS_PASSWORD"],
+      token: process.env["NATS_TOKEN"],
+      creds: process.env["NATS_CREDS"],
+      credsFile: process.env["NATS_CREDS_FILE"],
+      name: process.env["QUEUE_CLIENT_NAME"] || "workspaces-workers-consumer",
+      maxReconnectAttempts: process.env["NATS_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["NATS_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["NATS_RECONNECT_TIME_WAIT"] ? parseInt(process.env["NATS_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      stream,
+      consumer,
+      maxConcurrent: process.env["QUEUE_MAX_CONCURRENT"] ? parseInt(process.env["QUEUE_MAX_CONCURRENT"], 10) : 5,
+      maxDeliver: process.env["QUEUE_MAX_DELIVER"] ? parseInt(process.env["QUEUE_MAX_DELIVER"], 10) : 3,
+      ackWait: process.env["QUEUE_ACK_WAIT"] ? parseInt(process.env["QUEUE_ACK_WAIT"], 10) * 1e9 : 3e10
+    };
+    return _EventQueueFactory.createConsumer(config);
+  }
+  // ========================================================================
+  // Layer-Aware Factory Methods
+  // ========================================================================
+  /**
+  * Create a publisher for a specific layer
+  *
+  * @param layer - Service layer ('wspace' or 'global')
+  * @param serviceName - Service name for identification
+  * @returns Publisher configured for the layer
+  *
+  * @example
+  * ```typescript
+  * const publisher = EventQueueFactory.createPublisherForLayer('wspace', 'wspace-tags-svc');
+  * await publisher.connect();
+  * await publisher.publish({ subject: 'wspace.tags.created', data: { id: '123' } });
+  * ```
+  */
+  static createPublisherForLayer(layer, serviceName) {
+    const envPrefix = layer.toUpperCase();
+    const defaults = DEFAULT_LAYER_RESOURCES[layer];
+    const type = resolveQueueType();
+    if (type === QueueType.REDIS_STREAMS) {
+      return _EventQueueFactory.createPublisher({
+        type,
+        url: process.env["REDIS_URL"] ?? "redis://localhost:6379",
+        password: process.env["REDIS_PASSWORD"],
+        name: serviceName,
+        enableDeduplication: process.env["QUEUE_ENABLE_DEDUPLICATION"] === "true",
+        defaultPriority: process.env["QUEUE_DEFAULT_PRIORITY"] || "normal"
+      });
+    }
+    const config = {
+      type,
+      url: process.env[`${envPrefix}_NATS_URL`] || process.env["NATS_URL"] || defaults.natsUrl,
+      user: process.env["NATS_USER"],
+      password: process.env["NATS_PASSWORD"],
+      token: process.env["NATS_TOKEN"],
+      creds: process.env["NATS_CREDS"],
+      credsFile: process.env["NATS_CREDS_FILE"],
+      name: serviceName,
+      maxReconnectAttempts: process.env["NATS_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["NATS_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["NATS_RECONNECT_TIME_WAIT"] ? parseInt(process.env["NATS_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      enableDeduplication: process.env["QUEUE_ENABLE_DEDUPLICATION"] === "true",
+      defaultPriority: process.env["QUEUE_DEFAULT_PRIORITY"] || "normal",
+      defaultTTL: process.env["QUEUE_DEFAULT_TTL"] ? parseInt(process.env["QUEUE_DEFAULT_TTL"], 10) : void 0
+    };
+    logger.info("[EventQueueFactory] Creating layer publisher", {
+      layer,
+      serviceName,
+      url: config.url
+    });
+    return _EventQueueFactory.createPublisher(config);
+  }
+  /**
+  * Create a consumer for a specific layer
+  *
+  * @param layer - Service layer ('wspace' or 'global')
+  * @param serviceName - Service name for identification
+  * @param stream - NATS stream name
+  * @param consumer - Consumer name
+  * @returns Consumer configured for the layer
+  *
+  * @example
+  * ```typescript
+  * const consumer = EventQueueFactory.createConsumerForLayer(
+  *   'wspace', 'wspace-tags-svc', 'WSPACE_EVENTS', 'tags-consumer'
+  * );
+  * await consumer.connect();
+  * await consumer.consume(async (msg) => { console.log(msg); });
+  * ```
+  */
+  static createConsumerForLayer(layer, serviceName, stream, consumer) {
+    const envPrefix = layer.toUpperCase();
+    const defaults = DEFAULT_LAYER_RESOURCES[layer];
+    const type = resolveQueueType();
+    if (type === QueueType.REDIS_STREAMS) {
+      return _EventQueueFactory.createConsumer({
+        type,
+        url: process.env["REDIS_URL"] ?? "redis://localhost:6379",
+        password: process.env["REDIS_PASSWORD"],
+        name: serviceName,
+        stream,
+        consumer,
+        maxConcurrent: process.env["QUEUE_MAX_CONCURRENT"] ? parseInt(process.env["QUEUE_MAX_CONCURRENT"], 10) : 5,
+        maxDeliver: process.env["QUEUE_MAX_DELIVER"] ? parseInt(process.env["QUEUE_MAX_DELIVER"], 10) : 3,
+        ackWait: process.env["QUEUE_ACK_WAIT"] ? parseInt(process.env["QUEUE_ACK_WAIT"], 10) * 1e9 : 3e10
+      });
+    }
+    const config = {
+      type,
+      url: process.env[`${envPrefix}_NATS_URL`] || process.env["NATS_URL"] || defaults.natsUrl,
+      user: process.env["NATS_USER"],
+      password: process.env["NATS_PASSWORD"],
+      token: process.env["NATS_TOKEN"],
+      creds: process.env["NATS_CREDS"],
+      credsFile: process.env["NATS_CREDS_FILE"],
+      name: serviceName,
+      maxReconnectAttempts: process.env["NATS_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["NATS_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["NATS_RECONNECT_TIME_WAIT"] ? parseInt(process.env["NATS_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      stream,
+      consumer,
+      maxConcurrent: process.env["QUEUE_MAX_CONCURRENT"] ? parseInt(process.env["QUEUE_MAX_CONCURRENT"], 10) : 5,
+      maxDeliver: process.env["QUEUE_MAX_DELIVER"] ? parseInt(process.env["QUEUE_MAX_DELIVER"], 10) : 3,
+      ackWait: process.env["QUEUE_ACK_WAIT"] ? parseInt(process.env["QUEUE_ACK_WAIT"], 10) * 1e9 : 3e10
+    };
+    logger.info("[EventQueueFactory] Creating layer consumer", {
+      layer,
+      serviceName,
+      stream,
+      consumer,
+      url: config.url
+    });
+    return _EventQueueFactory.createConsumer(config);
+  }
+};
+
+export { EventQueueFactory, NatsEventConsumer, NatsEventPublisher, RedisStreamsConnection, RedisStreamsEventConsumer, RedisStreamsEventPublisher, dlqKey, streamKey };
+//# sourceMappingURL=chunk-BQRXB4CW.js.map
+//# sourceMappingURL=chunk-BQRXB4CW.js.map