@whanext/core 0.19.16 → 0.19.19

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 0.19.19
+
+### Provider
+- Updated the official provider from `zapo-js@1.7.1` to `zapo-js@1.8.0`.
+- Kept full received LID/PN addressing metadata when replying, reacting, editing, revoking, and pinning messages.
+- Inherits Zapo 1.8.0 mailbox `fromMe` persistence fixes, group-status stanza attribute unwrapping, username support, expired-CDN media resend support, and mobile-primary WhatsApp Business support.
+
+### Incoming message observability
+- Added `message_unavailable` tracking with primary-device resend correlation and a bounded 30-second recovery window.
+- Added `debug_decrypted_payload` correlation with `debug_unhandled_stanza` so decrypted-but-undecodable payloads are visible without logging plaintext bytes.
+- Expanded `health().messaging` with `decryptedPayloads`, `unavailable`, `resendRequested`, `recovered`, `recoveryFailed`, `unavailableUnrecoverable`, `decodeFailures`, `unhandledStanzas`, `ignoredOffline`, `duplicates`, and `normalizationFailures`.
+- Added typed `messageUnavailable`, `messageRecovered`, `messageRecoveryFailed`, `messageDecodeFailure`, and `messageDiscarded` application events.
+- Recovery failures and decrypted-payload decode failures temporarily mark provider stability as `degraded`; expected unrecoverable placeholders such as consumed view-once messages are counted without automatically degrading the session.
+
+### Safety
+- Raw decrypted payload bytes from Zapo are never emitted through the WhaNext public events or written to logs.
+- Existing `received`, `sent`, and `failed` counters keep their previous semantics; the new counters explain why an inbound stanza may not have become a public WhaNext `Message`.
+
+## 0.19.18
+
+### Stability
+- Added bounded command queues for `strategy: 'queue'`: `maxQueue` defaults to 10 waiting executions and `queueTimeoutMs` defaults to 60 seconds. Set either option to `0` to disable that limit.
+- Added `COMMAND_QUEUE_FULL` and `COMMAND_QUEUE_TIMEOUT` with typed `commandQueueFull` and `commandQueueTimeout` application events.
+- Added explicit Zapo transport/query timeouts through `providerTimeouts.connectTimeoutMs` and `providerTimeouts.nodeQueryTimeoutMs`, defaulting to 15 seconds and 30 seconds.
+- Stability event listeners are isolated from provider recovery work so consumer handler failures cannot turn a successful metadata recovery into a provider failure.
+
+### Health
+- Expanded `app.health()` without removing the existing fields. It now exposes `stability`, connection/reconnect state, messaging counters, crypto degradation counters, group metadata recovery counters, command queue metrics, and effective provider timeouts.
+- Added `healthy`, `degraded`, `reconnecting`, and `offline` operational stability states. Transient crypto/group warnings move the provider to `degraded` for a bounded window and automatically return it to `healthy`.
+- Added typed `healthChanged`, `connectionRecovered`, `groupMetadataRecovered`, and `cryptoDegraded` events.
+
+### Performance
+- Added `@zapo-js/native@0.1.0` as an optional dependency. Zapo automatically uses its X25519/XEdDSA accelerator when available and falls back to JavaScript when unavailable.
+- Health reports the detected crypto backend as `napi`, `wasm`, `js`, or `unknown`; the published optional package is detected as WASM on supported Node runtimes while locally built N-API addons are reported only when they can actually be loaded.
+
+### Compatibility
+- Existing command concurrency declarations remain valid; the queue limits only affect commands that already use `strategy: 'queue'`.
+- Custom providers are not required to implement `health()`; WhaNext supplies neutral health fallbacks when a provider does not expose runtime metrics.
+
+## 0.19.17
+
+### Reliability
+- Group sends now self-heal when Zapo reports an acknowledged participant-hash mismatch: WhaNext invalidates only the affected group's metadata cache, fetches fresh server metadata, invalidates the public group snapshot, and rate-limits recovery to once per group per minute.
+- Volatile Zapo `groupMetadata` and `deviceList` memory caches now expire after 3 minutes instead of the 5-minute default, reducing stale LID/device fan-out windows without disabling caching or forcing an IQ/usync on every send.
+- Transient WhatsApp disconnects now retry indefinitely by default with the existing exponential backoff; applications that set `reconnect.maxAttempts` keep their explicit limit. Fatal/logout reasons still stop reconnection immediately.
+
+### Performance
+- The shared Zapo SQLite store now uses `WAL`, `synchronous=NORMAL`, and a 5-second `busy_timeout`, improving concurrent reads/writes for persisted Signal, sender-key, mailbox, and app-state data.
+- The WhaNext mutation-snapshot SQLite database now uses the same WAL/NORMAL settings, reducing fsync contention on active bots.
+
+### Safety
+- Sender keys and Signal sessions are never globally reset during mismatch recovery. Zapo's normal retry-receipt/decryption recovery remains authoritative; WhaNext only refreshes stale group metadata.
+
 ## 0.19.16
 
 ### Fixed

