@fer2809fl/baileys 7.0.4 → 7.0.5

package/README.md

@@ -16,68 +16,117 @@
 
 ---
 
-## 🆕 Novedades — v7.0.3
+## 🆕 Novedades — v7.0.5
 
-Actualización de estabilidad y sincronización con las últimas mejoras del protocolo de WhatsApp Web.
+**La actualización más completa hasta ahora.** Se revisó el fork "beta" del proyecto en busca de utilidades que este repo todavía no tenía, se portaron una por una (evitando duplicar nombres ya existentes) y se hizo una auditoría de código de punta a punta — no solo del README.
 
-### ✅ Nuevas funciones añadidas
-- **`withUsernameProtocol()`** en `USyncQuery` — permite sincronizar contactos por *username* de WhatsApp (la nueva forma de identificar cuentas, además del número de teléfono):
+### 🔧 Mantenimiento y correcciones
+- **`messages-send.js`** — se corrigió un caso donde el nodo `biz` (usado por los botones nativos) podía duplicarse dentro del stanza si ya venía agregado por otra parte del mensaje; ahora se verifica que no exista antes de agregarlo.
+- **Auditoría completa de `lib/`**, archivo por archivo contra el fork beta: no faltaba ninguna función real, solo faltaban algunos exports y tipos, ya corregidos.
+- **Exports arreglados** — `Utils/reporting-utils.js` y `Utils/companion-reg-client-utils.js` existían en el código pero no se exportaban bien desde el paquete; quien instalaba `@fer2809fl/baileys` no podía importar sus funciones. Ya se puede.
+- **Tipos de TypeScript agregados** para los 9 módulos que solo venían en JavaScript — `anti-ban`, `smart-reconnect`, `message-queue`, `enhanced-cache`, `enhanced-logger`, `bot-utils`, `banner`, `rich-message-utils` y `use-sqlite-auth-state` — verificados con `tsc`. Ahora tienen autocompletado y chequeo de tipos.
+- **Limpieza de marca** en `banner.js` y `enhanced-logger.js` (traían branding del proyecto original de donde se portó el código).
+- En general: se optimizó y se prolijaron varios detalles sueltos de código y documentación que quedaron de fusiones anteriores.
+
+Se documentaron además funciones que ya existían en el código pero no tenían ejemplo de uso: tablas, bloques de código, carruseles, álbumes y canales/newsletters (ver secciones nuevas más abajo).
+
+Próximas tandas (se irán agregando poco a poco): documentación de Grupos avanzados, Comunidades, Negocios, Perfil/Privacidad, Estados (stories) y Eventos.
+
+### 🆕 Protocolo actualizado + funciones nuevas de chat
+- **Versión de WhatsApp Web actualizada** a `2.3000.1047406223` (la más reciente confirmada al momento de esta actualización), reduciendo el riesgo de rechazo de conexión por versión vieja.
+- **Nuevas funciones de chat** (no existían ni en este fork ni en el beta — son de cosecha propia esta vez): atajos simples para las operaciones de chat más comunes, en vez de tener que armar el objeto de `chatModify` a mano:
   ```javascript
-  const result = await sock.executeUSyncQuery(
-    new USyncQuery().withUsernameProtocol().withUser(new USyncUser().withPhone('+123...'))
-  )
+  await sock.pinChat(jid)              // fijar chat
+  await sock.pinChat(jid, false)       // desfijar
+  await sock.archiveChat(jid)          // archivar
+  await sock.archiveChat(jid, false)   // desarchivar
+  await sock.muteChat(jid, Date.now() + 8 * 60 * 60 * 1000) // silenciar 8 horas
+  await sock.muteChat(jid)             // quitar silencio
+  await sock.markChatRead(jid)         // marcar como leído
+  await sock.markChatUnread(jid)       // marcar como no leído
+  await sock.clearChat(jid)            // vaciar el historial del chat
+  await sock.deleteChat(jid)           // eliminar el chat de la lista
+  ```
+  Todas usan por debajo el mismo `chatModify` de siempre (mismo protocolo, mismos parches de estado), solo que ahora no hay que recordar la forma exacta del objeto `mod`.
+- **Fijar un mensaje dentro del chat** (`pinInChatMessage`) — esta ya existía en el código pero no estaba documentada:
+  ```javascript
+  // Fijar el mensaje citado por 24 horas (86400 segundos)
+  await sock.sendMessage(jid, { pin: quotedMsg.key, type: 1, time: 86400 })
+  // Desfijar
+  await sock.sendMessage(jid, { pin: quotedMsg.key, type: 2 })
   ```
