@whanext/core 0.19.16 → 0.19.19

package/dist/index.js

@@ -379,15 +379,37 @@ function isCommandGroup(definition) {
 }
 
 // src/commands/concurrency.ts
+var DEFAULT_MAX_QUEUE = 10;
+var DEFAULT_QUEUE_TIMEOUT_MS = 6e4;
 var CommandConcurrencyController = class {
   #states = /* @__PURE__ */ new Map();
-  async run(key, options, execute) {
+  #onEvent;
+  #queueTimeouts = 0;
+  #queueRejected = 0;
+  constructor(onEvent) {
+    this.#onEvent = onEvent;
+  }
+  health() {
+    let running = 0;
+    let queued = 0;
+    for (const state of this.#states.values()) {
+      running += state.active;
+      queued += state.queue.length;
+    }
+    return {
+      running,
+      queued,
+      queueTimeouts: this.#queueTimeouts,
+      queueRejected: this.#queueRejected
+    };
+  }
+  async run(key, options, execute, context) {
     const strategy = options?.strategy ?? "parallel";
     if (strategy === "parallel") {
       await execute(new AbortController().signal);
       return;
     }
-    const max = Math.max(1, options?.max ?? 1);
+    const max = normalizePositiveInteger(options?.max, 1);
     const state = this.#states.get(key) ?? { active: 0, queue: [], controllers: /* @__PURE__ */ new Set() };
     this.#states.set(key, state);
     if (strategy === "replace") {
@@ -399,7 +421,7 @@ var CommandConcurrencyController = class {
         recoverable: true
       });
     } else if (strategy === "queue" && state.active >= max) {
-      await new Promise((resolve4) => state.queue.push(resolve4));
+      await this.#waitForQueue(key, state, options ?? {}, context);
     }
     const controller = new AbortController();
     state.controllers.add(controller);
@@ -409,13 +431,97 @@ var CommandConcurrencyController = class {
     } finally {
       state.controllers.delete(controller);
       state.active -= 1;
-      state.queue.shift()?.();
+      this.#releaseNext(state);
       if (state.active === 0 && state.queue.length === 0) {
         this.#states.delete(key);
       }
     }
   }
+  async #waitForQueue(key, state, options, context) {
+    const maxQueue = normalizeQueueLimit(options.maxQueue);
+    if (state.queue.length >= maxQueue) {
+      this.#queueRejected += 1;
+      if (context && Number.isFinite(maxQueue)) {
+        this.#onEvent?.({
+          type: "commandQueueFull",
+          payload: {
+            ...context,
+            key,
+            maxQueue,
+            queued: state.queue.length
+          }
+        });
+      }
+      throw new WhaNextError("COMMAND_QUEUE_FULL", "This command queue is full.", {
+        context: { key, maxQueue, queued: state.queue.length },
+        recoverable: true
+      });
+    }
+    const queueTimeoutMs = normalizeQueueTimeout(options.queueTimeoutMs);
+    await new Promise((resolve4, reject) => {
+      const entry = {
+        resolve: resolve4,
+        reject,
+        enqueuedAt: Date.now(),
+        settled: false
+      };
+      if (queueTimeoutMs > 0) {
+        entry.timer = setTimeout(() => {
+          if (entry.settled) return;
+          entry.settled = true;
+          const index = state.queue.indexOf(entry);
+          if (index >= 0) state.queue.splice(index, 1);
+          const queuedForMs = Date.now() - entry.enqueuedAt;
+          this.#queueTimeouts += 1;
+          if (context) {
+            this.#onEvent?.({
+              type: "commandQueueTimeout",
+              payload: {
+                ...context,
+                key,
+                queuedForMs,
+                queueTimeoutMs,
+                queued: state.queue.length
+              }
+            });
+          }
+          reject(new WhaNextError(
+            "COMMAND_QUEUE_TIMEOUT",
+            "This command waited too long in the execution queue.",
+            {
+              context: { key, queuedForMs, queueTimeoutMs },
+              recoverable: true
+            }
+          ));
+        }, queueTimeoutMs);
+      }
+      state.queue.push(entry);
+    });
+  }
+  #releaseNext(state) {
+    while (state.queue.length > 0) {
+      const next = state.queue.shift();
+      if (!next || next.settled) continue;
+      next.settled = true;
+      if (next.timer) clearTimeout(next.timer);
+      next.resolve();
+      return;
+    }
+  }
 };
+function normalizePositiveInteger(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function normalizeQueueLimit(value) {
+  if (value === 0) return Number.POSITIVE_INFINITY;
+  return normalizePositiveInteger(value, DEFAULT_MAX_QUEUE);
+}
+function normalizeQueueTimeout(value) {
+  if (value === 0) return 0;
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_QUEUE_TIMEOUT_MS;
+  return Math.max(1, Math.floor(value));
+}
 
 // src/commands/context.ts
 var CommandContextImplementation = class {
@@ -739,6 +845,24 @@ function invalid(name, received, expected) {
   });
 }
 
