Please address the comments from this code review:
## Overall Comments
- Consider guarding in processMessage to log or throw if mount wasn’t called first, so you don’t emit into an uninitialized Subject.
- To prevent unbounded queue growth under load, think about adding a concurrency/backpressure strategy (e.g. mergeMap with a concurrency limit) instead of using an unbounded Subject with concatMap.
- Once BaileysMessageProcessor is fully in place, remove the commented-out direct call to messageHandle to keep the event loop code clean.

## Individual Comments

### Comment 1
<location> `src/api/integrations/channel/whatsapp/baileysMessage.processor.ts:44` </location>
<code_context>
+
+  processMessage(payload: MessageUpsertPayload, settings: any) {
+    const { messages, type, requestId } = payload;
+    this.messageSubject.next({ messages, type, requestId, settings });
+  }
+
</code_context>

<issue_to_address>
No backpressure or queue size limit is enforced on messageSubject.

This could cause memory issues if many messages are processed rapidly. Consider implementing a queue size limit or backpressure mechanism.

Suggested implementation:

```typescript
  // Limit the queue to 100 messages (adjust as needed)
  protected readonly MESSAGE_QUEUE_LIMIT = 100;
  protected messageQueue: Array<{ messages: any; type: any; requestId: any; settings: any }> = [];
  protected messageSubject = new Subject<{

```

```typescript
  processMessage(payload: MessageUpsertPayload, settings: any) {
    const { messages, type, requestId } = payload;
    if (this.messageQueue.length >= this.MESSAGE_QUEUE_LIMIT) {
      // Drop the oldest message to make room for the new one (or log/drop new, as preferred)
      this.processorLogs.warn(
        `Message queue full (${this.MESSAGE_QUEUE_LIMIT}). Dropping oldest message.`
      );
      this.messageQueue.shift();
    }
    const message = { messages, type, requestId, settings };
    this.messageQueue.push(message);
    this.messageSubject.next(message);
  }

```
</issue_to_address>

### Comment 2
<location> `src/api/integrations/channel/whatsapp/baileysMessage.processor.ts:48` </location>
<code_context>
+  }
+
+  onDestroy() {
+    this.subscription?.unsubscribe();
+    this.messageSubject.complete();
+  }
+}
</code_context>

<issue_to_address>
Unsubscribing and completing the Subject may cause issues if processMessage is called after onDestroy.

Calling processMessage after onDestroy will throw an error due to the completed Subject. Please guard processMessage or document its usage constraints.
</issue_to_address>