-- **`sock.fetchAccountReachoutTimelock()`** — consulta si tu cuenta tiene alguna restricción activa para iniciar chats nuevos, y hasta cuándo dura.
-- **`sock.fetchNewChatMessageCap()`** — consulta el límite de mensajes que puedes enviar a chats/números nuevos (cupo anti-spam de WhatsApp).
-- **`sock.registerSocketEndHandler(handler)`** — registra una función que se ejecuta automáticamente cada vez que la conexión se cierra (útil para limpieza de recursos propios sin tener que escuchar `connection.update` a mano).
-- **Nuevo formato de código QR de emparejamiento** — el QR ahora incluye el identificador de plataforma del companion, igual que el WhatsApp Web oficial (mejora la tasa de éxito al vincular).
-
-### 🐛 Correcciones de estabilidad y memoria
-- **Fuga de memoria en el buffer de eventos** — se agregó limpieza real de timers, cachés y listeners al cerrar una conexión (`ev.destroy()`), evitando que la memoria crezca con reconexiones frecuentes.
-- **Loop de reintentos por fallas de descifrado (MAC)** — se agregó detección de colisión de "base key" en reintentos de mensajes: si WhatsApp reenvía el mismo mensaje repetidamente por un fallo de sesión, la librería ahora detecta el patrón y fuerza una sesión nueva en vez de reintentar indefinidamente.
-- **Duplicados al sincronizar historial de grupos** — se corrigió el merge de "participantes que salieron" (`pastParticipants`) para no duplicar entradas cuando WhatsApp envía el historial en varios paquetes.
-- **IDs de consulta de canales (newsletters) desactualizados** — los IDs internos de `FOLLOW`/`UNFOLLOW` de canales estaban vencidos y podían empezar a fallar silenciosamente; se actualizaron a los vigentes.
-- **Versión de protocolo de WhatsApp Web actualizada** — reduce el riesgo de desconexiones forzadas por versión obsoleta.
-- **Dependencias actualizadas**: `libsignal` ahora se instala desde npm (antes requería `git` instalado en el servidor), `whatsapp-rust-bridge`, `protobufjs` y otras al día.
-
-> Nota: las funciones de auto-follow de canales, el motor de envío de mensajes (`sendMessage` y helpers internos) y el manejo avanzado de negocios (`business.js`) son personalizaciones propias de este fork — se mantuvieron intactas durante esta actualización.
-
-### 🔧 Fusión profunda adicional
-- **`chats.js` reconstruido sobre la base oficial**: recuperación automática de sincronización de estado cuando falta una clave (antes fallaba silenciosamente), resolución correcta de bloqueo de contactos por LID/PN, y tracking de finalización de sincronización de historial.
-- **`groups.js` reconstruido**: mejor resolución de LID/PN en metadata de grupos + tus funciones `isGroupAdmin`, `getGroupAdmins`, `resolveParticipantJid`, `groupMetadataCached` intactas.
-- **`business.js` alineado al oficial** (era funcionalmente idéntico, solo cambiaba el estilo del código).
-- **Endpoint de canales actualizado**: WhatsApp movió `newsletterFollow`/`newsletterUnfollow` a un endpoint nuevo (`_v2`); se actualizó, incluyendo tu sistema de auto-follow interno, para que siga funcionando.
 
----
+### ✅ Nuevas funciones añadidas
 
+**Anti-Ban** (`Utils/anti-ban.js`)
+- `randomDelay`, `messageDelay`, `typingDelay` — retrasos aleatorios "humanizados" antes de enviar.
+- `RateLimiter`, `globalRateLimiter`, `groupRateLimiter`, `broadcastRateLimiter` — limitadores de tasa listos para usar por chat/grupo/difusión.
+- `PresenceManager`, `generateSessionFingerprint`, `isValidJid`, `sanitizeMessage` — utilidades de apoyo para reducir el riesgo de baneo por comportamiento de bot.
 
