@burdenoff/be-sdk 2026.514.2 → 2026.516.2

package/dist/chunk-LRGXT37B.js

@@ -1,1966 +0,0 @@
-import { QueueType } from './chunk-UVYDP6P6.js';
-import { NatsConnectionManager, RedisStreamsConnection, isWildcard, streamKey, boundaryOf, dlqKey, registryKey, delayQueueKey, delayLockKey, dedupKey, replyKey, matchSubject } from './chunk-N52W3RQA.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/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, RedisStreamsEventConsumer, RedisStreamsEventPublisher };
-//# sourceMappingURL=chunk-LRGXT37B.js.map
-//# sourceMappingURL=chunk-LRGXT37B.js.map