@systemzero/baileys 1.0.5 → 1.0.7

package/README.md

@@ -4,11 +4,12 @@
 
 # @systemzero/baileys
 
-**v1.0.5** · Fork avançado do Baileys com suporte nativo a todos os tipos de mensagens do WhatsApp
+**v1.0.7** · Fork avançado do Baileys com suporte nativo a todos os tipos de mensagens do WhatsApp
 
 [![NPM](https://img.shields.io/npm/v/@systemzero/baileys?color=7c3aed&style=flat-square&label=npm)](https://www.npmjs.com/package/@systemzero/baileys)
 [![License](https://img.shields.io/badge/license-MIT-6366f1?style=flat-square)](LICENSE)
 [![Author](https://img.shields.io/badge/by-Josué%20%3C%2F%3E-ec4899?style=flat-square)](https://t.me/blackhzx)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-7c3aed?style=flat-square)](https://nodejs.org)
 
 </div>
 
@@ -20,13 +21,14 @@
 npm i @systemzero/baileys
 ```
 
-Dependências opcionais para sticker pack e thumbnail:
+Dependências opcionais:
 ```bash
-npm i sharp
-# ou
-npm i @napi-rs/image
+npm i sharp          # conversão de imagem para sticker pack
+npm i @napi-rs/image # alternativa ao sharp
 ```
 
+Requer `ffmpeg` instalado no sistema (com suporte a `libopus`) para conversão automática de áudio PTT. Confirme com `ffmpeg -encoders | grep opus`.
+
 ---
 
 ## Índice
@@ -39,28 +41,40 @@ npm i @napi-rs/image
 6. [Canais Newsletter](#6-canais-newsletter)
 7. [Enquetes com decrypt](#7-enquetes-com-decrypt)
 8. [AI Rich](#8-ai-rich)
-9. [Grupos](#9-grupos)
-10. [Perfil e privacidade](#10-perfil-e-privacidade)
-11. [Eventos do socket](#11-eventos-do-socket)
-12. [Utilitários](#12-utilitários)
+9. [LID / JID — Sistema avançado](#9-lid--jid--sistema-avançado)
+10. [Username (@usuario)](#10-username-usuario)
+11. [MessageBuilder — Button, ButtonV2, Carousel, AIRich](#11-messagebuilder--button-buttonv2-carousel-airich)
+12. [Botões estendidos](#12-botões-estendidos)
+13. [Grupos](#13-grupos)
+14. [Perfil e privacidade](#14-perfil-e-privacidade)
+15. [Eventos do socket](#15-eventos-do-socket)
+16. [Utilitários](#16-utilitários)
+17. [Fixar / Desfixar mensagens](#17-fixar--desfixar-mensagens)
+18. [Resolução de nomes (getName)](#18-resolução-de-nomes-getname)
+19. [PTT real com qualquer formato](#19-ptt-real-com-qualquer-formato)
+20. [Guard de pagamento stealth](#20-guard-de-pagamento-stealth-anti-fraude)
+21. [Bad MAC Handler](#21-bad-mac-handler--sessões-signal)
+22. [Resolução LID → telefone via grupo](#22-resolução-lid--telefone-via-grupo)
+23. [Versão do WhatsApp sempre atualizada](#23-versão-do-whatsapp-sempre-atualizada)
+24. [WhatsApp Flows — Formulários](#24-whatsapp-flows--formulários-interativos)
+25. [Mensagens agendadas](#25-mensagens-agendadas)
+26. [Status em grupo (GroupStatusMessageV2)](#26-status-em-grupo-groupstatusmessagev2)
 
 ---
 
 ## 1. Conexão
 
-### Setup básico
-
 ```js
 const {
     default: makeWASocket,
     useMultiFileAuthState,
     DisconnectReason,
     Browsers,
-    fetchLatestWaWebVersion
+    getBestWaVersion
 } = require('@systemzero/baileys')
 
 const { state, saveCreds } = await useMultiFileAuthState('./session')
-const { version } = await fetchLatestWaWebVersion()
+const { version, isLatest, source } = await getBestWaVersion()
 
 const sock = makeWASocket({
     version,
@@ -79,19 +93,25 @@ sock.ev.on('creds.update', saveCreds)
 sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
     if (connection === 'close') {
         const code = lastDisconnect?.error?.output?.statusCode
-        if (code !== DisconnectReason.loggedOut) startBot()
+        if (code === DisconnectReason.loggedOut) {
+            process.exit()
+        } else if (code === DisconnectReason.forbidden) {
+            console.log('Sessão revogada pelo WhatsApp (403). Apague a sessão e re-pareie.')
+            process.exit()
+        } else {
+            startBot()
+        }
     }
 })
 ```
 
+> Use `getBestWaVersion()` em vez de `fetchLatestWaWebVersion()` — ela tenta as duas fontes e só aceita resultado se buscou fresco de verdade, sem cair silenciosamente num fallback desatualizado que pode causar erros 403.
+
 ### Pairing Code
 
 ```js
-// Código gerado automaticamente (ex: ABCD-EFGH)
 const code = await sock.requestPairingCode('5511999999999')
-
-// Código personalizado — exatamente 8 caracteres
-const code = await sock.requestPairingCode('5511999999999', 'MYBOT001')
+const code = await sock.requestPairingCode('5511999999999', 'MYBOT001') // personalizado — 8 chars
 ```
 
 ### Store em memória
@@ -110,7 +130,6 @@ const store = {
     },
     loadMessage: async (jid, id) => store.messages[jid]?.[id] || null
 }
-
 store.bind(sock.ev)
 ```
 
@@ -118,111 +137,28 @@ store.bind(sock.ev)
 
 ## 2. Mensagens de mídia
 
-Todos os campos de mídia aceitam `Buffer`, `{ url: 'https://...' }` ou `{ stream: ReadableStream }`.
-
-### Texto
+Todos os campos de mídia aceitam `Buffer`, `{ url: 'https://...' }` ou `{ stream }`.
 
 ```js
 await sock.sendMessage(jid, { text: 'Olá!' })
-
-// Com menção
-await sock.sendMessage(jid, {
-    text:     '@55119...!',
-    mentions: ['5511999999999@s.whatsapp.net']
-})
-```
-
-### Imagem
-
-```js
-await sock.sendMessage(jid, {
-    image:   { url: 'https://exemplo.com/foto.jpg' },
-    caption: 'Legenda'
-})
-```
-
-### Vídeo
-
-```js
-await sock.sendMessage(jid, {
-    video:       { url: 'https://exemplo.com/video.mp4' },
-    caption:     'Legenda',
-    gifPlayback: false   // true envia como GIF silencioso
-})
-```
-
-### Áudio
-
-```js
-// Música
-await sock.sendMessage(jid, {
-    audio:    buffer,
-    mimetype: 'audio/mpeg',
-    ptt:      false
-})
-
-// Nota de voz (PTT)
-await sock.sendMessage(jid, {
-    audio:    buffer,
-    mimetype: 'audio/ogg; codecs=opus',
-    ptt:      true
-})
-```
-
-### Documento
-
-```js
-await sock.sendMessage(jid, {
-    document: buffer,
-    mimetype: 'application/pdf',
-    fileName: 'relatorio.pdf',
-    caption:  'Segue o relatório'
-})
-```
-
-### Figurinha
-
-```js
+await sock.sendMessage(jid, { text: '@5511...!', mentions: ['5511999999999@s.whatsapp.net'] })
+await sock.sendMessage(jid, { image: { url: 'https://...' }, caption: 'Legenda' })
+await sock.sendMessage(jid, { video: buffer, caption: 'Legenda', gifPlayback: false })
+await sock.sendMessage(jid, { audio: buffer, mimetype: 'audio/mpeg', ptt: false })
+await sock.sendMessage(jid, { audio: buffer, ptt: true }) // PTT — converte automaticamente
+await sock.sendMessage(jid, { document: buffer, mimetype: 'application/pdf', fileName: 'doc.pdf' })
 await sock.sendMessage(jid, { sticker: buffer })
-```
-
-### Album (múltiplas mídias agrupadas)
-
-Mínimo 2 itens.
-
-```js
 await sock.sendMessage(jid, {
-    album: [
-        { image: buffer1 },
-        { image: buffer2, caption: 'Segunda foto' },
-        { video: bufferVideo },
-    ]
+    album: [{ image: buffer1 }, { image: buffer2 }, { video: bufferVideo }]
 })
-```
-
-### Contato
-
-```js
 await sock.sendMessage(jid, {
     contacts: {
         displayName: 'João',
-        contacts: [{
-            vcard: `BEGIN:VCARD\nVERSION:3.0\nFN:João Silva\nTEL:+5511999999999\nEND:VCARD`
-        }]
+        contacts: [{ vcard: 'BEGIN:VCARD\nVERSION:3.0\nFN:João\nTEL:+5511999999999\nEND:VCARD' }]
     }
 })
-```
-
-### Localização
-
-```js
 await sock.sendMessage(jid, {
-    location: {
-        degreesLatitude:  -23.550520,
-        degreesLongitude: -46.633308,
-        name:             'São Paulo',
-        address:          'SP, Brasil'
-    }
+    location: { degreesLatitude: -23.55, degreesLongitude: -46.63, name: 'São Paulo' }
 })
 ```
 
@@ -230,790 +166,825 @@ await sock.sendMessage(jid, {
 
 ## 3. Mensagens especiais
 
-### Reação
-
-```js
-await sock.sendMessage(jid, {
-    react: { text: '❤️', key: message.key }
-    // text: '' remove a reação
-})
-```
-
-### Deletar mensagem
-
 ```js
+await sock.sendMessage(jid, { react: { text: '❤️', key: message.key } })
 await sock.sendMessage(jid, { delete: message.key })
-```
-
-### Editar mensagem
-
-```js
+await sock.sendMessage(jid, { edit: message.key, text: 'Texto editado' })
+await sock.sendMessage(jid, { image: buffer, viewOnce: true })
+await sock.sendMessage(jid, { image: buffer, viewOnceV2: true })
+await sock.sendMessage(jid, { image: buffer, caption: '!', spoiler: true })
+await sock.sendMessage(jid, { image: buffer, groupStatus: true })
+await sock.sendMessage(jid, { image: buffer, ephemeral: true })
+await sock.sendMessage(jid, { sticker: buffer, isLottie: true })
+await sock.sendMessage(jid, { text: '@all', mentionAll: true })
 await sock.sendMessage(jid, {
-    edit: message.key,
-    text: 'Texto editado'
+    text: 'Confira!',
+    externalAdReply: {
+        title: 'Título', body: 'Descrição',
+        thumbnail: bufferImg, mediaType: 1,
+        sourceUrl: 'https://systemzone.store',
+        renderLargerThumbnail: true
+    }
 })
-```
-
-### Fixar mensagem
-
-```js
 await sock.sendMessage(jid, {
-    pin: {
-        type:       1,           // 1 = fixar, 2 = desfixar
-        time:       86400,       // duração em segundos
-        messageKey: message.key
-    }
+    poll: { name: 'Pergunta?', values: ['A', 'B', 'C'], selectableCount: 1 }
 })
-```
-
-### Encaminhar
-
-```js
 const { generateForwardMessageContent, generateWAMessageFromContent } = require('@systemzero/baileys')
-
-const content = generateForwardMessageContent(message, false)
-const msg     = generateWAMessageFromContent(jid, content, { quoted: m })
+const fwd = generateForwardMessageContent(message, false)
+const msg = generateWAMessageFromContent(jid, fwd, { quoted: m })
 await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
 ```
 
-### View Once
+---
+
+## 4. Botões e interativos
 
 ```js
-await sock.sendMessage(jid, { image: buffer, viewOnce: true })
+const { generateWAMessageFromContent, proto } = require('@systemzero/baileys')
 
-// V2
-await sock.sendMessage(jid, { image: buffer, viewOnceV2: true })
+const msg = generateWAMessageFromContent(jid, {
+    viewOnceMessage: {
+        message: {
+            interactiveMessage: proto.Message.InteractiveMessage.create({
+                header: { title: 'Título', hasMediaAttachment: false },
+                body:   { text: 'Texto' },
+                footer: { text: 'Rodapé' },
+                nativeFlowMessage: { buttons: [ /* tipos abaixo */ ] }
+            })
+        }
+    }
+}, { quoted: m })
 
-// V2 Extension
-await sock.sendMessage(jid, { image: buffer, viewOnceV2Extension: true })
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
 ```
 
-### Spoiler
-
 ```js
-await sock.sendMessage(jid, {
-    image:   buffer,
-    caption: 'Spoiler!',
-    spoiler: true
-})
+{ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: 'OK', id: 'ok' }) }
+{ name: 'cta_url',    buttonParamsJson: JSON.stringify({ display_text: 'Abrir', url: 'https://systemzone.store' }) }
+{ name: 'cta_copy',   buttonParamsJson: JSON.stringify({ display_text: 'Copiar', copy_code: 'CODIGO' }) }
+{ name: 'cta_call',   buttonParamsJson: JSON.stringify({ display_text: 'Ligar', phone_number: '5511999999999' }) }
+{
+    name: 'single_select',
+    buttonParamsJson: JSON.stringify({
+        title: 'Escolher',
+        sections: [{ title: 'Cat', rows: [{ header: 'Op1', title: 'Opção 1', description: 'Desc', id: 'op1' }] }]
+    })
+}
 ```
 
-### Status de grupo
+### Header com imagem + nativeFlow
 
 ```js
+// Use `caption`, não `text` — `text` faz a lib pular o bloco do header
 await sock.sendMessage(jid, {
-    image:       buffer,
-    caption:     'Status do grupo',
-    groupStatus: true
+    image:      { url: 'https://...' },
+    caption:    'Texto do card',
+    nativeFlow: [{ text: 'Botão', id: 'btn1' }]
 })
 ```
 
-### Mensagem efêmera
+### Carousel
 
 ```js
 await sock.sendMessage(jid, {
-    image:    buffer,
-    ephemeral: true
+    cards: [
+        { image: buffer1, caption: 'Card 1', nativeFlow: [{ text: 'Ver', id: 'c1' }] },
+        { image: buffer2, caption: 'Card 2', nativeFlow: [{ text: 'Ver', id: 'c2' }] },
+    ],
+    footer: 'Rodapé'
 })
 ```
 
-### Lottie (sticker animado especial)
+### Template Buttons / Sections
 
 ```js
 await sock.sendMessage(jid, {
-    sticker:  buffer,
-    isLottie: true
+    text: 'Escolha:',
+    templateButtons: [
+        { text: 'Resposta', id: 'r1' },
+        { text: 'Site', url: 'https://systemzone.store' },
+        { text: 'Ligar', call: '5511999999999' },
+    ]
 })
-```
 
-### Keep (salvar mensagem)
-
-```js
 await sock.sendMessage(jid, {
-    keep: message.key,
-    type: 1   // 1 = salvar, 2 = remover
+    text: 'Selecione', buttonText: 'Ver opções',
+    sections: [{ title: 'Cat', rows: [{ title: 'Item 1', description: 'Desc', id: 'i1' }] }]
 })
 ```
 
-### Evento
-
-```js
-await sock.sendMessage(jid, {
-    event: {
-        isCanceled:  false,
-        name:        'Reunião',
-        description: 'Alinhamento',
-        location:    { name: 'Sala 3', address: 'Rua X, 100' },
-        startTime:   Math.floor(Date.now() / 1000) + 3600,
-        endTime:     Math.floor(Date.now() / 1000) + 7200,
-    }
-})
-```
+---
 
-### Enquete
+## 5. Sticker Pack nativo
 
 ```js
 await sock.sendMessage(jid, {
-    poll: {
-        name:            'Qual seu time?',
-        values:          ['Flamengo', 'Corinthians', 'Palmeiras'],
-        selectableCount: 1   // 0 = múltipla escolha
-    }
+    cover:    bufferWebP,
+    stickers: [
+        { data: bufferWebP,  emojis: ['😂'] },
+        { data: bufferAnima, emojis: ['🔥'] },
+        { data: bufferPng,   emojis: ['✨'] },
+    ],
+    name:      'Nome do Pack',
+    publisher: 'Autor',
 })
 ```
 
-### Invoice (nota fiscal)
+`cover` e cada `stickers[].data` esperam **Buffer**. Máximo 60 figurinhas, até 1MB cada. Requer `sharp` ou `@napi-rs/image` para PNG.
 
-```js
-await sock.sendMessage(jid, {
-    image:       buffer,
-    invoiceNote: 'Pagamento pedido #1234'
-})
-```
+---
 
-### External Ad Reply
+## 6. Canais Newsletter
 
 ```js
-await sock.sendMessage(jid, {
-    text: 'Confira!',
-    externalAdReply: {
-        title:                 'System Zero',
-        body:                  'Descrição do produto',
-        thumbnail:             bufferImagem,
-        mediaType:             1,
-        sourceUrl:             'https://systemzone.store',
-        renderLargerThumbnail: true
-    }
-})
-```
-
-### Mention All
+await sock.sendMessage('120363...@newsletter', { text: 'Novidade!' })
 
-```js
-await sock.sendMessage(jid, {
-    text:       '👋 @all',
-    mentionAll: true
+const { generateWAMessage, generateMessageIDV2 } = require('@systemzero/baileys')
+const fullMsg = await generateWAMessage(canalJid, { image: buffer, caption: 'Legenda' }, {
+    upload: sock.waUploadToServer, userJid: sock.user.id,
+    messageId: generateMessageIDV2(sock.user.id),
 })
+await sock.relayMessage(canalJid, fullMsg.message, { messageId: fullMsg.key.id })
+
+const canal = await sock.newsletterCreate('Nome', 'Descrição')
+await sock.newsletterFollow(jid)
+await sock.newsletterUnfollow(jid)
+await sock.newsletterMute(jid)
+await sock.newsletterUnmute(jid)
+const meta = await sock.newsletterMetadata('jid', jid)
+await sock.newsletterUpdateName(jid, 'Novo Nome')
+await sock.newsletterUpdateDescription(jid, 'Nova descrição')
+await sock.newsletterUpdatePicture(jid, buffer)
+await sock.newsletterRemovePicture(jid)
+await sock.newsletterReactMessage(jid, serverId, '❤️')
+const msgs = await sock.newsletterFetchMessages(jid, 30, 0, 0)
+await sock.newsletterDelete(jid)
+const { subscribers } = await sock.newsletterSubscribers(jid)
 ```
 
-### Convite de pagamento
+---
+
+## 7. Enquetes com decrypt
 
 ```js
 await sock.sendMessage(jid, {
-    paymentInviteServiceType: 3
+    poll: { name: 'Pergunta?', values: ['A', 'B', 'C'], selectableCount: 1 }
 })
-```
 
-### Resultado de enquete (snapshot)
-
-```js
-await sock.sendMessage(jid, {
-    pollResult: {
-        name:     'Pergunta?',
-        pollType: 0,   // 0 = poll, 1 = quiz
-        votes: [
-            { name: 'Opção A', voteCount: 12 },
-            { name: 'Opção B', voteCount: 7 },
-        ]
+const { getAggregateVotesInPollMessage } = require('@systemzero/baileys/lib/Utils/messages.js')
+sock.ev.on('messages.update', async (updates) => {
+    for (const { key, update } of updates) {
+        if (!update.pollUpdates) continue
+        const pollMsg = await store.loadMessage(key.remoteJid, key.id)
+        if (!pollMsg?.message) continue
+        const result = getAggregateVotesInPollMessage({
+            message: pollMsg.message, pollUpdates: update.pollUpdates
+        })
+        // [{ name: 'A', voters: ['5511...@s.whatsapp.net'] }]
     }
 })
 ```
 
 ---
 
-## 4. Botões e interativos
-
-### Estrutura base
+## 8. AI Rich
 
 ```js
-const { generateWAMessageFromContent, proto } = require('@systemzero/baileys')
-
-const msg = generateWAMessageFromContent(jid, {
-    viewOnceMessage: {
-        message: {
-            interactiveMessage: proto.Message.InteractiveMessage.create({
-                header: { title: 'Título', hasMediaAttachment: false },
-                body:   { text: 'Texto do corpo' },
-                footer: { text: 'Rodapé' },
-                nativeFlowMessage: {
-                    buttons: [ /* tipos abaixo */ ]
-                }
-            })
-        }
-    }
-}, { quoted: m })
+await sock.sendRich(jid, [
+    sock.makeText('Acesse [nosso site](https://systemzone.store).'),
+    sock.makeCode('bash', 'npm i @systemzero/baileys'),
+    sock.makeTable([['Nome', 'Status'], ['Botões', '✅']]),
+    sock.makeList(['Item 1', 'Item 2']),
+], quotedMsg, ['RICH_RESPONSE_CODE', 'RICH_RESPONSE_TABLE'])
 
-await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
+await sock.sendRichText(jid, 'Texto com [link](https://systemzone.store)', quotedMsg)
+await sock.sendRichCode(jid, 'Título', 'javascript', 'const x = 1', quotedMsg)
+await sock.sendRichList(jid, 'Lista', ['A', 'B'], quotedMsg)
 ```
 
-### Tipos de botão
+---
 
-```js
-// Resposta rápida
-{ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: 'Confirmar', id: 'confirmar' }) }
+## 9. LID / JID — Sistema avançado
 
-// Link externo
-{ name: 'cta_url', buttonParamsJson: JSON.stringify({ display_text: 'Abrir', url: 'https://systemzone.store' }) }
+O WhatsApp usa dois tipos de identificador:
+- **JID** (`@s.whatsapp.net`) — baseado em número de telefone
+- **LID** (`@lid`) — identificador opaco sem número
 
-// Copiar texto
-{ name: 'cta_copy', buttonParamsJson: JSON.stringify({ display_text: 'Copiar código', copy_code: 'PROMO2025' }) }
+A partir da v1.0.6, a lib resolve automaticamente LID↔JID via `sharedLidPhoneCache`, inclusive ao buscar metadata de grupo (`groupMetadata`).
 
-// Ligar
-{ name: 'cta_call', buttonParamsJson: JSON.stringify({ display_text: 'Ligar', phone_number: '5511999999999' }) }
+```js
+const {
+    lidToJid, resolveJid, resolveAll, normalizeJid, validateJid,
+    getSenderInfo, sharedLidPhoneCache, isLidUser, isPnUser,
+    getBotJid, setBotMap
+} = require('@systemzero/baileys')
 
-// Webview interno
-{ name: 'cta_webview', buttonParamsJson: JSON.stringify({ title: 'Painel', url: 'https://systemzone.store' }) }
+const jid = lidToJid('123456@lid')
+const { jid, lid } = resolveAll('5511999999999@s.whatsapp.net')
+const { jid, lid, isGroup } = getSenderInfo(message)
 
-// Lista dropdown com seções
-{
-    name: 'single_select',
-    buttonParamsJson: JSON.stringify({
-        title: 'Escolher',
-        sections: [{
-            title: 'Categoria',
-            rows: [
-                { header: 'Op 1', title: 'Opção 1', description: 'Desc', id: 'op1' },
-                { header: 'Op 2', title: 'Opção 2', description: 'Desc', id: 'op2' },
-            ]
-        }]
-    })
-}
+normalizeJid('5511999999999')  // → '5511999999999@s.whatsapp.net'
+normalizeJid('123456@lid')     // → resolve via cache
+
+sharedLidPhoneCache.set('123456@lid', '5511999999999@s.whatsapp.net')
+const jid = sharedLidPhoneCache.getPhoneForLid('123456@lid')
+const lid = sharedLidPhoneCache.getLidForPhone('5511999999999@s.whatsapp.net')
+console.log('Cache size:', sharedLidPhoneCache.size)
 ```
 
-### Header com imagem
+> ⚠️ Identidades do próprio bot (`sock.user.id`/`.lid`) vêm com sufixo de dispositivo (`numero:N@dominio`). Pra comparar com `participants`, remova só o `:N` preservando o domínio: `jid.replace(/:\d+(?=@)/, '')` — **não use** `split(':')[0]`.
+
+---
 
-Upload da imagem antes de usar no header:
+## 10. Username (@usuario)
 
 ```js
-const { generateWAMessage, generateMessageIDV2 } = require('@systemzero/baileys')
+const { resolveUsername, isUsername } = require('@systemzero/baileys')
 
-const uploaded = await generateWAMessage(jid, { image: buffer }, {
-    upload:    sock.waUploadToServer,
-    userJid:   sock.user.id,
-    messageId: generateMessageIDV2(sock.user.id),
-})
-const img = uploaded.message?.imageMessage
-
-// No header:
-header: {
-    title:              '',
-    hasMediaAttachment: true,
-    imageMessage: {
-        url:               img.url,
-        mimetype:          img.mimetype,
-        fileSha256:        img.fileSha256,
-        fileLength:        img.fileLength,
-        mediaKey:          img.mediaKey,
-        fileEncSha256:     img.fileEncSha256,
-        directPath:        img.directPath,
-        mediaKeyTimestamp: img.mediaKeyTimestamp,
-        jpegThumbnail:     img.jpegThumbnail,
-    }
-}
+isUsername('@josue')   // true
+const jid = await resolveUsername('@josue', sock.onWhatsApp.bind(sock))
+if (jid) await sock.sendMessage(jid, { text: 'Olá!' })
 ```
 
-### Catálogo (product no header)
-
-```js
-header: {
-    title:              'Produto',
-    hasMediaAttachment: true,
-    productMessage:     proto.Message.ProductMessage.create({
-        product: proto.Message.ProductMessage.ProductSnapshot.create({
-            productImage:    proto.Message.ImageMessage.create({ ...img }),
-            productId:       'ID-001',
-            title:           'Nome do Produto',
-            description:     'Descrição completa',
-            currencyCode:    'BRL',
-            priceAmount1000: 29990,   // R$ 29,99
-            retailerId:      'minha-loja',
-            url:             'https://loja.com/produto',
-            productImageCount: 1,
-        }),
-        businessOwnerJid: sock.user.id
-    })
-}
-```
+---
 
-### Carousel
+## 11. MessageBuilder — Button, ButtonV2, Carousel, AIRich
 
 ```js
-await sock.sendMessage(jid, {
-    cards: [
-        {
-            image:      buffer1,
-            caption:    'Texto do card 1',
-            title:      'Card 1',
-            nativeFlow: [
-                { text: 'Ver mais', id: 'card1' },
-                { text: 'Site', url: 'https://systemzone.store' }
-            ]
-        },
-        {
-            image:      buffer2,
-            caption:    'Texto do card 2',
-            nativeFlow: [{ text: 'Clique', id: 'card2' }]
-        }
-    ],
-    footer: 'Rodapé'
-})
+const { Button, ButtonV2, Carousel, AIRich } = require('@systemzero/baileys/lib/MB.cjs')
+// O socket vai sempre no construtor: new ButtonV2(sock)
 ```
 
-### Template Buttons
+### ButtonV2
 
 ```js
-await sock.sendMessage(jid, {
-    text:            'Escolha:',
-    templateButtons: [
-        { text: 'Resposta', id:   'res1' },
-        { text: 'Site',     url:  'https://systemzone.store' },
-        { text: 'Ligar',    call: '5511999999999' },
-    ]
-})
+const msg = new ButtonV2(sock)
+msg.setTitle('Título'); msg.setBody('Corpo'); msg.setFooter('Rodapé')
+msg.setThumbnail('https://exemplo.com/imagem.jpg')
+msg.addButton('✅ Opção 1', 'opcao_1')
+msg.addButton('❌ Opção 2', 'opcao_2')
+await msg.send(jid, { quoted: m })
+// clique chega como m.body === 'opcao_1'
 ```
 
-### Sections (lista clássica)
+### Button (native flow)
 
 ```js
-await sock.sendMessage(jid, {
-    text:       'Selecione',
-    buttonText: 'Ver opções',
-    sections: [{
-        title: 'Categoria',
-        rows: [
-            { title: 'Item 1', description: 'Desc', id: 'item1' },
-            { title: 'Item 2', description: 'Desc', id: 'item2' },
-        ]
-    }]
-})
+const msg = new Button(sock)
+msg.addReply('✅ Confirmar', 'confirmar')
+msg.addUrl('🔗 Abrir', 'https://systemzone.store')
+msg.addCopy('📋 Copiar', 'PROMO2025')
+msg.addCall('📞 Ligar', '5511999999999')
+await msg.send(jid, { quoted: m })
 ```
 
-### Interactive como Template
+### Carousel
 
 ```js
-await sock.sendMessage(jid, {
-    nativeFlow: [{ text: 'Clique', id: 'btn' }],
-    text:       'Mensagem',
-    interactiveAsTemplate: true
-})
+const msg = new Carousel(sock)
+msg.setBody('Escolha:')
+msg.card(c => c.image('https://...').title('Card 1').text('Desc').button('Ver', 'c1'))
+msg.card(c => c.image('https://...').title('Card 2').text('Desc').button('Ver', 'c2'))
+await msg.send(jid, { quoted: m })
 ```
 
-### Botões com imagem no corpo (não no header)
+### AIRich
 
 ```js
-await sock.sendMessage(jid, {
-    image:   buffer,
-    caption: 'Escolha:',
-    buttons: [
-        { text: 'Opção 1', id: 'op1' },
-        { text: 'Link', url: 'https://systemzone.store' },
-    ]
-})
+const msg = new AIRich(sock)
+msg.addText('Acesse [System Zero](https://systemzone.store).')
+msg.addCode('javascript', `require('@systemzero/baileys')`)
+msg.addTable([['Comando', 'Desc'], ['!menu', 'Menu principal']])
+await msg.send(jid, { quoted: m })
 ```
 
-### Áudio no rodapé de interativo
+---
 
-```js
-await sock.sendMessage(jid, {
-    text:        'Ouça e escolha:',
-    nativeFlow:  [{ text: 'Opção', id: 'op' }],
-    audioFooter: bufferAudio
-})
-```
+## 12. Botões estendidos
 
----
+```js
+await sock.sendMessage(jid, { text: 'Mensagem', nativeFlow: [ /* botões */ ] })
 
-## 5. Sticker Pack nativo
+{ text: '⏰ Me lembre', reminder: 'lembrete_id' }
+{ text: '🔕 Cancelar', cancelReminder: 'lembrete_id' }
+{ text: '📍 Endereço', address: true }
+{ text: '📡 Localização', location: true }
+{ text: '🛍️ Catálogo', catalog: '5511999999999@s.whatsapp.net' }
+{ text: 'Copiar código', otp: '123456' }
+{ text: '📞 Ligar', phoneNumber: '5511999999999' }
+{ text: '🗑️ Limpar chat', clearChat: true }
+{ text: '🔗 Abrir', urlBtn: 'https://systemzone.store' }
+```
 
-Envia um pack de figurinhas que aparece na aba de stickers do WhatsApp, igual a um pack real.
+### isSystemNotification
 
 ```js
-await sock.sendMessage(jid, {
-    cover:    { url: 'https://exemplo.com/capa.webp' },
-    stickers: [
-        { data: buffer1,       emojis: ['😂'] },
-        { data: bufferAnimado, emojis: ['🔥', '💀'] },
-        { data: bufferPng,     emojis: ['🐱'] },    // PNG converte automaticamente
-    ],
-    name:        'Nome do Pack',
-    publisher:   'Autor',
-    description: 'Descrição opcional'
+sock.ev.on('messages.upsert', async ({ messages }) => {
+    const msg = messages[0]
+    if (msg.isSystemNotification) return
 })
 ```
 
-`cover` aceita `Buffer`, `{ url }` ou `{ stream }`. O mesmo vale para cada `sticker.data`.
-
-Limites: máximo **60 figurinhas** por pack, cada uma com até **1MB**.
-
-Requer `sharp` ou `@napi-rs/image` para conversão de PNG e geração de thumbnail. Sem eles, apenas WebP é aceito.
-
 ---
 
-## 6. Canais Newsletter
-
-### Enviar texto
+## 13. Grupos
 
 ```js
-await sock.sendMessage('120363...@newsletter', { text: 'Novidade!' })
+const meta  = await sock.groupMetadata(jid)
+const grupo = await sock.groupCreate('Nome', ['5511...@s.whatsapp.net'])
+await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'add')
+await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'remove')
+await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'promote')
+await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'demote')
+await sock.groupLeave(jid)
+await sock.groupUpdateSubject(jid, 'Novo Nome')
+await sock.groupUpdateDescription(jid, 'Nova descrição')
+const code = await sock.groupInviteCode(jid)
+await sock.groupRevokeInvite(jid)
+await sock.groupAcceptInvite('CODIGO')
+await sock.groupToggleEphemeral(jid, 86400)
+const grupos = await sock.groupFetchAllParticipating()
 ```
 
-### Enviar mídia
+---
 
-`sendMessage` não passa pelo `encodeNewsletterMessage` corretamente para mídia. Use sempre `generateWAMessage` + `relayMessage`:
+## 14. Perfil e privacidade
 
 ```js
-const { generateWAMessage, generateMessageIDV2 } = require('@systemzero/baileys')
+const url = await sock.profilePictureUrl(jid, 'image')
+await sock.updateProfilePicture(jid, buffer)
+await sock.updateProfileStatus('🤖 Bot ativo')
+const [result] = await sock.onWhatsApp('5511999999999')
+await sock.updateBlockStatus(jid, 'block')
+await sock.updateBlockStatus(jid, 'unblock')
+await sock.sendPresenceUpdate('composing', jid)
+await sock.sendPresenceUpdate('available', jid)
+await sock.presenceSubscribe(jid)
+await sock.readMessages([message.key])
+await sock.chatModify({ archive: true }, jid)
+await sock.chatModify({ pin: true }, jid)
+await sock.chatModify({ mute: 8 * 60 * 60 * 1000 }, jid)
+await sock.logout()
+```
 
-const canalJid = '120363...@newsletter'
+---
 
-const fullMsg = await generateWAMessage(canalJid, {
-    image:   buffer,
-    caption: 'Legenda'
-}, {
-    upload:    sock.waUploadToServer,
-    userJid:   sock.user.id,
-    messageId: generateMessageIDV2(sock.user.id),
-})
+## 15. Eventos do socket
 
-await sock.relayMessage(canalJid, fullMsg.message, {
-    messageId: fullMsg.key.id,
+```js
+sock.ev.on('messages.upsert',          ({ messages, type }) => {})
+sock.ev.on('messages.update',           (updates) => {})
+sock.ev.on('messages.delete',           (item) => {})
+sock.ev.on('messages.reaction',         (reactions) => {})
+sock.ev.on('messages.decrypt-failed',   (failInfo) => {}) // ver seção 20
+sock.ev.on('presence.update',           ({ id, presences }) => {})
+sock.ev.on('groups.update',             (updates) => {})
+sock.ev.on('group-participants.update', ({ id, participants, action }) => {})
+sock.ev.on('contacts.update',           (contacts) => {})
+sock.ev.on('connection.update',         ({ connection, lastDisconnect, qr }) => {})
+sock.ev.on('creds.update',              saveCreds)
+sock.ev.on('call', (calls) => {
+    for (const call of calls) {
+        if (call.status === 'offer') sock.rejectCall(call.id, call.from)
+    }
 })
 ```
 
-Funciona para `image`, `video`, `audio`, `sticker`, `document`.
+---
 
-### Gerenciar canais
+## 16. Utilitários
 
 ```js
-// Criar
-const canal = await sock.newsletterCreate('Nome do Canal', 'Descrição')
-
-// Seguir / deixar
-await sock.newsletterFollow(jid)
-await sock.newsletterUnfollow(jid)
-
-// Silenciar
-await sock.newsletterMute(jid)
-await sock.newsletterUnmute(jid)
-
-// Metadata
-const meta = await sock.newsletterMetadata('jid', jid)
-const meta = await sock.newsletterMetadata('invite', 'CODIGO')
+const { downloadMediaMessage } = require('@systemzero/baileys')
+const buffer = await downloadMediaMessage(message, 'buffer', {})
 
-// Atualizar
-await sock.newsletterUpdateName(jid, 'Novo Nome')
-await sock.newsletterUpdateDescription(jid, 'Nova descrição')
-await sock.newsletterUpdatePicture(jid, buffer)
-await sock.newsletterRemovePicture(jid)
+const { generateWAMessage, generateWAMessageFromContent, generateMessageIDV2 } = require('@systemzero/baileys')
+const { jidNormalizedUser, isJidGroup, isJidNewsletter, isLidUser, isPnUser } = require('@systemzero/baileys')
 
-// Reagir a mensagem
-await sock.newsletterReactMessage(jid, serverId, '❤️')
+// Detectar dispositivo — analisa o ID DA MENSAGEM, não o JID
+const { getDevice } = require('@systemzero/baileys')
+const device = getDevice(message.key.id) // 'android' | 'ios' | 'web' | 'unknown'
+```
 
-// Listar mensagens
-const msgs = await sock.newsletterFetchMessages(jid, 30, 0, 0)
+---
 
-// Admin
-const count    = await sock.newsletterAdminCount(jid)
-await sock.newsletterChangeOwner(jid, novoDonoJid)
-await sock.newsletterDemote(jid, usuarioJid)
-await sock.newsletterDelete(jid)
+## 17. Fixar / Desfixar mensagens
 
-// Seguidores
-const { subscribers } = await sock.newsletterSubscribers(jid)
+```js
+await sock.sendMessage(jid, { pin: quotedMsg.key, type: 1 }) // PIN_FOR_ALL
+await sock.sendMessage(jid, { pin: quotedMsg.key, type: 2 }) // UNPIN_FOR_ALL
 ```
 
 ---
 
-## 7. Enquetes com decrypt
-
-### Criar enquete
+## 18. Resolução de nomes (getName)
 
 ```js
-await sock.sendMessage(jid, {
-    poll: {
-        name:            'Pergunta?',
-        values:          ['A', 'B', 'C'],
-        selectableCount: 1   // 0 = múltipla escolha
-    }
-})
+const { getName } = require('@systemzero/baileys')
+const nome = getName(msg, contactStore)
+// Prioridade: contato salvo → verifiedName → pushName → @lid → telefone → "Usuário desconhecido"
 ```
 
-### Receber e descriptografar votos
+---
 
-No `connect.js`, após `saveCreds`:
+## 19. PTT real com qualquer formato
 
 ```js
-const { getAggregateVotesInPollMessage } = require('@systemzero/baileys/lib/Utils/messages.js')
+// Qualquer formato de entrada — a lib converte via ffmpeg automaticamente
+await sock.sendMessage(jid, { audio: { url: 'https://musica.mp3' }, ptt: true })
+```
 
-sock.ev.on('messages.update', async (updates) => {
-    for (const { key, update } of updates) {
-        if (!update.pollUpdates) continue
+A lib detecta a extensão real da fonte (não o `mimetype` declarado) e converte pra mono/16kHz opus quando necessário. Requer `ffmpeg` com `libopus`.
 
-        const pollMsg = await store.loadMessage(key.remoteJid, key.id)
-        if (!pollMsg?.message) continue
+---
 
-        const result = getAggregateVotesInPollMessage({
-            message:     pollMsg.message,
-            pollUpdates: update.pollUpdates,
-        })
+## 20. Guard de pagamento stealth (anti-fraude)
 
-        // [{ name: 'Opção A', voters: ['5511...@s.whatsapp.net'] }]
-        console.log(result)
+```js
+const { bindPaymentGuard } = require('@systemzero/baileys')
 
-        if (!global.pollResults) global.pollResults = {}
-        global.pollResults[key.id] = { options: result, jid: key.remoteJid }
+bindPaymentGuard(sock, {
+    isPaymentMessage: (webMessage) => { /* sua lógica */ },
+    recordEnvelope:  (webMessage, isPayment) => { /* seu registro */ },
+    treatDecryptFailureAsSuspicious: true,
+    onDetect: (detection) => {
+        // detection.type: 'direct' | 'edited' | 'undecryptable'
     }
 })
 ```
 
-O `getMessage` precisa estar configurado no `makeWASocket` (veja seção 1).
+| Caminho | Evento | Garantia |
+|---|---|---|
+| Mensagem direta | `messages.upsert` | Roda detector no conteúdo |
+| Mensagem editada | `messages.update` | Extrai `editedMessage` e roda detector |
+| Falha de decrypt | `messages.decrypt-failed` | Nunca ignora silenciosamente |
 
 ---
 
-## 8. AI Rich
-
-Mensagens com formatação avançada: markdown, código, tabelas, hyperlinks clicáveis no texto.
-
-### Direto pelo socket
+## 21. Bad MAC Handler — sessões Signal
 
 ```js
-// Texto com hyperlink
-await sock.sendRich(jid, [
-    sock.makeText('Acesse [nosso site](https://systemzone.store).')
-], quotedMsg)
-
-// Código
-await sock.sendRich(jid, [
-    sock.makeCode('bash', 'npm i @systemzero/baileys')
-], null, ['RICH_RESPONSE_CODE'])
+const { badMacHandler } = require('@systemzero/baileys')
 
-// Tabela
-await sock.sendRich(jid, [
-    sock.makeTable([
-        ['Nome',    'Status'],
-        ['Botões',  '✅'],
-        ['Canais',  '✅'],
-    ])
-], null, ['RICH_RESPONSE_TABLE'])
-
-// Lista
-await sock.sendRich(jid, [
-    sock.makeList(['Item 1', 'Item 2', 'Item 3'])
-])
-
-// Tudo junto
-await sock.sendRich(jid, [
-    sock.makeText('# Título\nConteúdo com [link](https://systemzone.store)'),
-    sock.makeCode('javascript', 'const x = require("@systemzero/baileys")'),
-    sock.makeTable([['Col A', 'Col B'], ['val1', 'val2']]),
-], quotedMsg, ['RICH_RESPONSE_CODE', 'RICH_RESPONSE_TABLE'])
+if (badMacHandler.isBadMacError(error)) {
+    badMacHandler.handleError(error, 'contexto')
+}
+badMacHandler.clearProblematicSessionFiles() // preserva creds.json
 ```
 
-### Atalhos
+---
+
+## 22. Resolução LID → telefone via grupo
 
 ```js
-await sock.sendRichText(jid, 'Texto com [link](https://systemzone.store)', quotedMsg)
-await sock.sendRichCode(jid, 'Título', 'javascript', 'console.log("hi")', quotedMsg)
-await sock.sendRichList(jid, 'Lista', ['A', 'B', 'C'], quotedMsg)
+const { resolveLidPhoneFromGroup } = require('@systemzero/baileys')
+const telefone = await resolveLidPhoneFromGroup(sock, groupJid, lid)
 ```
 
-### Usando a classe AIRich
+Força resolução de `@lid` → telefone via `groupMetadata` — útil quando o cache ainda não tem aquele par.
 
-```js
-const { AIRich } = require('@systemzero/baileys/lib/MB.cjs')
+---
 
-const msg = new AIRich(sock)
-msg.addText('Texto com [link](https://systemzone.store)')
-msg.addCode('javascript', 'const x = 1')
-msg.addTable([['Col', 'Valor'], ['linha', 'dado']])
-await msg.send(jid, { quoted: m })
+## 23. Versão do WhatsApp sempre atualizada
+
+```js
+const { getBestWaVersion } = require('@systemzero/baileys')
+const { version, isLatest, source } = await getBestWaVersion()
+// tenta web.whatsapp.com → GitHub → fallback fixo (avisando explicitamente)
 ```
 
 ---
 
-## 9. Grupos
+## 24. WhatsApp Flows — Formulários interativos
+
+> Requer `flow_id` aprovado no Meta Business Manager.
 
 ```js
-// Criar
-const grupo = await sock.groupCreate('Nome', ['5511...@s.whatsapp.net'])
+const { generateWAMessageFromContent } = require('@systemzero/baileys')
 
-// Participantes
-await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'add')
-await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'remove')
-await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'promote')
-await sock.groupParticipantsUpdate(jid, ['5511...@s.whatsapp.net'], 'demote')
+const formMsg = generateWAMessageFromContent(jid, {
+    viewOnceMessage: {
+        message: {
+            messageContextInfo: { deviceListMetadata: {}, deviceListMetadataVersion: 2 },
+            interactiveMessage: {
+                body: { text: 'Preencha seus dados.' },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'galaxy_message',
+                        buttonParamsJson: JSON.stringify({
+                            flow_message_version: '4',
+                            flow_id: 'SEU_FLOW_ID',
+                            flow_action_payload: {
+                                screen: 'contact_details',
+                                data: { full_name_visible: true, email_visible: true }
+                            },
+                            flow_cta: '__localize:FLOWS_SIGN_UP_BUTTON_TITLE',
+                            flow_action: 'navigate',
+                            flow_token: 'T0ZGRVJfU0lHTlVQ'
+                        })
+                    }],
+                    messageParamsJson: '{}'
+                }
+            }
+        }
+    }
+}, { userJid: sock.user.id })
 
-// Sair
-await sock.groupLeave(jid)
+await sock.relayMessage(jid, formMsg.message, { messageId: formMsg.key.id })
+```
 
-// Nome e descrição
-await sock.groupUpdateSubject(jid, 'Novo Nome')
-await sock.groupUpdateDescription(jid, 'Nova descrição')
+### Recebendo a resposta
 
-// Convite
-const code = await sock.groupInviteCode(jid)
-await sock.groupRevokeInvite(jid)
-await sock.groupAcceptInvite('CODIGO')
+```js
+sock.ev.on('messages.upsert', async ({ messages }) => {
+    const m = messages[0]
+    const nfr = m.message?.interactiveResponseMessage?.nativeFlowResponseMessage
+    if (nfr?.name !== 'galaxy_message' || !nfr?.paramsJson) return
 
-// Mensagens efêmeras (0 = desativar)
-await sock.groupToggleEphemeral(jid, 86400)
+    const parsed   = JSON.parse(nfr.paramsJson)
+    if (!parsed.wa_flow_response_params) return
 
-// Metadata
-const meta   = await sock.groupMetadata(jid)
-const grupos = await sock.groupFetchAllParticipating()
+    const flowId  = parsed.wa_flow_response_params.flow_id
+    const screens = JSON.parse(parsed.wa_flow_response_params.response_message).screens || []
+
+    const campos = {}
+    for (const screen of screens) {
+        for (const comp of (screen.components || [])) {
+            if (comp.name && comp.value !== undefined && comp.value !== '')
+                campos[comp.name] = comp.value
+        }
+    }
+
+    if (flowId === 'SEU_FLOW_ID') {
+        let resposta = 'Formulário recebido!\n\n'
+        if (campos.full_name) resposta += `Nome: ${campos.full_name}\n`
+        if (campos.email)     resposta += `Email: ${campos.email}\n`
+        await sock.sendMessage(m.key.remoteJid, { text: resposta }, { quoted: m })
+    }
+})
 ```
 
 ---
 
-## 10. Perfil e privacidade
+## 25. Mensagens agendadas
+
+Sistema de agendamento em memória. Auto-inicia o timer quando há mensagens na fila, auto-para quando a fila esvazia.
 
 ```js
-// Foto de perfil
-const url = await sock.profilePictureUrl(jid, 'image')
-await sock.updateProfilePicture(jid, buffer)
+const { createMessageScheduler } = require('@systemzero/baileys')
 
-// Bio
-await sock.updateProfileStatus('🤖 Bot ativo')
+const scheduler = createMessageScheduler(
+    (jid, content) => sock.sendMessage(jid, content),
+    {
+        onSent:   (s, msg) => console.log(`Enviado pra ${s.jid} — ID: ${s.id}`),
+        onFailed: (s, err) => console.error(`Falhou: ${err.message}`)
+    }
+)
 
-// Verificar número
-const [result] = await sock.onWhatsApp('5511999999999')
-// { exists: true, jid: '5511...@s.whatsapp.net' }
+// Agendar para data/hora específica
+const entry = scheduler.schedule(
+    '5511999999999@s.whatsapp.net',
+    { text: 'Feliz Aniversário! 🎂' },
+    new Date('2026-12-25T09:00:00')
+)
+console.log('Agendado com ID:', entry.id)
 
-// Bloquear / desbloquear
-await sock.updateBlockStatus(jid, 'block')
-await sock.updateBlockStatus(jid, 'unblock')
+// Agendar com delay (30 minutos)
+scheduler.scheduleDelay(jid, { text: 'Lembrete!' }, 30 * 60 * 1000)
 
-// Presence
-await sock.sendPresenceUpdate('composing', jid)    // digitando
-await sock.sendPresenceUpdate('recording', jid)    // gravando
-await sock.sendPresenceUpdate('available', jid)    // online
-await sock.sendPresenceUpdate('unavailable')        // offline
-await sock.presenceSubscribe(jid)                   // receber presence de contato
+// Agendar qualquer tipo de mensagem
+scheduler.schedule(groupJid, {
+    image: { url: './promo.jpg' },
+    caption: 'Promoção de fim de semana!'
+}, new Date('2026-12-20T08:00:00'))
 
-// Marcar como lido
-await sock.readMessages([message.key])
+// Cancelar um agendamento
+scheduler.cancel(entry.id)
 
-// Privacidade da foto
-await sock.updateProfilePicturePrivacy('all')    // 'all' | 'contacts' | 'none'
+// Cancelar todos de um JID
+scheduler.cancelForJid(jid)
 
-// Modificar chat
-await sock.chatModify({ archive: true }, jid)
-await sock.chatModify({ pin: true }, jid)
-await sock.chatModify({ mute: 8 * 60 * 60 * 1000 }, jid)
-await sock.chatModify({ star: { messages: [{ id, fromMe }], star: true } }, jid)
-await sock.chatModify({ clear: { messages: [{ id, fromMe, timestamp }] } }, jid)
+// Ver pendentes
+const pendentes = scheduler.getPending()
 
-// Desconectar
-await sock.logout()
+// Parar/retomar
+scheduler.stop()
+scheduler.start()
+
+// Limpar tudo
+scheduler.clearAll()
+```
+
+**Objeto retornado:**
+```js
+{
+    id:            'sched_1782000000000_a3f2b1',
+    jid:           '5511...@s.whatsapp.net',
+    content:       { text: '...' },
+    scheduledTime: Date,
+    createdAt:     Date,
+    status:        'pending' | 'sent' | 'failed' | 'cancelled',
+    messageId:     '...',  // preenchido após envio
+    error:         '...'   // preenchido em caso de falha
+}
 ```
 
 ---
 
-## 11. Eventos do socket
+## 26. Status em grupo (GroupStatusMessageV2)
+
+Posta conteúdo como status dentro de um grupo — texto, imagem, vídeo ou áudio. Suporta modo **Close Friends** (apenas amigos próximos), usando o mesmo mecanismo do status nativo do WhatsApp.
 
 ```js
-sock.ev.on('messages.upsert',         ({ messages, type }) => {})
-sock.ev.on('messages.update',          (updates) => {})
-sock.ev.on('messages.delete',          (item) => {})
-sock.ev.on('messages.reaction',        (reactions) => {})
-sock.ev.on('presence.update',          ({ id, presences }) => {})
-sock.ev.on('groups.update',            (updates) => {})
-sock.ev.on('group-participants.update', ({ id, participants, action }) => {})
-sock.ev.on('contacts.update',          (contacts) => {})
-sock.ev.on('chats.update',             (chats) => {})
-sock.ev.on('connection.update',        ({ connection, lastDisconnect, qr }) => {})
-sock.ev.on('creds.update',             saveCreds)
+const { generateWAMessageFromContent, prepareWAMessageMedia, downloadMediaMessage } = require('@systemzero/baileys')
+const crypto = require('crypto')
 
-// Chamadas
-sock.ev.on('call', (calls) => {
-    for (const call of calls) {
-        if (call.status === 'offer') {
-            sock.rejectCall(call.id, call.from)
+// ── Texto para todos do grupo ────────────────────────────────────────────────
+const messageSecret = crypto.randomBytes(32)
+
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            extendedTextMessage: {
+                text: 'Olá, grupo! 👋',
+                contextInfo: { isGroupStatus: true }
+            },
+            messageContextInfo: { messageSecret }
         }
     }
-})
+}, {})
+
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
 ```
 
----
+```js
+// ── Texto apenas para Amigos Próximos (Close Friends) ────────────────────────
+const messageSecret = crypto.randomBytes(32)
 
-## 12. Utilitários
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            extendedTextMessage: {
+                text: 'Só pra você que é chegado 🤫',
+                contextInfo: {
+                    isGroupStatus: true,
+                    statusAudienceMetadata: { audienceType: 1 } // 1 = Close Friends
+                }
+            },
+            messageContextInfo: { messageSecret }
+        }
+    }
+}, {})
 
-### Download de mídia
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
+```
 
 ```js
-const { downloadMediaMessage } = require('@systemzero/baileys')
+// ── Imagem para todos do grupo ───────────────────────────────────────────────
+const messageSecret = crypto.randomBytes(32)
 
-const buffer = await downloadMediaMessage(message, 'buffer', {})
-const stream = await downloadMediaMessage(message, 'stream', {})
-```
+const prep = await prepareWAMessageMedia(
+    { image: buffer },
+    { upload: sock.waUploadToServer }
+)
 
-### Download manual por stream
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            imageMessage: {
+                ...prep.imageMessage,
+                caption:    'Legenda da imagem',
+                contextInfo: { isGroupStatus: true }
+            },
+            messageContextInfo: { messageSecret }
+        }
+    }
+}, {})
+
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
+```
 
 ```js
-const { downloadContentFromMessage } = require('@systemzero/baileys')
+// ── Imagem apenas para Amigos Próximos ───────────────────────────────────────
+const messageSecret = crypto.randomBytes(32)
 
-const stream = await downloadContentFromMessage(
-    { mediaKey, directPath, url },
-    'image'   // 'image' | 'video' | 'audio' | 'sticker' | 'document'
+const prep = await prepareWAMessageMedia(
+    { image: buffer },
+    { upload: sock.waUploadToServer }
 )
-const chunks = []
-for await (const chunk of stream) chunks.push(chunk)
-const buffer = Buffer.concat(chunks)
-```
 
-### Geração de mensagem manual
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            imageMessage: {
+                ...prep.imageMessage,
+                caption:    'Só pra chegados 🤫',
+                contextInfo: {
+                    isGroupStatus: true,
+                    statusAudienceMetadata: { audienceType: 1 }
+                }
+            },
+            messageContextInfo: { messageSecret }
+        }
+    }
+}, {})
+
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
+```
 
 ```js
-const {
-    generateWAMessage,
-    generateWAMessageFromContent,
-    generateMessageIDV2,
-    generateForwardMessageContent
-} = require('@systemzero/baileys')
+// ── Vídeo ─────────────────────────────────────────────────────────────────────
+const messageSecret = crypto.randomBytes(32)
 
-// Com upload automático de mídia
-const msg = await generateWAMessage(jid, { image: buffer }, {
-    upload:    sock.waUploadToServer,
-    userJid:   sock.user.id,
-    messageId: generateMessageIDV2(sock.user.id),
-})
+const prep = await prepareWAMessageMedia(
+    { video: buffer },
+    { upload: sock.waUploadToServer }
+)
 
-// Sem upload (proto manual)
-const msg = generateWAMessageFromContent(jid, { ... }, { quoted: m })
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            videoMessage: {
+                ...prep.videoMessage,
+                caption:    'Legenda do vídeo',
+                contextInfo: { isGroupStatus: true }
+            },
+            messageContextInfo: { messageSecret }
+        }
+    }
+}, {})
 
-// Enviar o proto
 await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
 ```
 
-### Detectar dispositivo
-
 ```js
-const { getDevice } = require('@systemzero/baileys')
-const device = getDevice(message.key.id)
-// 'android' | 'ios' | 'web' | 'unknown'
-```
+// ── Áudio ─────────────────────────────────────────────────────────────────────
+const messageSecret = crypto.randomBytes(32)
 
-### JID utils
+const prep = await prepareWAMessageMedia(
+    { audio: buffer, mimetype: 'audio/mp4' },
+    { upload: sock.waUploadToServer }
+)
 
-```js
-const {
-    jidNormalizedUser,
-    isJidGroup,
-    isJidNewsletter,
-    jidEncode,
-    jidDecode
-} = require('@systemzero/baileys')
+const msg = generateWAMessageFromContent(jid, {
+    messageContextInfo: { messageSecret },
+    groupStatusMessageV2: {
+        message: {
+            audioMessage: {
+                ...prep.audioMessage,
+                contextInfo: { isGroupStatus: true }
+            },
+            messageContextInfo: { messageSecret }
+        }
+    }
+}, {})
 
-jidNormalizedUser('5511999999999@s.whatsapp.net')
-isJidGroup('120363...@g.us')            // true
-isJidNewsletter('120363...@newsletter') // true
+await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
 ```
 
+**Pontos importantes:**
+- `messageSecret` deve ser um `Buffer` de 32 bytes gerado com `crypto.randomBytes(32)` — cada postagem precisa de um novo secret
+- `audienceType: 1` ativa o modo Close Friends; omitir `statusAudienceMetadata` posta para todos do grupo
+- Para repostar uma mensagem citada (quoted), baixe a mídia com `downloadMediaMessage` antes de fazer o `prepareWAMessageMedia`
+- O `groupStatus: true` no `sendMessage` simples (seção 3) existe como atalho, mas para controle de Close Friends e repost de mídias, use o `groupStatusMessageV2` direto como mostrado acima
+
+---
+
+## Changelog
+
+### v1.0.7
+- **Fix PTT real** — `ptt: true` converte via `ffmpeg` antes do upload; corrigido bug `Cannot use 'in' operator to search for 'stream'` (caminho do arquivo transcrito era passado como string crua em vez de `{ url }`)
+- **Fix 403 / conexão** — `lidDbMigrated` no login agora reflete o estado real das credenciais; companion version usa a versão real do WA; `"forbidden"` mapeado corretamente pra `DisconnectReason.forbidden`
+- **Mensagens agendadas** — `MessageScheduler` / `createMessageScheduler` portado de innovatorssoft/baileys
+- **PreKey recovery melhorado** — upload de 30 chaves (era 5), delay de 2500ms (era 1000ms), parâmetro `force` pra ignorar `MIN_UPLOAD_INTERVAL` em recuperação de erro
+- **Fix groupMetadata → sharedLidPhoneCache** — pares LID↔telefone agora registrados automaticamente ao buscar metadata de grupo
+- Guard de pagamento stealth, Bad MAC Handler, getName, getBestWaVersion, resolveLidPhoneFromGroup, WhatsApp Flows
+
+### v1.0.6
+- Sistema LID/JID avançado com cache bidirecional (`sharedLidPhoneCache`)
+- `lidToJid`, `resolveJid`, `resolveAll`, `normalizeJid`, `validateJid`, `getSenderInfo`
+- Suporte a `@username` — `isUsername`, `resolveUsername`
+- Botões estendidos (20+ tipos via `nativeFlow`)
+- Fix canal newsletter, fix groupStatus audio, `isSystemNotification`
+
+### v1.0.5
+- Sticker Pack nativo com animadas e PNG
+- Album, Spoiler, ViewOnce V2, Ephemeral, Lottie, Evento
+- Native Flow, Carousel, Template Buttons
+- AI Rich (makeText, makeCode, makeTable, makeList, sendRich)
+- Poll decrypt com `getAggregateVotesInPollMessage`
+- MessageBuilder (`Button`, `ButtonV2`, `Carousel`, `AIRich`)
+
 ---
 
 <div align="center">
 
-**@systemzero/baileys v1.0.5**
+**@systemzero/baileys v1.0.7**
 
 Desenvolvido por [Josué </>](https://t.me/blackhzx) · [Canal WhatsApp](https://whatsapp.com/channel/0029VaqUb9aGk1FxqeKKOd2i) · [systemzone.store](https://systemzone.store)