+**Reconexión inteligente** (`Utils/smart-reconnect.js`)
+- `SmartReconnect`, `createConnectionHandler`, `withRetry` — backoff exponencial con jitter y detección de causas de desconexión recuperables vs definitivas.
 
-### ✅ Nuevas funciones añadidas
-- **Detección de admins y resolución de JID/LID 100% nativa** — Antes, cada bot tenía que reimplementar a mano la comparación de `jid`, `@lid` y número de teléfono contra `groupMetadata` para saber si alguien es admin. Ahora esa lógica vive directamente en el socket:
-  - `isGroupAdmin(chatId, jid)` — `true`/`false` si ese participante (venga como número o como `@lid`) es admin o superadmin del grupo.
-  - `getGroupAdmins(chatId)` — lista de admins del grupo, ya resueltos a su jid de número de teléfono real (nunca `@lid`).
-  - `resolveParticipantJid(chatIdOrParticipants, jid)` — convierte cualquier `@lid` a su número real. Primero busca en los participantes del grupo; si no encuentra coincidencia, usa el mapeo LID↔PN nativo de WhatsApp (`signalRepository.lidMapping`) en vez de adivinar.
-  - `groupMetadataCached(chatId)` — igual que `groupMetadata`, pero con cache de 30s que se invalida solo apenas hay un alta, baja, ascenso o descenso real de participantes (via `group-participants.update`), para no golpear a WhatsApp en cada mensaje.
+**Cola de mensajes** (`Utils/message-queue.js`)
+- `MessageQueue`, `createMessageQueue` — colas con prioridad (`PRIORITY.CRITICAL` a `PRIORITY.BACKGROUND`) y control de tasa por tipo de contenido.
 
-  Esto es lo mismo que antes hacían los bots "a mano" con `groupMetadata` + comparaciones manuales de `id`/`lid`/`phoneNumber`, pero ahora resuelto por la librería, con cache y con el mapeo oficial de WhatsApp como respaldo.
+**Caché mejorada** (`Utils/enhanced-cache.js`)
+- `EnhancedCache`, `CacheManager` — caché en memoria con TTL/stale-TTL basada en `lru-cache`, con snapshot a disco.
 
----
+**Logger mejorado** (`Utils/enhanced-logger.js`)
+- `createLogger`, `RyzeLogger` — logger con niveles, colores en consola e iconos por categoría (no reemplaza tu logger `pino` existente, es una alternativa opcional).
 