package/README.md

@@ -311,20 +311,41 @@ const app = await create({
 
 ## Health checks
 
-`app.health()` entrega um snapshot sem consultar o WhatsApp novamente:
+`app.health()` entrega um snapshot local e barato, sem consultar o WhatsApp novamente. Os campos antigos permanecem disponíveis e a camada de estabilidade acrescenta conexão, mensagens, crypto, grupos, filas e timeouts:
 
 ```ts
 const health = app.health();
 
 console.log(health.status);
+console.log(health.stability);
 console.log(health.ready);
 console.log(health.state);
 console.log(health.uptimeMs);
-console.log(health.muteEnabled);
-console.log(health.logLevel);
+console.log(health.connection);
+console.log(health.messaging);
+console.log(health.crypto);
+console.log(health.groups);
+console.log(health.commands);
+console.log(health.timeouts);
 ```
 
-Estados possíveis: `idle`, `starting`, `ready` e `stopped`.
+`status` continua representando o ciclo da aplicação: `idle`, `starting`, `ready` ou `stopped`. `stability` representa a saúde operacional do provider: `healthy`, `degraded`, `reconnecting` ou `offline`.
+
+O provider Zapo contabiliza reconexões, mensagens enviadas/recebidas, falhas de envio, falhas de descriptografia, `sender key id mismatch`, falhas de addons, divergências de `phash` e recuperações de metadata. Com Zapo 1.8.0, `health.messaging` também mostra mensagens indisponíveis, pedidos de resend, recuperações, payloads descriptografados, falhas de decode, stanzas não tratadas, duplicatas, mensagens offline ignoradas e falhas de normalização. O router contabiliza execuções ativas, fila atual, expirações e rejeições por fila cheia.
+
+```ts
+const { messaging } = app.health();
+
+console.log(messaging.unavailable);
+console.log(messaging.resendRequested);
+console.log(messaging.recovered);
+console.log(messaging.recoveryFailed);
+console.log(messaging.decodeFailures);
+console.log(messaging.ignoredOffline);
+console.log(messaging.duplicates);
+```
+
+`decryptedPayloads` conta payloads `<enc>` individuais, portanto pode ser maior que `received` em fanout para vários devices. O WhaNext usa esse sinal apenas para correlação e nunca expõe os bytes descriptografados no health, eventos públicos ou logs.
 
 ```ts
 server.get('/health', async () => app.health());
@@ -333,11 +354,87 @@ server.get('/health', async () => app.health());
 Para uma verificação simples:
 
 ```ts
-if (app.isReady) {
-  console.log('Aplicação pronta.');
+if (app.isReady && app.health().stability === 'healthy') {
+  console.log('Aplicação pronta e saudável.');
 }
 ```
 
+## Estabilidade do provider
+
+O provider oficial usa timeouts explícitos para conexão e queries de protocolo. Os padrões são 15 segundos para conexão e 30 segundos para queries; ambos podem ser ajustados na criação da aplicação:
+
+```ts
+const app = await create({
+  providerTimeouts: {
+    connectTimeoutMs: 15_000,
+    nodeQueryTimeoutMs: 30_000,
+  },
+});
+```
+
+Valores menores que 1 segundo são normalizados para 1 segundo. Os valores efetivos ficam disponíveis em `app.health().timeouts`.
+
+A aceleração crypto do Zapo também é integrada de forma opcional. `@zapo-js/native` acelera X25519 e XEdDSA e o provider continua funcionando com o backend JavaScript caso o acelerador não esteja disponível. O pacote publicado usa WASM; um build N-API local também é detectado quando realmente carregável.
+
+```ts
+const health = app.health();
+
+console.log(health.crypto.backend);
+console.log(health.crypto.acceleration);
+```
+
+Backends reportados: `napi`, `wasm`, `js` ou `unknown`. Para forçar o fallback JavaScript, inicie o processo com `ZAPO_NATIVE_BACKEND=js`.
+
+A aplicação expõe eventos tipados para observabilidade sem parsing de logs:
+
+```ts
+app.on('healthChanged', ({ previous, current }) => {
+  console.log(previous, current);
+});
+
+app.on('connectionRecovered', ({ recoveredAt, reconnects }) => {
+  console.log(recoveredAt, reconnects);
+});
+
+app.on('groupMetadataRecovered', ({ groupId }) => {
+  console.log(groupId);
+});
+
+app.on('cryptoDegraded', ({ kind, chatId }) => {
+  console.log(kind, chatId);
+});
+
+app.on('messageUnavailable', ({ messageId, resendRequested }) => {
+  console.log(messageId, resendRequested);
+});
+
+app.on('messageRecovered', ({ messageId, recoveryMs }) => {
+  console.log(messageId, recoveryMs);
+});
+
+app.on('messageRecoveryFailed', ({ messageId, waitedMs }) => {
+  console.log(messageId, waitedMs);
+});
+
+app.on('messageDecodeFailure', ({ stanzaId, reason }) => {
+  console.log(stanzaId, reason);
+});
+
+app.on('messageDiscarded', ({ messageId, reason }) => {
+  console.log(messageId, reason);
+});
+
+app.on('commandQueueTimeout', ({ command, queuedForMs }) => {
+  console.log(command, queuedForMs);
+});
+
+app.on('commandQueueFull', ({ command, queued }) => {
+  console.log(command, queued);
+});
+```
+
+Falhas criptográficas transitórias deixam o provider em `degraded` por uma janela curta; a volta para `healthy` também dispara `healthChanged`. A recuperação de metadata por `phash` continua específica ao grupo afetado e não apaga Sender Keys nem sessões Signal.
+
 ## Usuários
 
 Toda mensagem possui `message.sender: User`. Menções ficam em `message.mentionedUsers`, e o remetente de um reply em `message.quoted?.sender`.
@@ -697,6 +794,8 @@ app.commands.command(
       scope: 'chat',
       max: 1,
       strategy: 'queue',
+      maxQueue: 10,
+      queueTimeoutMs: 60_000,
     },
 
     async execute(ctx) {
@@ -715,6 +814,21 @@ app.commands.command(
 );
 ```
 
+Para `strategy: 'queue'`, o WhaNext limita por padrão a fila a 10 execuções aguardando e cada entrada pode esperar até 60 segundos. `maxQueue: 0` remove o limite de quantidade e `queueTimeoutMs: 0` remove o timeout. Quando os limites são atingidos, o router usa `COMMAND_QUEUE_FULL` ou `COMMAND_QUEUE_TIMEOUT` e emite os eventos tipados correspondentes.
+
+```ts
+app.commands.onError(async (ctx, error) => {
+  if (error.code === 'COMMAND_QUEUE_FULL') {
+    await ctx.reply('Muitos comandos estão aguardando. Tente novamente em instantes.');
+    return;
+  }
+
+  if (error.code === 'COMMAND_QUEUE_TIMEOUT') {
+    await ctx.reply('A fila demorou demais. Envie o comando novamente.');
+  }
+});
+```
+
 ### Comandos exclusivos do dono
 
 O dono é a própria conta conectada naquela aplicação. Não é necessário salvar número, JID ou LID manualmente. O provider usa a marca de mensagem enviada pela própria conta e, quando necessário, compara as identidades normalizadas da sessão.

package/dist/index.d.ts

@@ -289,6 +289,8 @@ interface CallEvent {
 }
 
 type ConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
+type StabilityHealthStatus = 'healthy' | 'degraded' | 'reconnecting' | 'offline';
+type CryptoAccelerationBackend = 'napi' | 'wasm' | 'js' | 'unknown';
 type PresenceState = 'typing' | 'recording' | 'paused';
 type ParticipantAction = 'remove' | 'promote' | 'demote';
 interface ParticipantUpdateResult {
@@ -301,6 +303,131 @@ interface ConnectionUpdate {
     attempt?: number;
     error?: Error;
 }
+interface ProviderConnectionHealth {
+    state: ConnectionState;
+    uptimeMs: number;
+    reconnects: number;
+    reconnectAttempt: number;
+    lastConnectedAt?: Date;
+    lastDisconnectedAt?: Date;
+}
+interface ProviderMessagingHealth {
+    sent: number;
+    received: number;
+    failed: number;
+    decryptedPayloads: number;
+    unavailable: number;
+    resendRequested: number;
+    recovered: number;
+    recoveryFailed: number;
+    unavailableUnrecoverable: number;
+    decodeFailures: number;
+    unhandledStanzas: number;
+    ignoredOffline: number;
+    duplicates: number;
+    normalizationFailures: number;
+    lastIncomingAt?: Date;
+    lastOutgoingAt?: Date;
+}
+interface ProviderCryptoHealth {
+    backend: CryptoAccelerationBackend;
+    acceleration: boolean;
+    decryptFailures: number;
+    addonDecryptFailures: number;
+    senderKeyMismatches: number;
+}
+interface ProviderGroupHealth {
+    phashMismatches: number;
+    metadataRecoveries: number;
+    metadataRecoveryFailures: number;
+}
+interface ProviderTimeoutHealth {
+    connectTimeoutMs: number;
+    nodeQueryTimeoutMs: number;
+}
+interface ProviderHealth {
+    stability: StabilityHealthStatus;
+    connection: ProviderConnectionHealth;
+    messaging: ProviderMessagingHealth;
+    crypto: ProviderCryptoHealth;
+    groups: ProviderGroupHealth;
+    timeouts: ProviderTimeoutHealth;
+}
+interface GroupMetadataRecoveredEvent {
+    groupId: string;
+    recoveredAt: Date;
+}
+type CryptoDegradationKind = 'decrypt_failure' | 'addon_decrypt_failure' | 'sender_key_mismatch';
+interface CryptoDegradedEvent {
+    kind: CryptoDegradationKind;
+    occurredAt: Date;
+    messageId?: string;
+    chatId?: string;
+    participantId?: string;
+}
+interface MessageUnavailableEvent {
+    kind: 'view_once' | 'hosted' | 'bot' | 'other';
+    resendRequested: boolean;
+    occurredAt: Date;
+    messageId?: string;
+    chatId?: string;
+    participantId?: string;
+}
+interface MessageRecoveredEvent {
+    recoveredAt: Date;
+    recoveryMs: number;
+    messageId?: string;
+    chatId?: string;
+    participantId?: string;
+}
+interface MessageRecoveryFailedEvent {
+    failedAt: Date;
+    waitedMs: number;
+    messageId?: string;
+    chatId?: string;
+    participantId?: string;
+}
+interface MessageDecodeFailureEvent {
+    occurredAt: Date;
+    reason: string;
+    stanzaId?: string;
+    chatId?: string;
+    encType?: string;
+}
+type MessageDiscardReason = 'offline' | 'duplicate' | 'normalization_failed';
+interface MessageDiscardedEvent {
+    reason: MessageDiscardReason;
+    occurredAt: Date;
+    messageId?: string;
+    chatId?: string;
+}
+type ProviderStabilityEvent = {
+    type: 'groupMetadataRecovered';
+    payload: GroupMetadataRecoveredEvent;
+} | {
+    type: 'cryptoDegraded';
+    payload: CryptoDegradedEvent;
+} | {
+    type: 'messageUnavailable';
+    payload: MessageUnavailableEvent;
+} | {
+    type: 'messageRecovered';
+    payload: MessageRecoveredEvent;
+} | {
+    type: 'messageRecoveryFailed';
+    payload: MessageRecoveryFailedEvent;
+} | {
+    type: 'messageDecodeFailure';
+    payload: MessageDecodeFailureEvent;
+} | {
+    type: 'messageDiscarded';
+    payload: MessageDiscardedEvent;
+} | {
+    type: 'healthRefresh';
+    payload: {
+        occurredAt: Date;
+    };
+};
 interface ProviderEvents {
     message: Message;
     messageDeleted: MessageDeleted;
@@ -311,6 +438,7 @@ interface ProviderEvents {
     };
     groupParticipantsChanged: GroupParticipantsChanged;
     call: CallEvent;
+    stability: ProviderStabilityEvent;
 }
 type Unsubscribe = () => void;
 interface WhatsAppProvider {
@@ -319,6 +447,7 @@ interface WhatsAppProvider {
     getCurrentUserIds(): string[];
     requestPairingCode(phone: string): Promise<string>;
     on<Event extends keyof ProviderEvents>(event: Event, listener: (payload: ProviderEvents[Event]) => void | Promise<void>): Unsubscribe;
+    health?(): ProviderHealth;
     sendMessage(chatId: string, content: MessageContent, replyTo?: MessageKey): Promise<SentMessage>;
     repostMessage(source: MessageKey, chatId: string, options?: RepostMessageOptions): Promise<SentMessage>;
     reactToMessage(key: MessageKey, emoji?: string): Promise<SentMessage>;
@@ -616,7 +745,7 @@ declare class DeferredReply {
     delete(): Promise<void>;
 }
 
-type WhaNextErrorCode = 'AUTH_INVALID_PHONE' | 'AUTH_EXPIRED' | 'AUTH_PASSKEY_REQUIRED' | 'CONNECTION_CLOSED' | 'CONNECTION_FAILED' | 'GROUP_NOT_FOUND' | 'MEMBER_NOT_FOUND' | 'BOT_NOT_ADMIN' | 'MESSAGE_NOT_FOUND' | 'MEDIA_NOT_AVAILABLE' | 'MESSAGE_REACHOUT_LOCKED' | 'MUTE_DISABLED' | 'STORAGE_ERROR' | 'ARGUMENT_MISSING' | 'ARGUMENT_INVALID' | 'COMMAND_NOT_ALLOWED' | 'COMMAND_COOLDOWN' | 'COMMAND_BUSY' | 'COMMAND_LOAD_FAILED' | 'PROVIDER_ERROR' | 'UNKNOWN_ERROR';
+type WhaNextErrorCode = 'AUTH_INVALID_PHONE' | 'AUTH_EXPIRED' | 'AUTH_PASSKEY_REQUIRED' | 'CONNECTION_CLOSED' | 'CONNECTION_FAILED' | 'GROUP_NOT_FOUND' | 'MEMBER_NOT_FOUND' | 'BOT_NOT_ADMIN' | 'MESSAGE_NOT_FOUND' | 'MEDIA_NOT_AVAILABLE' | 'MESSAGE_REACHOUT_LOCKED' | 'MUTE_DISABLED' | 'STORAGE_ERROR' | 'ARGUMENT_MISSING' | 'ARGUMENT_INVALID' | 'COMMAND_NOT_ALLOWED' | 'COMMAND_COOLDOWN' | 'COMMAND_BUSY' | 'COMMAND_QUEUE_FULL' | 'COMMAND_QUEUE_TIMEOUT' | 'COMMAND_LOAD_FAILED' | 'PROVIDER_ERROR' | 'UNKNOWN_ERROR';
 interface WhaNextErrorOptions {
     cause?: unknown;
     context?: Readonly<Record<string, unknown>>;
@@ -656,6 +785,8 @@ interface CommandConcurrency {
     max?: number;
     scope?: CommandScope;
     strategy?: ConcurrencyStrategy;
+    maxQueue?: number;
+    queueTimeoutMs?: number;
 }
 interface CommandLocalization {
     name?: string;
@@ -710,6 +841,37 @@ declare function defineCommandGroup<const Group extends CommandGroupDefinition>(
 declare function defineCommands<const Commands extends readonly CommandDefinition[]>(...commands: Commands): Commands;
 declare function isCommandGroup(definition: CommandDefinition): definition is CommandGroupDefinition;
 
+interface CommandConcurrencyContext {
+    command: string;
+    messageId: string;
+    chatId: string;
+    userId: string;
+}
+interface CommandQueueTimeoutEvent extends CommandConcurrencyContext {
+    key: string;
+    queuedForMs: number;
+    queueTimeoutMs: number;
+    queued: number;
+}
+interface CommandQueueFullEvent extends CommandConcurrencyContext {
+    key: string;
+    maxQueue: number;
+    queued: number;
+}
+interface CommandConcurrencyHealth {
+    running: number;
+    queued: number;
+    queueTimeouts: number;
+    queueRejected: number;
+}
+type CommandConcurrencyEvent = {
+    type: 'commandQueueTimeout';
+    payload: CommandQueueTimeoutEvent;
+} | {
+    type: 'commandQueueFull';
+    payload: CommandQueueFullEvent;
+};
+
 interface CommandRegistrar {
     command(definition: CommandDefinition): unknown;
 }
@@ -743,6 +905,10 @@ interface CommandHelpOptions extends CommandCatalogOptions {
     title?: string;
 }
 type CommandErrorHandler = (context: CommandContext, error: WhaNextError) => void | Promise<void>;
+interface CommandRouterEvents {
+    commandQueueTimeout: CommandQueueTimeoutEvent;
+    commandQueueFull: CommandQueueFullEvent;
+}
 declare class CommandRouter {
     #private;
     constructor(services: CommandRuntimeServices, options?: RouterOptions);
@@ -751,6 +917,8 @@ declare class CommandRouter {
     get prefixes(): readonly string[];
     setPrefixes(prefixes: string | readonly string[]): this;
     get size(): number;
+    health(): CommandConcurrencyHealth;
+    on<Event extends keyof CommandRouterEvents>(event: Event, listener: (payload: CommandRouterEvents[Event]) => void | Promise<void>): () => void;
     command(definition: CommandDefinition): this;
     load(dirPath: string | URL, options?: LoadCommandsOptions): Promise<LoadCommandsResult>;
     use(middleware: CommandMiddleware): this;
@@ -808,6 +976,15 @@ declare class AccountService {
     isOwner(message: Pick<Message, 'keys' | 'senderIds'>): boolean;
 }
 
+interface HealthChangedEvent {
+    previous: StabilityHealthStatus;
+    current: StabilityHealthStatus;
+    health: AppHealth;
+}
+interface ConnectionRecoveredEvent {
+    recoveredAt: Date;
+    reconnects: number;
+}
 interface AppEvents {
     message: Message;
     messageDeleted: MessageDeleted;
@@ -817,6 +994,17 @@ interface AppEvents {
     mute: MuteEnforcement;
     call: CallEvent;
     groupParticipantsChanged: GroupParticipantsChanged;
+    healthChanged: HealthChangedEvent;
+    connectionRecovered: ConnectionRecoveredEvent;
+    groupMetadataRecovered: GroupMetadataRecoveredEvent;
+    cryptoDegraded: CryptoDegradedEvent;
+    messageUnavailable: MessageUnavailableEvent;
+    messageRecovered: MessageRecoveredEvent;
+    messageRecoveryFailed: MessageRecoveryFailedEvent;
+    messageDecodeFailure: MessageDecodeFailureEvent;
+    messageDiscarded: MessageDiscardedEvent;
+    commandQueueTimeout: CommandQueueTimeoutEvent;
+    commandQueueFull: CommandQueueFullEvent;
 }
 interface LoginOptions {
     onCode?: (code: string) => void | Promise<void>;
@@ -825,12 +1013,19 @@ interface LoginOptions {
 type AppHealthStatus = 'idle' | 'starting' | 'ready' | 'stopped';
 interface AppHealth {
     status: AppHealthStatus;
+    stability: StabilityHealthStatus;
     state: ConnectionUpdate['state'];
     ready: boolean;
     uptimeMs: number;
     timestamp: Date;
     muteEnabled: boolean;
     logLevel: LogLevel;
+    connection: ProviderConnectionHealth;
+    messaging: ProviderMessagingHealth;
+    crypto: ProviderCryptoHealth;
+    groups: ProviderGroupHealth;
+    commands: CommandConcurrencyHealth;
+    timeouts: ProviderTimeoutHealth;
 }
 interface WhaNextAppOptions {
     phone?: string;
@@ -869,6 +1064,10 @@ declare enum Browser {
     Ubuntu = "ubuntu"
 }
 
+interface ProviderTimeoutOptions {
+    connectTimeoutMs?: number;
+    nodeQueryTimeoutMs?: number;
+}
 interface ReconnectOptions {
     enabled?: boolean;
     maxAttempts?: number;
@@ -885,6 +1084,7 @@ interface CreateOptions {
     mute?: MuteOptions;
     router?: Omit<RouterOptions, 'prefix'>;
     reconnect?: ReconnectOptions;
+    providerTimeouts?: ProviderTimeoutOptions;
     messageCacheSize?: number;
     processOfflineMessages?: boolean;
     provider?: WhatsAppProvider;
@@ -972,4 +1172,4 @@ declare class SqliteMuteStore implements MuteStore {
     close(): void;
 }
 
-export { AccountService, type AddMuteOptions, type AddMuteResult, type AppEvents, type AppHealth, type AppHealthStatus, ArgsParser, type AudioContent, type BooleanOption, Browser, type ButtonsContent, type CacheOptions, type CacheStore, type CallEvent, type CallStatus, type ChangeResult, type CommandAccountContext, type CommandCatalogOptions, type CommandCatalogView, type CommandChatContext, type CommandConcurrency, type CommandContext, type CommandCooldown, type CommandDefinition, type CommandErrorHandler, type CommandGroupContext, type CommandGroupDefinition, type CommandGuard, type CommandHelpOptions, type CommandHooks, type CommandLocalization, type CommandMetadata, type CommandMiddleware, type CommandOptionDefinition, type CommandOptionSchema, type CommandOptionValue, type CommandOptionValues, type CommandRegistrar, CommandRouter, type CommandRuntimeServices, type CommandScope, type ConcurrencyStrategy, type ConnectionState, type ConnectionUpdate, type CopyCodeButton, type CreateMultiOptions, type CreateOptions, DeferredReply, type DownloadedMedia, type DurationOption, type EnumOption, type ExecutableCommandDefinition, type GroupAccess, type GroupAddressingMode, type GroupParticipant, type GroupParticipantAction, type GroupParticipantsChanged, type GroupRole, type GroupSnapshot, type GuardResult, type ImageContent, type InteractiveResponse, type InteractiveResponseKind, type InviteResult, type LinkButton, type ListContent, type ListRow, type ListSection, type LoadCommandsOptions, type LoadCommandsResult, type LoadedCommand, type LogContext, type LogEntry, type LogFormat, type LogLevel, type LogWriter, Logger, type LoggerConfig, type LoggerOptions, type LoginOptions, type MediaKind, type MediaSource, type MemberActionState, MemoryCache, type MemoryCacheStats, type MentionTarget, type Message, type MessageButton, type MessageContent, type MessageContentKind, type MessageDeleted, type MessageEdited, type MessageKey, type MessageMedia, type MessagePayloadKind, type MessageProtocolKind, type MultiAccountOptions, type MultiAppEvent, type MultiAppHealth, MultiCommandRouter, type MultiLoadCommandsResult, type MultiLoginOptions, type MuteChangeResult, type MuteEnforcement, type MuteOptions, type MuteRecord, MuteService, type MuteStore, type NumberOption, ParsedCommandOptions, type ParticipantUpdateResult, type PollContent, type PresenceState, type QuickReplyButton, type QuotedMessage, type ReconnectOptions, type RegisteredCommand, type RemoveMuteResult, type ReplyOptions, type RepostMessageOptions, type RouterOptions, type SentMessage, SqliteMuteStore, type StickerContent, type StoredMute, type StringOption, type TextContent, User, type UserData, type UserOption, type VideoContent, WhaNextApp, WhaNextError, type WhaNextErrorCode, WhaNextMultiApp, type WhatsAppProvider, create, createMulti, defineCommand, defineCommandGroup, defineCommands, defineSubcommand, guards, isCommandGroup, loadCommands, option, toWhaNextError };
+export { AccountService, type AddMuteOptions, type AddMuteResult, type AppEvents, type AppHealth, type AppHealthStatus, ArgsParser, type AudioContent, type BooleanOption, Browser, type ButtonsContent, type CacheOptions, type CacheStore, type CallEvent, type CallStatus, type ChangeResult, type CommandAccountContext, type CommandCatalogOptions, type CommandCatalogView, type CommandChatContext, type CommandConcurrency, type CommandConcurrencyContext, type CommandConcurrencyEvent, type CommandConcurrencyHealth, type CommandContext, type CommandCooldown, type CommandDefinition, type CommandErrorHandler, type CommandGroupContext, type CommandGroupDefinition, type CommandGuard, type CommandHelpOptions, type CommandHooks, type CommandLocalization, type CommandMetadata, type CommandMiddleware, type CommandOptionDefinition, type CommandOptionSchema, type CommandOptionValue, type CommandOptionValues, type CommandQueueFullEvent, type CommandQueueTimeoutEvent, type CommandRegistrar, CommandRouter, type CommandRouterEvents, type CommandRuntimeServices, type CommandScope, type ConcurrencyStrategy, type ConnectionRecoveredEvent, type ConnectionState, type ConnectionUpdate, type CopyCodeButton, type CreateMultiOptions, type CreateOptions, type CryptoAccelerationBackend, type CryptoDegradationKind, type CryptoDegradedEvent, DeferredReply, type DownloadedMedia, type DurationOption, type EnumOption, type ExecutableCommandDefinition, type GroupAccess, type GroupAddressingMode, type GroupMetadataRecoveredEvent, type GroupParticipant, type GroupParticipantAction, type GroupParticipantsChanged, type GroupRole, type GroupSnapshot, type GuardResult, type HealthChangedEvent, type ImageContent, type InteractiveResponse, type InteractiveResponseKind, type InviteResult, type LinkButton, type ListContent, type ListRow, type ListSection, type LoadCommandsOptions, type LoadCommandsResult, type LoadedCommand, type LogContext, type LogEntry, type LogFormat, type LogLevel, type LogWriter, Logger, type LoggerConfig, type LoggerOptions, type LoginOptions, type MediaKind, type MediaSource, type MemberActionState, MemoryCache, type MemoryCacheStats, type MentionTarget, type Message, type MessageButton, type MessageContent, type MessageContentKind, type MessageDecodeFailureEvent, type MessageDeleted, type MessageDiscardReason, type MessageDiscardedEvent, type MessageEdited, type MessageKey, type MessageMedia, type MessagePayloadKind, type MessageProtocolKind, type MessageRecoveredEvent, type MessageRecoveryFailedEvent, type MessageUnavailableEvent, type MultiAccountOptions, type MultiAppEvent, type MultiAppHealth, MultiCommandRouter, type MultiLoadCommandsResult, type MultiLoginOptions, type MuteChangeResult, type MuteEnforcement, type MuteOptions, type MuteRecord, MuteService, type MuteStore, type NumberOption, ParsedCommandOptions, type ParticipantUpdateResult, type PollContent, type PresenceState, type ProviderConnectionHealth, type ProviderCryptoHealth, type ProviderGroupHealth, type ProviderHealth, type ProviderMessagingHealth, type ProviderStabilityEvent, type ProviderTimeoutHealth, type ProviderTimeoutOptions, type QuickReplyButton, type QuotedMessage, type ReconnectOptions, type RegisteredCommand, type RemoveMuteResult, type ReplyOptions, type RepostMessageOptions, type RouterOptions, type SentMessage, SqliteMuteStore, type StabilityHealthStatus, type StickerContent, type StoredMute, type StringOption, type TextContent, User, type UserData, type UserOption, type VideoContent, WhaNextApp, WhaNextError, type WhaNextErrorCode, WhaNextMultiApp, type WhatsAppProvider, create, createMulti, defineCommand, defineCommandGroup, defineCommands, defineSubcommand, guards, isCommandGroup, loadCommands, option, toWhaNextError };