+// src/provider/event-emitter.ts
+var TypedEventEmitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    const listeners = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.#listeners.set(event, listeners);
+    return () => listeners.delete(listener);
+  }
+  async emit(event, payload) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners) {
+      return;
+    }
+    await Promise.all([...listeners].map((listener) => listener(payload)));
+  }
+};
+
 // src/services/user-service.ts
 var UserService = class {
   #group;
@@ -781,11 +905,19 @@ var CommandRouter = class {
   #globalMiddleware = [];
   #errorHandlers = [];
   #cooldowns = /* @__PURE__ */ new Map();
-  #concurrency = new CommandConcurrencyController();
+  #events = new TypedEventEmitter();
+  #concurrency;
   #beforeExecute;
   #afterExecute;
   #cooldownOperations = 0;
   constructor(servicesOrGroup, options = {}) {
+    this.#concurrency = new CommandConcurrencyController((event) => {
+      if (event.type === "commandQueueTimeout") {
+        void this.#events.emit("commandQueueTimeout", event.payload).catch(() => void 0);
+      } else {
+        void this.#events.emit("commandQueueFull", event.payload).catch(() => void 0);
+      }
+    });
     this.#services = isRuntimeServices(servicesOrGroup) ? servicesOrGroup : createLegacyServices(servicesOrGroup);
     this.setPrefixes(options.prefix ?? "!");
     this.#legacyOnError = options.onError;
@@ -809,6 +941,12 @@ var CommandRouter = class {
   get size() {
     return this.catalog({ includeHidden: true }).length;
   }
+  health() {
+    return this.#concurrency.health();
+  }
+  on(event, listener) {
+    return this.#events.on(event, listener);
+  }
   command(definition) {
     this.#validateTree(definition, []);
     for (const name of commandNames(definition)) {
@@ -970,6 +1108,12 @@ _Nenhum comando dispon\xEDvel._`;
           await this.#authorize(resolved.layers, context);
           this.#consumeCooldown(resolved, context);
           await this.#execute(resolved, context);
+        },
+        {
+          command: resolved.registered.path.join(" "),
+          messageId: message.id,
+          chatId: message.chatId,
+          userId: message.sender.id
         }
       );
       return true;
@@ -1797,24 +1941,6 @@ var SqliteMuteStore = class {
   }
 };
 
-// src/provider/event-emitter.ts
-var TypedEventEmitter = class {
-  #listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    const listeners = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
-    listeners.add(listener);
-    this.#listeners.set(event, listeners);
-    return () => listeners.delete(listener);
-  }
-  async emit(event, payload) {
-    const listeners = this.#listeners.get(event);
-    if (!listeners) {
-      return;
-    }
-    await Promise.all([...listeners].map((listener) => listener(payload)));
-  }
-};
-
 // src/services/account-service.ts
 var AccountService = class {
   id;
@@ -2165,6 +2291,7 @@ var WhaNextApp = class {
   #router;
   #startedAt = Date.now();
   #state = "idle";
+  #lastStability = "offline";
   constructor(provider, options = {}, logger = new Logger(options.logger)) {
     this.#provider = provider;
     this.#phone = options.phone;
@@ -2209,14 +2336,61 @@ var WhaNextApp = class {
     return this.#state === "connected";
   }
   health() {
+    const provider = this.#provider.health?.();
+    const connection = provider?.connection ?? {
+      state: this.#state,
+      uptimeMs: this.isReady ? Date.now() - this.#startedAt : 0,
+      reconnects: 0,
+      reconnectAttempt: 0
+    };
+    const messaging = provider?.messaging ?? {
+      sent: 0,
+      received: 0,
+      failed: 0,
+      decryptedPayloads: 0,
+      unavailable: 0,
+      resendRequested: 0,
+      recovered: 0,
+      recoveryFailed: 0,
+      unavailableUnrecoverable: 0,
+      decodeFailures: 0,
+      unhandledStanzas: 0,
+      ignoredOffline: 0,
+      duplicates: 0,
+      normalizationFailures: 0
+    };
+    const crypto = provider?.crypto ?? {
+      backend: "unknown",
+      acceleration: false,
+      decryptFailures: 0,
+      addonDecryptFailures: 0,
+      senderKeyMismatches: 0
+    };
+    const groups = provider?.groups ?? {
+      phashMismatches: 0,
+      metadataRecoveries: 0,
+      metadataRecoveryFailures: 0
+    };
+    const timeouts = provider?.timeouts ?? {
+      connectTimeoutMs: 0,
+      nodeQueryTimeoutMs: 0
+    };
+    const stability = provider?.stability ?? this.#fallbackStability();
     return {
       status: this.#healthStatus(),
+      stability,
       state: this.#state,
       ready: this.isReady,
       uptimeMs: Date.now() - this.#startedAt,
       timestamp: /* @__PURE__ */ new Date(),
       muteEnabled: this.mute.enabled,
-      logLevel: this.logger.level
+      logLevel: this.logger.level,
+      connection,
+      messaging,
+      crypto,
+      groups,
+      commands: this.#router.health(),
+      timeouts
     };
   }
   router() {
@@ -2286,9 +2460,42 @@ var WhaNextApp = class {
   }
   #bind() {
     this.#provider.on("connection", async (update) => {
+      const previousState = this.#state;
       this.#state = update.state;
       this.#logConnection(update);
       await this.#events.emit("connection", update);
+      if (update.state === "connected" && previousState === "reconnecting") {
+        const providerHealth = this.#provider.health?.();
+        await this.#events.emit("connectionRecovered", {
+          recoveredAt: /* @__PURE__ */ new Date(),
+          reconnects: providerHealth?.connection.reconnects ?? 1
+        });
+      }
+      await this.#refreshHealthState();
+    });
+    this.#provider.on("stability", async (event) => {
+      if (event.type === "groupMetadataRecovered") {
+        await this.#events.emit("groupMetadataRecovered", event.payload);
+      } else if (event.type === "cryptoDegraded") {
+        await this.#events.emit("cryptoDegraded", event.payload);
+      } else if (event.type === "messageUnavailable") {
+        await this.#events.emit("messageUnavailable", event.payload);
+      } else if (event.type === "messageRecovered") {
+        await this.#events.emit("messageRecovered", event.payload);
+      } else if (event.type === "messageRecoveryFailed") {
+        await this.#events.emit("messageRecoveryFailed", event.payload);
+      } else if (event.type === "messageDecodeFailure") {
+        await this.#events.emit("messageDecodeFailure", event.payload);
+      } else if (event.type === "messageDiscarded") {
+        await this.#events.emit("messageDiscarded", event.payload);
+      }
+      await this.#refreshHealthState();
+    });
+    this.#router.on("commandQueueTimeout", async (event) => {
+      await this.#events.emit("commandQueueTimeout", event);
+    });
+    this.#router.on("commandQueueFull", async (event) => {
+      await this.#events.emit("commandQueueFull", event);
     });
     this.#provider.on("groupChanged", ({ groupId }) => this.group.invalidate(groupId));
     this.#provider.on("groupParticipantsChanged", async (change) => {
@@ -2356,6 +2563,22 @@ var WhaNextApp = class {
       }
     });
   }
+  #fallbackStability() {
+    if (this.#state === "connected") return "healthy";
+    if (this.#state === "connecting" || this.#state === "reconnecting") return "reconnecting";
+    return "offline";
+  }
+  async #refreshHealthState() {
+    const health = this.health();
+    if (health.stability === this.#lastStability) return;
+    const previous = this.#lastStability;
+    this.#lastStability = health.stability;
+    await this.#events.emit("healthChanged", {
+      previous,
+      current: health.stability,
+      health
+    });
+  }
   #healthStatus() {
     if (this.#state === "connected") {
       return "ready";
@@ -2932,6 +3155,15 @@ var fatalDisconnectReasons = /* @__PURE__ */ new Set([
 var fatalDisconnectCodes = /* @__PURE__ */ new Set([401, 403, 405, 406, 409, 516]);
 var sharedMediaProcessor = createMediaProcessor();
 var REMOTE_MEDIA_TIMEOUT_MS = 12e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
+var DEFAULT_NODE_QUERY_TIMEOUT_MS = 3e4;
+var PROVIDER_DEGRADED_WINDOW_MS = 12e4;
+var GROUP_METADATA_CACHE_TTL_MS = 18e4;
+var DEVICE_LIST_CACHE_TTL_MS = 18e4;
+var GROUP_METADATA_RECOVERY_COOLDOWN_MS = 6e4;
+var GROUP_METADATA_MISMATCH_WARNING = "group message publish acknowledged with mismatch metadata";
+var MESSAGE_RECOVERY_TIMEOUT_MS = 3e4;
+var DECRYPT_CORRELATION_TTL_MS = 15e3;
 var messageSnapshotRetentionSeconds = 7 * 24 * 60 * 60;
 var messageSnapshotMaxPerSession = 2e4;
 var messageSnapshotPruneInterval = 256;
@@ -2942,10 +3174,18 @@ var ZapoProvider = class {
   #messageStore = /* @__PURE__ */ new Map();
   #messageKeyStore = /* @__PURE__ */ new WeakMap();
   #deliveredMessageStore = /* @__PURE__ */ new Set();
+  #pendingUnavailableRecoveries = /* @__PURE__ */ new Map();
+  #recentDecryptedPayloads = /* @__PURE__ */ new Map();
   #handledProtocolStore = /* @__PURE__ */ new Set();
   #callCreatorStore = /* @__PURE__ */ new Map();
+  #groupMetadataRecoveryAt = /* @__PURE__ */ new Map();
+  #groupMetadataRecoveryInFlight = /* @__PURE__ */ new Set();
   #messageCacheSize;
+  #cryptoBackend;
+  #connectTimeoutMs;
+  #nodeQueryTimeoutMs;
   #protocolMutationQueue = Promise.resolve();
+  #state = "idle";
   #client;
   #storeEntry;
   #storePath;
@@ -2960,14 +3200,95 @@ var ZapoProvider = class {
   #messageSnapshotsSincePrune = 0;
   #pairingReady = Promise.resolve();
   #resolvePairingReady;
+  #lastConnectedAt;
+  #lastDisconnectedAt;
+  #reconnects = 0;
+  #sentMessages = 0;
+  #receivedMessages = 0;
+  #failedMessages = 0;
+  #decryptedPayloads = 0;
+  #unavailableMessages = 0;
+  #resendRequestedMessages = 0;
+  #recoveredMessages = 0;
+  #recoveryFailedMessages = 0;
+  #unavailableUnrecoverableMessages = 0;
+  #decodeFailures = 0;
+  #unhandledStanzas = 0;
+  #ignoredOfflineMessages = 0;
+  #duplicateMessages = 0;
+  #normalizationFailures = 0;
+  #lastIncomingAt;
+  #lastOutgoingAt;
+  #decryptFailures = 0;
+  #addonDecryptFailures = 0;
+  #senderKeyMismatches = 0;
+  #phashMismatches = 0;
+  #metadataRecoveries = 0;
+  #metadataRecoveryFailures = 0;
+  #degradedUntil = 0;
+  #healthRefreshTimer;
+  #cryptoBackendLogged = false;
   constructor(options) {
     this.#options = options;
     this.#logger = options.logger ?? new Logger("silent");
     this.#messageCacheSize = Math.max(1, options.messageCacheSize ?? 1e3);
+    this.#connectTimeoutMs = normalizeProviderTimeout(options.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS);
+    this.#nodeQueryTimeoutMs = normalizeProviderTimeout(options.nodeQueryTimeoutMs, DEFAULT_NODE_QUERY_TIMEOUT_MS);
+    this.#cryptoBackend = detectCryptoBackend();
   }
   on(event, listener) {
     return this.#events.on(event, listener);
   }
+  health() {
+    const now = Date.now();
+    const state = this.#state;
+    const stability = state === "connected" ? now < this.#degradedUntil ? "degraded" : "healthy" : state === "reconnecting" || state === "connecting" ? "reconnecting" : "offline";
+    return {
+      stability,
+      connection: {
+        state,
+        uptimeMs: this.#connectedAtSeconds > 0 && this.#connected ? Math.max(0, now - this.#connectedAtSeconds * 1e3) : 0,
+        reconnects: this.#reconnects,
+        reconnectAttempt: this.#reconnectAttempt,
+        ...this.#lastConnectedAt ? { lastConnectedAt: new Date(this.#lastConnectedAt) } : {},
+        ...this.#lastDisconnectedAt ? { lastDisconnectedAt: new Date(this.#lastDisconnectedAt) } : {}
+      },
+      messaging: {
+        sent: this.#sentMessages,
+        received: this.#receivedMessages,
+        failed: this.#failedMessages,
+        decryptedPayloads: this.#decryptedPayloads,
+        unavailable: this.#unavailableMessages,
+        resendRequested: this.#resendRequestedMessages,
+        recovered: this.#recoveredMessages,
+        recoveryFailed: this.#recoveryFailedMessages,
+        unavailableUnrecoverable: this.#unavailableUnrecoverableMessages,
+        decodeFailures: this.#decodeFailures,
+        unhandledStanzas: this.#unhandledStanzas,
+        ignoredOffline: this.#ignoredOfflineMessages,
+        duplicates: this.#duplicateMessages,
+        normalizationFailures: this.#normalizationFailures,
+        ...this.#lastIncomingAt ? { lastIncomingAt: new Date(this.#lastIncomingAt) } : {},
+        ...this.#lastOutgoingAt ? { lastOutgoingAt: new Date(this.#lastOutgoingAt) } : {}
+      },
+      crypto: {
+        backend: this.#cryptoBackend,
+        acceleration: this.#cryptoBackend === "napi" || this.#cryptoBackend === "wasm",
+        decryptFailures: this.#decryptFailures,
+        addonDecryptFailures: this.#addonDecryptFailures,
+        senderKeyMismatches: this.#senderKeyMismatches
+      },
+      groups: {
+        phashMismatches: this.#phashMismatches,
+        metadataRecoveries: this.#metadataRecoveries,
+        metadataRecoveryFailures: this.#metadataRecoveryFailures
+      },
+      timeouts: {
+        connectTimeoutMs: this.#connectTimeoutMs,
+        nodeQueryTimeoutMs: this.#nodeQueryTimeoutMs
+      }
+    };
+  }
   async connect() {
     this.#intentionalClose = false;
     this.#closedNotified = false;
@@ -2976,8 +3297,9 @@ var ZapoProvider = class {
       return;
     }
     this.#preparePairingGate();
+    this.#state = this.#reconnectAttempt > 0 ? "reconnecting" : "connecting";
     await this.#events.emit("connection", {
-      state: this.#reconnectAttempt > 0 ? "reconnecting" : "connecting",
+      state: this.#state,
       attempt: this.#reconnectAttempt
     });
     this.#startConnect(client);
@@ -2988,6 +3310,15 @@ var ZapoProvider = class {
       clearTimeout(this.#reconnectTimer);
       this.#reconnectTimer = void 0;
     }
+    if (this.#healthRefreshTimer) {
+      clearTimeout(this.#healthRefreshTimer);
+      this.#healthRefreshTimer = void 0;
+    }
+    for (const pending of this.#pendingUnavailableRecoveries.values()) {
+      clearTimeout(pending.timer);
+    }
+    this.#pendingUnavailableRecoveries.clear();
+    this.#recentDecryptedPayloads.clear();
     const client = this.#client;
     this.#connectPromise = void 0;
     try {
@@ -2998,6 +3329,8 @@ var ZapoProvider = class {
       }
     } finally {
       this.#connected = false;
+      this.#state = "closed";
+      this.#lastDisconnectedAt = /* @__PURE__ */ new Date();
       await this.#releaseStore();
     }
   }
@@ -3045,50 +3378,56 @@ var ZapoProvider = class {
     }
   }
   async sendMessage(chatId, content, replyTo) {
-    if ("buttons" in content) {
-      return this.#sendButtons(chatId, content, replyTo);
-    }
-    if ("list" in content) {
-      return this.#sendList(chatId, content, replyTo);
-    }
-    const client = this.#requireClient();
-    const { value, mentions, viewOnce } = await this.#toContent(content);
-    const result = await client.message.send(chatId, value, {
-      ...replyTo ? { quote: this.#toZapoKey(replyTo) } : {},
-      ...mentions.length > 0 ? { mentions } : {},
-      ...viewOnce !== void 0 ? { viewOnce } : {}
+    return this.#trackOutgoing(async () => {
+      if ("buttons" in content) {
+        return this.#sendButtons(chatId, content, replyTo);
+      }
+      if ("list" in content) {
+        return this.#sendList(chatId, content, replyTo);
+      }
+      const client = this.#requireClient();
+      const { value, mentions, viewOnce } = await this.#toContent(content);
+      const result = await client.message.send(chatId, value, {
+        ...replyTo ? { quote: this.#toZapoKey(replyTo) } : {},
+        ...mentions.length > 0 ? { mentions } : {},
+        ...viewOnce !== void 0 ? { viewOnce } : {}
+      });
+      return this.#sent(result, chatId);
     });
-    return this.#sent(result, chatId);
   }
   async repostMessage(source, chatId, options = {}) {
-    const original = await this.#findStoredMessage(this.#toZapoKey(source));
-    if (!original?.message) {
-      throw new WhaNextError(
-        "MESSAGE_NOT_FOUND",
-        "The source message is no longer available in the recent-message cache.",
+    return this.#trackOutgoing(async () => {
+      const original = await this.#findStoredMessage(this.#toZapoKey(source));
+      if (!original?.message) {
+        throw new WhaNextError(
+          "MESSAGE_NOT_FOUND",
+          "The source message is no longer available in the recent-message cache.",
+          {
+            context: { messageId: source.id, chatId: source.chatId },
+            recoverable: true
+          }
+        );
+      }
+      const result = await this.#requireClient().message.send(
+        chatId,
+        original.message,
         {
-          context: { messageId: source.id, chatId: source.chatId },
-          recoverable: true
+          forward: true,
+          ...options.mentions && options.mentions.length > 0 ? { mentions: this.#mentions(options.mentions) } : {}
         }
       );
-    }
-    const result = await this.#requireClient().message.send(
-      chatId,
-      original.message,
-      {
-        forward: true,
-        ...options.mentions && options.mentions.length > 0 ? { mentions: this.#mentions(options.mentions) } : {}
-      }
-    );
-    return this.#sent(result, chatId);
+      return this.#sent(result, chatId);
+    });
   }
   async reactToMessage(key, emoji) {
-    const result = await this.#requireClient().message.send(key.chatId, {
-      type: "reaction",
-      emoji: emoji ?? "",
-      target: this.#toZapoKey(key)
+    return this.#trackOutgoing(async () => {
+      const result = await this.#requireClient().message.send(key.chatId, {
+        type: "reaction",
+        emoji: emoji ?? "",
+        target: this.#toZapoKey(key)
+      });
+      return this.#sent(result, key.chatId);
     });
-    return this.#sent(result, key.chatId);
   }
   async downloadMedia(key) {
     const message = this.#messageKeyStore.get(key) ?? await this.#findStoredMessage(this.#toZapoKey(key));
@@ -3124,17 +3463,21 @@ var ZapoProvider = class {
     }
   }
   async editMessage(key, content) {
-    const result = await this.#requireClient().message.send(
-      key.chatId,
-      content,
-      { editKey: this.#toZapoKey(key) }
-    );
-    return this.#sent(result, key.chatId);
+    return this.#trackOutgoing(async () => {
+      const result = await this.#requireClient().message.send(
+        key.chatId,
+        content,
+        { editKey: this.#toZapoKey(key) }
+      );
+      return this.#sent(result, key.chatId);
+    });
   }
   async deleteMessage(key) {
-    await this.#requireClient().message.send(key.chatId, {
-      type: "revoke",
-      target: this.#toZapoKey(key)
+    await this.#trackOutgoing(async () => {
+      await this.#requireClient().message.send(key.chatId, {
+        type: "revoke",
+        target: this.#toZapoKey(key)
+      });
     });
   }
   async getGroup(groupId) {
@@ -3186,13 +3529,15 @@ var ZapoProvider = class {
     return result.code;
   }
   async setMessagePin(groupId, key, pinned) {
-    await this.#requireClient().message.send(groupId, pinned ? {
-      type: "pin",
-      target: this.#toZapoKey(key),
-      durationSecs: 604800
-    } : {
-      type: "unpin",
-      target: this.#toZapoKey(key)
+    await this.#trackOutgoing(async () => {
+      await this.#requireClient().message.send(groupId, pinned ? {
+        type: "pin",
+        target: this.#toZapoKey(key),
+        durationSecs: 604800
+      } : {
+        type: "unpin",
+        target: this.#toZapoKey(key)
+      });
     });
   }
   async updateParticipant(groupId, memberId, action) {
@@ -3233,6 +3578,14 @@ var ZapoProvider = class {
       ]
     });
   }
+  async #trackOutgoing(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      this.#failedMessages += 1;
+      throw error;
+    }
+  }
   async #ensureClient() {
     if (this.#client) return this.#client;
     const authPath = resolve2(this.#options.auth);
@@ -3256,13 +3609,29 @@ var ZapoProvider = class {
       markOnlineOnConnect: false,
       deviceBrowser: this.#deviceBrowser(),
       deviceOsDisplayName: this.#deviceOsDisplayName(),
+      connectTimeoutMs: this.#connectTimeoutMs,
+      nodeQueryTimeoutMs: this.#nodeQueryTimeoutMs,
       history: { enabled: true, requireFullSync: true },
       addons: {
         autoDecrypt: true,
         persistAllSecrets: true
       },
       media: { processor: sharedMediaProcessor }
-    }, new WhaNextZapoLogger(this.#logger));
+    }, new WhaNextZapoLogger(
+      this.#logger,
+      {},
+      (message, context) => this.#observeZapoWarning(message, context)
+    ));
+    if (!this.#cryptoBackendLogged) {
+      this.#cryptoBackendLogged = true;
+      if (this.#cryptoBackend === "napi" || this.#cryptoBackend === "wasm") {
+        this.#logger.info("Crypto acceleration enabled.", { backend: this.#cryptoBackend });
+      } else {
+        this.#logger.debug("Crypto acceleration unavailable; using JavaScript backend.", {
+          backend: this.#cryptoBackend
+        });
+      }
+    }
     this.#storeEntry = storeEntry;
     this.#storePath = storePath;
     this.#client = client;
@@ -3311,8 +3680,19 @@ var ZapoProvider = class {
       }
       this.#handleMessage(event);
     });
+    client.on("message_unavailable", (event) => {
+      this.#handleUnavailableMessage(event);
+    });
+    client.on("debug_decrypted_payload", (event) => {
+      this.#handleDecryptedPayload(event);
+    });
+    client.on("debug_unhandled_stanza", (event) => {
+      this.#handleUnhandledStanza(event);
+    });
     client.on("message_send", (event) => {
       if (!event.id || !event.message) return;
+      this.#sentMessages += 1;
+      this.#lastOutgoingAt = /* @__PURE__ */ new Date();
       this.#remember({
         key: {
           id: event.id,
@@ -3347,7 +3727,16 @@ var ZapoProvider = class {
     if (quoted?.key.id && quoted.message) {
       this.#remember(quoted);
     }
+    const deliveryKey = this.#messageDeliveryKey(stored.key);
+    this.#resolveUnavailableRecovery(deliveryKey, stored.key);
+    const decryptedCorrelationKey = this.#stanzaCorrelationKey(
+      stored.key.remoteJid ?? void 0,
+      stored.key.id ?? void 0
+    );
+    if (decryptedCorrelationKey) this.#recentDecryptedPayloads.delete(decryptedCorrelationKey);
     if (this.#isOfflineMessage(stored)) {
+      this.#ignoredOfflineMessages += 1;
+      this.#emitMessageDiscarded("offline", stored.key);
       this.#logger.debug("Ignored message queued before the current live connection.", {
         messageId: stored.key.id ?? void 0,
         chatId: stored.key.remoteJid ?? void 0,
@@ -3355,8 +3744,9 @@ var ZapoProvider = class {
       });
       return;
     }
-    const deliveryKey = this.#messageDeliveryKey(stored.key);
     if (stored.key.id && this.#deliveredMessageStore.has(deliveryKey)) {
+      this.#duplicateMessages += 1;
+      this.#emitMessageDiscarded("duplicate", stored.key);
       this.#logger.debug("Ignored duplicate Zapo message event.", {
         messageId: stored.key.id,
         chatId: stored.key.remoteJid ?? void 0
@@ -3364,8 +3754,18 @@ var ZapoProvider = class {
       return;
     }
     const message = normalizeZapoMessage(event);
-    if (!message) return;
+    if (!message) {
+      this.#normalizationFailures += 1;
+      this.#emitMessageDiscarded("normalization_failed", stored.key);
+      this.#logger.warn("Could not normalize incoming Zapo message.", {
+        messageId: stored.key.id ?? void 0,
+        chatId: stored.key.remoteJid ?? void 0
+      });
+      return;
+    }
     if (stored.key.id) this.#rememberDeliveredMessage(deliveryKey);
+    this.#receivedMessages += 1;
+    this.#lastIncomingAt = /* @__PURE__ */ new Date();
     this.#messageKeyStore.set(message.keys, stored);
     if (message.quoted && quoted?.message) {
       this.#messageKeyStore.set(
@@ -3375,6 +3775,162 @@ var ZapoProvider = class {
     }
     void this.#events.emit("message", message);
   }
+  #handleUnavailableMessage(event) {
+    this.#unavailableMessages += 1;
+    const occurredAt = /* @__PURE__ */ new Date();
+    const messageId = event.key.id || void 0;
+    const chatId = event.key.remoteJid || void 0;
+    const participantId = event.key.participant ?? event.key.participantAlt ?? void 0;
+    this.#emitStability({
+      type: "messageUnavailable",
+      payload: {
+        kind: event.kind,
+        resendRequested: event.resendRequested,
+        occurredAt,
+        ...messageId ? { messageId } : {},
+        ...chatId ? { chatId } : {},
+        ...participantId ? { participantId } : {}
+      }
+    });
+    if (!event.resendRequested) {
+      this.#unavailableUnrecoverableMessages += 1;
+      const log = event.kind === "other" ? this.#logger.warn.bind(this.#logger) : this.#logger.debug.bind(this.#logger);
+      log("Incoming message is unavailable and was not queued for recovery.", {
+        kind: event.kind,
+        ...messageId ? { messageId } : {},
+        ...chatId ? { chatId } : {},
+        ...participantId ? { participantId } : {}
+      });
+      return;
+    }
+    this.#resendRequestedMessages += 1;
+    const deliveryKey = this.#messageDeliveryKey(event.key);
+    const previous = this.#pendingUnavailableRecoveries.get(deliveryKey);
+    if (previous) clearTimeout(previous.timer);
+    const requestedAt = Date.now();
+    const timer = setTimeout(() => {
+      const pending = this.#pendingUnavailableRecoveries.get(deliveryKey);
+      if (!pending || pending.requestedAt !== requestedAt) return;
+      this.#pendingUnavailableRecoveries.delete(deliveryKey);
+      this.#recoveryFailedMessages += 1;
+      this.#markDegraded();
+      const failedAt = /* @__PURE__ */ new Date();
+      this.#emitStability({
+        type: "messageRecoveryFailed",
+        payload: {
+          failedAt,
+          waitedMs: failedAt.getTime() - pending.requestedAt,
+          ...pending.messageId ? { messageId: pending.messageId } : {},
+          ...pending.chatId ? { chatId: pending.chatId } : {},
+          ...pending.participantId ? { participantId: pending.participantId } : {}
+        }
+      });
+      this.#logger.warn("Unavailable message recovery did not arrive in time.", {
+        ...pending.messageId ? { messageId: pending.messageId } : {},
+        ...pending.chatId ? { chatId: pending.chatId } : {},
+        waitedMs: failedAt.getTime() - pending.requestedAt
+      });
+    }, MESSAGE_RECOVERY_TIMEOUT_MS);
+    this.#pendingUnavailableRecoveries.set(deliveryKey, {
+      requestedAt,
+      timer,
+      ...messageId ? { messageId } : {},
+      ...chatId ? { chatId } : {},
+      ...participantId ? { participantId } : {}
+    });
+    this.#logger.info("Incoming message unavailable; primary-device resend requested.", {
+      ...messageId ? { messageId } : {},
+      ...chatId ? { chatId } : {},
+      ...participantId ? { participantId } : {}
+    });
+  }
+  #resolveUnavailableRecovery(deliveryKey, key) {
+    const pending = this.#pendingUnavailableRecoveries.get(deliveryKey);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.#pendingUnavailableRecoveries.delete(deliveryKey);
+    this.#recoveredMessages += 1;
+    const recoveredAt = /* @__PURE__ */ new Date();
+    const participantId = key.participant ?? key.participantAlt ?? pending.participantId;
+    this.#emitStability({
+      type: "messageRecovered",
+      payload: {
+        recoveredAt,
+        recoveryMs: recoveredAt.getTime() - pending.requestedAt,
+        ...key.id ? { messageId: key.id } : pending.messageId ? { messageId: pending.messageId } : {},
+        ...key.remoteJid ? { chatId: key.remoteJid } : pending.chatId ? { chatId: pending.chatId } : {},
+        ...participantId ? { participantId } : {}
+      }
+    });
+    this.#logger.info("Recovered unavailable message from the primary device.", {
+      ...key.id ? { messageId: key.id } : {},
+      ...key.remoteJid ? { chatId: key.remoteJid } : {},
+      recoveryMs: recoveredAt.getTime() - pending.requestedAt
+    });
+  }
+  #handleDecryptedPayload(event) {
+    this.#decryptedPayloads += 1;
+    const correlationKey = this.#stanzaCorrelationKey(event.chatJid, event.stanzaId);
+    if (!correlationKey) return;
+    const now = Date.now();
+    this.#recentDecryptedPayloads.set(correlationKey, {
+      observedAt: now,
+      encType: event.encType
+    });
+    for (const [key, value] of this.#recentDecryptedPayloads) {
+      if (now - value.observedAt > DECRYPT_CORRELATION_TTL_MS) {
+        this.#recentDecryptedPayloads.delete(key);
+      }
+    }
+  }
+  #handleUnhandledStanza(event) {
+    this.#unhandledStanzas += 1;
+    const correlationKey = this.#stanzaCorrelationKey(event.chatJid, event.stanzaId);
+    const decrypted = correlationKey ? this.#recentDecryptedPayloads.get(correlationKey) : void 0;
+    const now = Date.now();
+    if (decrypted && now - decrypted.observedAt <= DECRYPT_CORRELATION_TTL_MS) {
+      this.#decodeFailures += 1;
+      this.#markDegraded();
+      this.#emitStability({
+        type: "messageDecodeFailure",
+        payload: {
+          occurredAt: new Date(now),
+          reason: event.reason,
+          encType: decrypted.encType,
+          ...event.stanzaId ? { stanzaId: event.stanzaId } : {},
+          ...event.chatJid ? { chatId: event.chatJid } : {}
+        }
+      });
+      this.#logger.warn("Decrypted incoming payload could not be decoded into a supported stanza.", {
+        reason: event.reason,
+        encType: decrypted.encType,
+        ...event.stanzaId ? { stanzaId: event.stanzaId } : {},
+        ...event.chatJid ? { chatId: event.chatJid } : {}
+      });
+      if (correlationKey) this.#recentDecryptedPayloads.delete(correlationKey);
+      return;
+    }
+    this.#logger.debug("Incoming stanza was not handled by Zapo.", {
+      reason: event.reason,
+      ...event.stanzaId ? { stanzaId: event.stanzaId } : {},
+      ...event.chatJid ? { chatId: event.chatJid } : {}
+    });
+  }
+  #emitMessageDiscarded(reason, key) {
+    this.#emitStability({
+      type: "messageDiscarded",
+      payload: {
+        reason,
+        occurredAt: /* @__PURE__ */ new Date(),
+        ...key.id ? { messageId: key.id } : {},
+        ...key.remoteJid ? { chatId: key.remoteJid } : {}
+      }
+    });
+  }
+  #stanzaCorrelationKey(chatJid, stanzaId) {
+    if (!stanzaId) return void 0;
+    return `${chatJid ?? ""}:${stanzaId}`;
+  }
   #handleAddonEvent(event) {
     const decrypted = this.#addonRecord(event.decrypted);
     const protocol = this.#addonProtocolMessage(decrypted);
@@ -3622,21 +4178,121 @@ var ZapoProvider = class {
     }
     void this.#events.emit("groupChanged", { groupId });
   }
+  #observeZapoWarning(message, context) {
+    if (message === GROUP_METADATA_MISMATCH_WARNING) {
+      this.#phashMismatches += 1;
+      this.#markDegraded();
+      const groupId = stringValue(context.groupJid);
+      if (groupId?.endsWith("@g.us")) void this.#recoverGroupMetadata(groupId);
+      return;
+    }
+    if (message === "failed to decrypt incoming message") {
+      this.#decryptFailures += 1;
+      const detail = stringValue(context.message);
+      const kind = detail === "sender key id mismatch" ? "sender_key_mismatch" : "decrypt_failure";
+      if (kind === "sender_key_mismatch") this.#senderKeyMismatches += 1;
+      this.#markDegraded();
+      this.#emitCryptoDegraded(kind, context);
+      return;
+    }
+    if (message === "addon auto-decrypt failed") {
+      this.#addonDecryptFailures += 1;
+      this.#markDegraded();
+      this.#emitCryptoDegraded("addon_decrypt_failure", context);
+    }
+  }
+  #emitCryptoDegraded(kind, context) {
+    const messageId = stringValue(context.id);
+    const chatId = stringValue(context.from) ?? stringValue(context.groupJid);
+    const participantId = stringValue(context.participant);
+    this.#emitStability({
+      type: "cryptoDegraded",
+      payload: {
+        kind,
+        occurredAt: /* @__PURE__ */ new Date(),
+        ...messageId ? { messageId } : {},
+        ...chatId ? { chatId } : {},
+        ...participantId ? { participantId } : {}
+      }
+    });
+  }
+  #markDegraded() {
+    this.#degradedUntil = Math.max(this.#degradedUntil, Date.now() + PROVIDER_DEGRADED_WINDOW_MS);
+    if (this.#healthRefreshTimer) clearTimeout(this.#healthRefreshTimer);
+    const delay = Math.max(1, this.#degradedUntil - Date.now() + 5);
+    this.#healthRefreshTimer = setTimeout(() => {
+      this.#healthRefreshTimer = void 0;
+      this.#emitStability({
+        type: "healthRefresh",
+        payload: { occurredAt: /* @__PURE__ */ new Date() }
+      });
+    }, delay);
+  }
+  #emitStability(event) {
+    void this.#events.emit("stability", event).catch((error) => {
+      this.#logger.warn("Stability event listener failed.", {
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    });
+  }
+  async #recoverGroupMetadata(groupId) {
+    const client = this.#client;
+    const storeEntry = this.#storeEntry;
+    if (!client || !storeEntry || !this.#connected) return;
+    const now = Date.now();
+    const lastRecoveryAt = this.#groupMetadataRecoveryAt.get(groupId);
+    if (lastRecoveryAt !== void 0 && now - lastRecoveryAt < GROUP_METADATA_RECOVERY_COOLDOWN_MS) {
+      return;
+    }
+    if (this.#groupMetadataRecoveryInFlight.has(groupId)) return;
+    this.#groupMetadataRecoveryAt.set(groupId, now);
+    this.#groupMetadataRecoveryInFlight.add(groupId);
+    try {
+      const sessionStore = storeEntry.store.session(this.#sessionId());
+      await sessionStore.groupMetadata.deleteGroupMetadata(groupId);
+      await client.group.queryGroupMetadata(groupId);
+      await this.#events.emit("groupChanged", { groupId });
+      this.#metadataRecoveries += 1;
+      const recoveredAt = /* @__PURE__ */ new Date();
+      this.#emitStability({
+        type: "groupMetadataRecovered",
+        payload: { groupId, recoveredAt }
+      });
+      this.#logger.info("Refreshed group metadata after participant-hash mismatch.", {
+        groupId
+      });
+    } catch (error) {
+      this.#metadataRecoveryFailures += 1;
+      this.#logger.warn("Could not refresh group metadata after participant-hash mismatch.", {
+        groupId,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    } finally {
+      this.#groupMetadataRecoveryInFlight.delete(groupId);
+    }
+  }
   async #handleConnectionEvent(client, event) {
     if (client !== this.#client) return;
     if (event.status === "open") {
+      const wasReconnect = this.#reconnectAttempt > 0;
       this.#connectPromise = void 0;
       this.#connected = true;
+      this.#state = "connected";
       this.#resolvePairingReady?.();
       this.#resolvePairingReady = void 0;
       this.#connectedAtSeconds = Math.floor(Date.now() / 1e3);
+      this.#lastConnectedAt = /* @__PURE__ */ new Date();
+      if (wasReconnect) this.#reconnects += 1;
       this.#reconnectAttempt = 0;
       this.#closedNotified = false;
+      this.#groupMetadataRecoveryAt.clear();
+      this.#groupMetadataRecoveryInFlight.clear();
       await this.#events.emit("connection", { state: "connected" });
       return;
     }
     this.#connectPromise = void 0;
     this.#connected = false;
+    this.#lastDisconnectedAt = /* @__PURE__ */ new Date();
     const details = disconnectDetails(event.reason, event.code);
     const error = connectionError(event.reason, details);
     if (this.#intentionalClose || event.isLogout === true || shouldStopAutomaticReconnect(details)) {
@@ -3678,6 +4334,8 @@ var ZapoProvider = class {
     }
     this.#connectPromise = void 0;
     this.#connected = false;
+    this.#state = "closed";
+    this.#lastDisconnectedAt = /* @__PURE__ */ new Date();
     await this.#emitClosedOnce(error);
     this.#client = void 0;
     try {
@@ -3693,6 +4351,7 @@ var ZapoProvider = class {
   async #emitClosedOnce(error) {
     if (this.#closedNotified) return;
     this.#closedNotified = true;
+    this.#state = "closed";
     await this.#events.emit("connection", {
       state: "closed",
       ...error ? { error } : {}
@@ -3714,15 +4373,16 @@ var ZapoProvider = class {
   async #scheduleReconnect(error, delayOverrideMs) {
     if (this.#reconnectTimer) return;
     const options = this.#options.reconnect;
-    const maxAttempts = options?.maxAttempts ?? 10;
+    const maxAttempts = options?.maxAttempts ?? Number.POSITIVE_INFINITY;
     if (options?.enabled === false || this.#reconnectAttempt >= maxAttempts) {
       await this.#emitClosedOnce(error);
       await this.#releaseStore();
       return;
     }
     this.#reconnectAttempt += 1;
+    this.#state = "reconnecting";
     await this.#events.emit("connection", {
-      state: "reconnecting",
+      state: this.#state,
       attempt: this.#reconnectAttempt,
       ...error ? { error } : {}
     });
@@ -4008,11 +4668,16 @@ var ZapoProvider = class {
     return mentions.map((mention) => typeof mention === "string" ? mention : mention.mentionId);
   }
   #toZapoKey(key) {
+    const original = this.#messageKeyStore.get(key)?.key;
+    const participant = original?.participant ?? key.participantId;
     return {
       id: key.id,
       remoteJid: key.chatId,
       fromMe: key.fromMe,
-      ...key.participantId ? { participant: key.participantId } : {}
+      ...original?.remoteJidAlt ? { remoteJidAlt: original.remoteJidAlt } : {},
+      ...participant ? { participant } : {},
+      ...original?.participantAlt ? { participantAlt: original.participantAlt } : {},
+      ...original?.addressingMode ? { addressingMode: original.addressingMode } : {}
     };
   }
   #sent(result, chatId) {
@@ -4408,7 +5073,12 @@ function createZapoStoreEntry(storePath) {
     backends: {
       sqlite: createSqliteStore({
         path: storePath,
-        driver: "auto"
+        driver: "auto",
+        pragmas: {
+          journal_mode: "WAL",
+          synchronous: "NORMAL",
+          busy_timeout: 5e3
+        }
       })
     },
     providers: {
@@ -4426,11 +5096,19 @@ function createZapoStoreEntry(storePath) {
     },
     cacheProviders: {
       messageSecret: "sqlite"
+    },
+    memory: {
+      cacheTtlMs: {
+        groupMetadataMs: GROUP_METADATA_CACHE_TTL_MS,
+        deviceListMs: DEVICE_LIST_CACHE_TTL_MS
+      }
     }
   });
   const Database = require2("better-sqlite3");
   const snapshotDb = new Database(messageSnapshotStorePath(storePath));
   snapshotDb.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
     PRAGMA busy_timeout = 5000;
     CREATE TABLE IF NOT EXISTS whanext_message_snapshots (
       session_id TEXT NOT NULL,
@@ -4671,6 +5349,44 @@ function booleanValue(value) {
   if (value === false || value === 0) return false;
   return void 0;
 }
+function normalizeProviderTimeout(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1e3, Math.floor(value));
+}
+function detectCryptoBackend() {
+  const requested = process.env.ZAPO_NATIVE_BACKEND?.trim().toLowerCase() ?? "auto";
+  if (requested === "js" || requested === "none") return "js";
+  if ((requested === "auto" || requested === "napi") && nativeNapiAvailable()) {
+    return "napi";
+  }
+  if ((requested === "auto" || requested === "wasm") && supportsZapoWasmRuntime() && moduleResolvable("@zapo-js/native/wasm/pkg/zapo_native_wasm.js") && moduleResolvable("@zapo-js/native/wasm/pkg/zapo_native_wasm_bg.wasm")) {
+    return "wasm";
+  }
+  return "js";
+}
+function nativeNapiAvailable() {
+  try {
+    require2("@zapo-js/native");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function moduleResolvable(specifier) {
+  try {
+    require2.resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function supportsZapoWasmRuntime() {
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  if (major > 22) return true;
+  if (major === 22) return minor >= 12;
+  if (major === 20) return minor >= 19;
+  return false;
+}
 function bytesField(value) {
   if (value instanceof Uint8Array) return value;
   return void 0;
@@ -4679,9 +5395,11 @@ var WhaNextZapoLogger = class _WhaNextZapoLogger {
   level;
   #logger;
   #context;
-  constructor(logger, context = {}) {
+  #onWarn;
+  constructor(logger, context = {}, onWarn) {
     this.#logger = logger;
     this.#context = context;
+    this.#onWarn = onWarn;
     this.level = logger.level === "debug" ? "debug" : logger.level === "warn" ? "warn" : logger.level === "error" || logger.level === "silent" ? "error" : "info";
   }
   trace(message, context) {
@@ -4694,7 +5412,9 @@ var WhaNextZapoLogger = class _WhaNextZapoLogger {
     this.#logger.info(message, this.#merge(context));
   }
   warn(message, context) {
-    this.#logger.warn(message, this.#merge(context));
+    const merged = this.#merge(context);
+    this.#logger.warn(message, merged);
+    this.#onWarn?.(message, merged);
   }
   error(message, context) {
     this.#logger.error(message, this.#merge(context));
@@ -4703,7 +5423,7 @@ var WhaNextZapoLogger = class _WhaNextZapoLogger {
     return new _WhaNextZapoLogger(this.#logger, {
       ...this.#context,
       ...bindings
-    });
+    }, this.#onWarn);
   }
   #merge(context) {
     return context ? { ...this.#context, ...context } : this.#context;
@@ -4731,7 +5451,9 @@ async function create(options = {}) {
     ...options.accountId ? { sessionId: options.accountId } : {},
     ...options.messageCacheSize !== void 0 ? { messageCacheSize: options.messageCacheSize } : {},
     ...options.processOfflineMessages !== void 0 ? { processOfflineMessages: options.processOfflineMessages } : {},
-    ...options.reconnect ? { reconnect: options.reconnect } : {}
+    ...options.reconnect ? { reconnect: options.reconnect } : {},
+    ...options.providerTimeouts?.connectTimeoutMs !== void 0 ? { connectTimeoutMs: options.providerTimeouts.connectTimeoutMs } : {},
+    ...options.providerTimeouts?.nodeQueryTimeoutMs !== void 0 ? { nodeQueryTimeoutMs: options.providerTimeouts.nodeQueryTimeoutMs } : {}
   });
   return new WhaNextApp(provider, {
     ...options.accountId ? { accountId: options.accountId } : {},
@@ -4963,6 +5685,12 @@ function mergeCreateOptions(shared, account) {
       ...account.reconnect
     };
   }
+  if (shared.providerTimeouts || account.providerTimeouts) {
+    merged.providerTimeouts = {
+      ...shared.providerTimeouts,
+      ...account.providerTimeouts
+    };
+  }
   if (shared.logger && account.logger && typeof shared.logger === "object" && typeof account.logger === "object") {
     merged.logger = {
       ...shared.logger,