-## 🆕 Novedades — v7.0.1
+**Mensajes programados** (`Utils/scheduled-messages.js`)
+```javascript
+import { startScheduler, scheduleMessage, recurringMessage } from '@fer2809fl/baileys'
 
-### ✅ Nuevas funciones añadidas
-- **Botones nativos reales** — Se agregaron métodos directos en el socket para enviar botones interactivos de WhatsApp (native flow), reemplazando el viejo formato `buttons: [{text, id}]` que ya no renderiza en WhatsApp:
-  - `sendQuickReplyButtons` — Botones de respuesta rápida
-  - `sendUrlButton` — Botón que abre un enlace
-  - `sendCallButton` — Botón para iniciar una llamada
-  - `sendCopyButton` — Botón que copia texto al portapapeles
-  - `sendReminderButton` — Botón de recordatorio
-  - `sendListButton` — Menú desplegable con secciones y filas
-  - `sendMixedButtons` — Combinación libre de varios tipos en un solo mensaje
-- **Previsualización automática de links** — `sendLinkPreview` y todos los botones de arriba arman solos la tarjeta grande (imagen + título + descripción) de cualquier URL que detecten en el texto, con el mismo motor que usa WhatsApp para los links normales.
-
-### 🐛 Correcciones
-- **Error en macOS** — Se reparó un bug crítico que impedía iniciar sesión correctamente en dispositivos Mac. El proceso de pairing/QR ahora funciona de forma estable en macOS.
+startScheduler(sock) // arranca el scheduler una vez tengas el sock conectado
+
+// una sola vez, en una fecha exacta
+scheduleMessage('123@s.whatsapp.net', { text: 'Recordatorio' }, Date.now() + 60_000)
+
+// recurrente con cron simple: "MIN HOUR DOM MON DOW"
+recurringMessage('123@s.whatsapp.net', { text: 'Buenos días' }, '0 9 * * *')
+```
+También: `cancelScheduledMessage`, `deleteScheduledMessage`, `listScheduledMessages`, `getScheduledMessage`, `updateScheduledMessage`, `getSchedulerStats`. Persiste en `database/scheduled-messages.json`.
+
+**Utilidades de LID** (`Utils/lid-utils.js`)
+- `isLid`, `lidToJid`, `resolveAnyLidToJid`, `resolveParticipant`, `getParticipantJid(s)`, `cacheParticipantLids`, `findParticipantByNumber`, entre otras — resolución y cacheo de `@lid` ↔ número real con persistencia en `database/lid-cache.json`. Complementa (no reemplaza) la resolución de admins/JID-LID nativa que ya tenía este fork desde v1.10.0.
+
+**Utilidades para bots** (`Utils/bot-utils.js`)
+- `parseCommand(text, prefix)` — parseo de comandos con flags (`--flag=valor`) y argumentos.
+- `CooldownManager`, `PermissionManager` (owners/admins/baneados/premium).
+- `extractMentions`, `extractQuotedMessage`, `isGroupAdmin`, `isBotAdmin`, `formatPhoneNumber`, `parseTime('10m')`, `formatDuration(ms)`, `sendFast(sock, jid, contenido)`.
+
+**Auth state en SQLite** (`Utils/use-sqlite-auth-state.js`)
+```javascript
+import { useSqliteAuthState } from '@fer2809fl/baileys'
+const { state, saveCreds } = await useSqliteAuthState({ dbPath: './auth.db' })
+```
+Requiere `better-sqlite3` (peer dependency opcional: `npm i better-sqlite3`).
+
+**Banner de inicio** (`Utils/banner.js`) — `printBanner()` opcional para mostrar un logo ASCII al arrancar el bot.
+
+**AI Rich Response — helpers de bajo nivel** (`Utils/rich-message-utils.js`)
+- `prepareRichResponseMessage(contenido)` — arma un `AIRichResponseMessage` completo (texto + código + tabla + links) en un solo llamado, incluyendo la firma/certificado de `botMetadata`.
+- `toUnified`, `wrapToBotForwardedMessage`, `botMetadataSignature`, `botMetadataCertificate` — piezas internas reutilizables si armas tus propios mensajes enriquecidos.
+- Se ampliaron los lenguajes soportados para resaltado de código en `LANGUAGE_KEYWORDS` (`Utils/rich-messages.js`): ahora incluye `rust`, `c`, `cpp`/`c++`, `csharp`/`c#`, `html` y `css`, además de los que ya tenías.
+
+**Builder "Modded"** (`Modded/message_builder.js`) — clases con API encadenable para armar botones, carruseles y respuestas AI-Rich sin construir el objeto a mano: `Button`, `ButtonV2`, `Carousel`, `AIRich`, `ORich`, `Toolkit`. *(Este archivo trae una nota de autoría de su creador original — se mantuvo intacta tal cual, junto con los términos: uso libre para proyectos propios, pero no puede revenderse ni redistribuirse como librería independiente.)*
+
+**VoIP — llamadas de voz** (`VoIP/`) — cliente experimental de llamadas de voz de WhatsApp sobre el motor WASM oficial:
+```javascript
+import { VoipClient, CallState } from '@fer2809fl/baileys'
+
+const voip = new VoipClient(sock)
+const call = await voip.call('123@s.whatsapp.net')
+call.on('stateChange', (state) => console.log(CallState[state]))
+```
+Incluye `ActiveCall`, manejo de señalización, y el binario WASM necesario (`lib/assets/wasm/`). Es una función pesada y experimental: úsala solo si tu bot realmente necesita hacer/recibir llamadas.
+
+### 📌 Notas finales
+- Se revisó cuidadosamente cada función nueva contra el código ya existente para no pisar ni duplicar exports (por ejemplo, `BufferJSON` y los tipos de resaltado de código se reutilizan de los archivos que ya tenías, en vez de crear una segunda copia).
+- Las funciones marcadas arriba con ejemplo de código ya están 100% cableadas y listas para usar; el resto se documentará con más ejemplos en la próxima revisión.
+- Los archivos `anti-ban.js`, `smart-reconnect.js`, `message-queue.js`, `enhanced-cache.js`, `enhanced-logger.js`, `bot-utils.js`, `banner.js`, `rich-message-utils.js` y `use-sqlite-auth-state.js` se distribuyen por ahora solo en JavaScript (igual que en el fork de origen); los tipos de TypeScript para estos módulos llegarán en una futura actualización.
 
 ---
 
@@ -412,6 +461,253 @@ export default handler
 
 ---
 
+## 🌐 HTML embebido en WhatsApp *(nuevo en v7.1.0)*
+
+WhatsApp expone un renderer HTML interno (diseñado originalmente para Meta AI)
+accesible vía el campo opaco `unifiedResponse.data` de `AIRichResponseMessage`.
+Cuando el JSON embebido contiene un `__typename: "GenAIaeacdsnwHtmlPrimitive"`,
+el cliente levanta un **WebView sandboxed dentro del bocadillo del mensaje** y
+renderiza el HTML+JS indicado en `payload`, con permiso de red limitado a los
+dominios listados en `trusted_sources`.
+
+Este fork expone esa capacidad como API de primer nivel:
+
+### `sock.sendHtml` — envía un WebView dentro del chat
+
+```javascript
+await sock.sendHtml(
+  jid,
+  html,                  // string con <style>, <body>, <script>
+  trustedSources,        // ["api.tuyo.com"]  ← dominios permitidos para fetch
+  quoted,                // mensaje a responder (opcional)
+  { headerText, footer } // opciones (opcional)
+)
+```
+
+O construí el mensaje por tu cuenta con `generateHtmlContent` (exportado desde
+`@nyxthor-dev/baileys`) y mandalo con `relayMessage` si querés más control.
+
+### Ejemplo mínimo
+
+```javascript
+const html = `
+  <body style="margin:0;font-family:sans-serif">
+    <h1 style="color:#a3e635">¡Hola desde el WebView!</h1>
+    <p>Esto se renderiza dentro del bocadillo de WhatsApp.</p>
+  </body>
+`;
+await sock.sendHtml(jid, html, [], msg);
+```
+
+### ⚠️ Limitaciones estructurales (importante)
+
+El WebView tiene 4 restricciones que **no se pueden evitar desde el lado del
+HTML**. El patrón recomendado para resolverlas es mover la lógica a un backend
+HTTP (ver `examples/html-dynamic/` para un demo completo):
+
+| Limitación | Qué NO hacer | Patrón recomendado |
+|---|---|---|
+| El WebView es efímero: `localStorage` a menudo se borra al cerrar el chat | Confiar en `localStorage` como única persistencia | Mover la persistencia a un backend HTTP en `trusted_sources` |
+| No existe puente HTML → bot (`window.WhatsApp.postMessage` no existe) | Esperar callbacks automáticos al bot | El HTML hace `fetch` a tu API, y tu API llama `sock.sendMessage(...)` |
+| `fetch()` solo anda hacia dominios listados en `trusted_sources` | Hacer `fetch` a dominios arbitrarios | Listar todos los dominios necesarios al llamar `sendHtml` |
+| El HTML no recibe identidad del usuario automáticamente | Generar el mismo HTML para todos los usuarios | Inyectar `window.__INITIAL__ = { jid, token, ... }` al renderizar |
+
+### Patrón dinámico con estado persistente
+
+```javascript
+// En tu comando del bot:
+const best = await db.scores.get(senderJid);          // 1. leer estado
+const token = issueJwt(senderJid, { expiresIn: '5m' }); // 2. firmar identidad
+
+let html = readFileSync('game.html', 'utf8');
+const init = JSON.stringify({ jid: senderJid, best, token, apiBase });
+html = html.replace('</body>',
+  `<script>window.__INITIAL__ = ${init};</script></body>`);
+
+await sock.sendHtml(jid, html, ['api.tuyo.com'], msg, {
+  headerText: '🎮 Mini-juego con estado persistente',
+});
+```
+
+```javascript
+// Dentro del HTML (game.html):
+async function saveScore(score) {
+  await fetch(INIT.apiBase + '/score', {
+    method: 'POST',
+    headers: { 'Authorization': 'Bearer ' + INIT.token,
+               'Content-Type': 'application/json' },
+    body: JSON.stringify({ score })
+  });
+}
+```
+
+```javascript
+// En tu backend (Express):
+app.post('/score', authMiddleware, async (req, res) => {
+  const { jid } = verifyJwt(req.headers.authorization);  // <- identidad del JWT
+  const { score } = req.body;
+  await db.query('INSERT INTO scores ... ON CONFLICT ...', [jid, score]);
+  res.json({ ok: true });
+});
+```
+
+Ver **`examples/html-dynamic/`** para un demo completo y funcional con SQLite.
+
+### Anti-patrones (qué NO hacer)
+
+- ❌ Usar `forwardOrigin = META_AI` para broadcast masivo — riesgo de ban.
+- ❌ Enviar HTML > 50KB — puede truncarse.
+- ❌ Confiar en `localStorage` para persistencia entre sesiones.
+- ❌ Hacer `fetch` a dominios fuera de `trusted_sources`.
+- ❌ Generar HTML sin identidad de usuario (no sabrás quién interactúa).
+- ❌ Exponer tokens en texto plano dentro del HTML sin expiración corta.
+
+### ⚠️ Advertencias
+
+- Esta capacidad **no es oficial** y **no está documentada** por Meta. Puede
+  romperse en cualquier update del cliente de WhatsApp.
+- El renderer depende de `forwardOrigin = META_AI` + `forwardedAiBotMessageInfo`,
+  que es una **impersonación** de un mensaje de Meta AI. Usalo en chats propios
+  o privados, no en broadcast.
+- Probá siempre en Android, iOS y WhatsApp Web — los tres WebViews tienen
+  comportamientos distintos.
+
+---
+
+## 📊 Mensajes Enriquecidos (Tablas, Código, Links, LaTeX)
+
+Estas funciones ya vienen integradas en el fork (heredadas de la fusión con el fork beta) — aquí quedan documentadas con ejemplos reales.
+
+```javascript
+// Tabla (formato clásico)
+await sock.sendTable(
+  jid,
+  'Precios',
+  ['Producto', 'Precio'],
+  [['Plan A', '$10'], ['Plan B', '$20']],
+  quotedMsg,
+  { headerText: 'Nuestros planes', footer: 'Precios en USD' }
+)
+
+// Tabla V2 (respuesta unificada tipo "AI Rich")
+await sock.sendTableV2(jid, tablaObjeto, quotedMsg, { title: 'Precios' })
+
+// Lista simple
+await sock.sendList(jid, 'Tareas', ['Comprar pan', 'Pagar luz'], quotedMsg)
+
+// Bloque de código
+await sock.sendCodeBlock(jid, 'console.log("hola")', quotedMsg, {
+  language: 'javascript',
+  title: 'Ejemplo'
+})
+
+// Bloque de código V2 (unified response)
+await sock.sendCodeBlockV2(jid, 'SELECT * FROM users;', quotedMsg, { language: 'sql' })
+
+// Texto con links enriquecidos (embeds inline)
+await sock.sendLink(jid, 'Mira esto: ', [
+  { url: 'https://github.com/Fer2809fl/Bail', displayName: 'Repo en GitHub' }
+], quotedMsg)
+
+// LaTeX (fórmulas)
+await sock.sendLatex(quotedMsg, { formula: 'E = mc^2' })
+```
+
+## 🎠 Carruseles y 🖼️ Álbumes
+
+**Carrusel** — se envía como un `interactiveMessage` con `carouselMessage`, cada tarjeta puede llevar imagen/video y sus propios botones nativos:
+
+```javascript
+await sock.sendMessage(jid, {
+  interactiveMessage: {
+    body: { text: 'Elegí un producto' },
+    footer: { text: 'Catálogo 2026' },
+    carouselMessage: {
+      cards: [
+        {
+          header: { title: 'Producto 1', imageMessage: 'https://.../foto1.jpg' },
+          body: { text: 'Descripción del producto 1' },
+          nativeFlowMessage: { buttons: [/* botones nativos, ver sección de Botones */] }
+        },
+        {
+          header: { title: 'Producto 2', videoMessage: 'https://.../video2.mp4' },
+          body: { text: 'Descripción del producto 2' }
+        }
+      ]
+    }
+  }
+})
+```
+
+**Álbum** — varias imágenes/videos agrupados en un mismo "paquete" visual (como el álbum nativo de WhatsApp):
+
+```javascript
+await sock.sendMessage(jid, {
+  album: [
+    { image: { url: './foto1.jpg' }, caption: 'Foto 1' },
+    { image: { url: './foto2.jpg' } },
+    { video: { url: './video1.mp4' } }
+  ]
+})
+```
+
+> Ambas funciones viven en `Socket/dugong.js` (el despachador interno que detecta el tipo de contenido especial que le mandás a `sock.sendMessage`) y ya estaban portadas desde la fusión con el fork beta — lo que faltaba era este ejemplo en el README.
+
+---
+
+## 📰 Newsletters / Canales
+
+Todo el manejo de canales (newsletters) de WhatsApp ya está integrado en `Socket/newsletter.js`. Resumen de las funciones disponibles en `sock`:
+
+```javascript
+// Crear un canal
+const canal = await sock.newsletterCreate('Mi Canal', 'Descripción del canal')
+
+// Seguir / dejar de seguir / silenciar / activar notificaciones
+await sock.newsletterAction(jid, 'follow')     // seguir
+await sock.newsletterAction(jid, 'unfollow')   // dejar de seguir
+await sock.newsletterAction(jid, 'mute')       // silenciar
+await sock.newsletterAction(jid, 'unmute')     // reactivar notificaciones
+
+// Seguir varios canales de una (separados por espacio en un solo string)
+await sock.newsletterMultipleFollow('120363...@newsletter 120363...@newsletter')
+
+// Ver todos los canales a los que estás suscrito
+const misCanales = await sock.newsletterFetchAllSubscribe()
+
+// Obtener metadata de un canal por su JID o por su código de invitación
+const meta = await sock.newsletterMetadata('invite', 'codigoDeInvitacion')
+// o, a partir de un link https://whatsapp.com/channel/xxxx o wa.me/channel/xxxx:
+const metaPorLink = await sock.cekIDSaluran('https://whatsapp.com/channel/xxxxxxxx')
+
+// Editar (nombre, descripción, foto)
+await sock.newsletterUpdateName(jid, 'Nuevo nombre')
+await sock.newsletterUpdateDescription(jid, 'Nueva descripción')
+await sock.newsletterUpdatePicture(jid, fotoBuffer)
+await sock.newsletterRemovePicture(jid)
+
+// Administración
+await sock.newsletterSubscribers(jid)          // cantidad/lista de suscriptores
+await sock.newsletterAdminCount(jid)           // cantidad de admins
+await sock.newsletterChangeOwner(jid, nuevoOwnerJid)
+await sock.newsletterDemote(jid, userJid)
+await sock.newsletterDelete(jid)
+
+// Mensajes del canal
+await sock.newsletterFetchMessages(jid, 20)    // últimos 20 mensajes
+await sock.newsletterReactMessage(jid, serverId, '❤️')
+```
+
+**Enviar un mensaje a un canal** es igual que a cualquier chat, usando el JID del canal (termina en `@newsletter`):
+
+```javascript
+await sock.sendMessage(canalJid, { text: 'Novedades de hoy 🎉' })
+```
+
+> Nota de mantenimiento (heredada de v7.0.4): WhatsApp movió los endpoints internos de `follow`/`unfollow` a una versión `_v2`; este fork ya usa los IDs de consulta vigentes, así que el seguimiento de canales no debería fallar por IDs vencidos.
+
+---
+
 ## ✨ Características
 
 ### General
@@ -419,6 +715,7 @@ export default handler
 - 📸 Mensajes multimedia (imágenes, video, audio, documentos)
 - 🔘 **Botones nativos reales, sin imports sueltos** *(v1.9.0)*
 - 🖼️ **Previsualización automática de links en botones y mensajes** *(v1.9.0)*
+- 🌐 **HTML embebido en WhatsApp con `sock.sendHtml`** *(v7.1.0)* — WebView sandboxed dentro del bocadillo, con patrón documentado para sitios dinámicos + BD
 - 👥 Soporte para grupos y chats privados
 
 ### Técnicas

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from "../../WAProto/index.js";
 import { makeLibSignalRepository } from "../Signal/libsignal.js";
 import { Browsers } from "../Utils/browser-utils.js";
 import logger from "../Utils/logger.js";
-const version = [2, 3000, 1043857760];
+const version = [2, 3000, 1047406223];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = "https://web.whatsapp.com";
 export const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";