@codexverified/baileys 2.10.11 → 2.11.12

package/README.md

@@ -1,52 +1,79 @@
 # @codexverified/baileys
 
-> A premium Baileys package built and maintained by Codex.
-
-`@codexverified/baileys` is a Node.js and TypeScript library for building WhatsApp integrations over the Baileys protocol. It provides a familiar socket-based API together with media handling, authentication helpers, newsletter operations, interactive messages, rich content utilities, and account-management features.
-
-The project is developed and maintained by **Codex** with an emphasis on readable source code, explicit behavior, maintainable interfaces,and practical production use.
-
-## Project Status
+[![npm version](https://img.shields.io/npm/v/@codexverified/baileys.svg)](https://www.npmjs.com/package/@codexverified/baileys)
+[![node](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](#at-a-glance)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](#license-and-maintenance)
+[![types](https://img.shields.io/badge/types-included-blue)](#at-a-glance)
+
+> A readable, carefully maintained Baileys distribution for building reliable WhatsApp integrations with codexverified/baileys.
+
+`@codexverified/baileys` is a Node.js and TypeScript library for creating WhatsApp automations over the Baileys protocol. It provides a socket-oriented API for authentication, messaging, media, interactive content, rich responses, newsletters, groups, communities, business features, account utilities, and carefully documented extensions.
+
+The package is maintained by **Codex** under the **CodexVerified** organization. It is intended for developers who want a practical Baileys foundation with familiar interfaces, public TypeScript declarations, readable source code, explicit behavior, and room for carefully tested improvements.
+
+## Table of contents
+
+- [At a glance](#at-a-glance)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [CommonJS usage](#commonjs-usage)
+- [Core capabilities](#core-capabilities)
+- [Everyday message usage](#everyday-message-usage)
+- [Rich menu example](#rich-menu-example)
+- [Status, grids, tables, and flows](#status-grids-tables-and-flows)
+- [Authentication and deployment guidance](#authentication-and-deployment-guidance)
+- [Development workflow](#development-workflow)
+- [Recent compatibility updates](#recent-compatibility-updates)
+- [About Codex](#about-codex)
+- [Package layout](#package-layout)
+- [Security and responsible use](#security-and-responsible-use)
+- [License and maintenance](#license-and-maintenance)
+- [Compatibility additions](#compatibility-additions)
+- [Comparison references](#comparison-references)
+- [Additional functional compatibility helpers](#additional-functional-compatibility-helpers)
+- [AI generation primitive](#ai-generation-primitive)
+
+## At a glance
 
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.10.11` |
+| Version | `2.11.12` |
 | Runtime | Node.js 20 or newer |
-| Module format | ESM with CommonJS compatibility where supported |
-| Type declarations | Included |
-| License | MIT |
+| Module format | ESM, with CommonJS compatibility where supported |
+| Type declarations | Included at `lib/index.d.ts` |
+| License | MIT, as declared by the package metadata |
 | Maintainer | Codex |
+| Entry point | `lib/index.js` |
+| Repository | `https://github.com/codexverified/baileys` |
 
 ## Installation
 
-Install the published package when it is available in the npm registry:
+| Method | Command | Notes |
+| --- | --- | --- |
+| From npm | `npm install @codexverified/baileys` | Standard install when published under your organization |
+| From local archive | `npm install ./codex-baileys-2.11.12.tgz` | Place the `.tgz` beside your application |
+| Source audit (no scripts) | `npm install --ignore-scripts` | Skips install hooks for local review |
 
-```bash
-npm install @codexverified/baileys
-```
-
-To install the current local build from the provided archive, place `codex-baileys-2.10.11.tgz` in your project directory and run:
+Both npm and archive installs use the same import name:
 
-```bash
-npm install ./codex-baileys-2.10.11.tgz
+```javascript
+import { makeWASocket } from '@codexverified/baileys'
 ```
 
-The local archive installs under the package name `@codexverified/baileys`, so application imports remain the same in both cases.
-
-## Quick Start
+## Quick start
 
-The following example creates a socket, persists authentication credentials, and reconnects after an unexpected connection close.
+The following example creates a socket, stores multi-file authentication credentials, reconnects after an unexpected disconnect, and replies to incoming messages. Keep the session directory private and never commit it to a public repository.
 
 ```javascript
 import {
+  DisconnectReason,
   makeWASocket,
-  useMultiFileAuthState,
-  DisconnectReason
+  useMultiFileAuthState
 } from '@codexverified/baileys'
 import P from 'pino'
 
-const start = async () => {
+async function start() {
   const { state, saveCreds } = await useMultiFileAuthState('./session')
 
   const sock = makeWASocket({
@@ -58,14 +85,12 @@ const start = async () => {
 
   sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
     if (connection === 'open') {
-      console.log('Connected using @codexverified/baileys')
+      console.log('Connected with @codexverified/baileys')
     }
 
     if (connection === 'close') {
       const statusCode = lastDisconnect?.error?.output?.statusCode
-      const shouldReconnect = statusCode !== DisconnectReason.loggedOut
-
-      if (shouldReconnect) {
+      if (statusCode !== DisconnectReason.loggedOut) {
         start().catch(console.error)
       }
     }
@@ -85,9 +110,7 @@ const start = async () => {
 start().catch(console.error)
 ```
 
-## CommonJS Usage
-
-For supported Node.js versions, the package can also be loaded through CommonJS:
+## CommonJS usage
 
 ```javascript
 const {
@@ -96,162 +119,140 @@ const {
 } = require('@codexverified/baileys')
 ```
 
-## Core Capabilities
+If your runtime or bundler does not support this interop path, use the ESM import form instead.
 
-The package includes the following major capabilities:
+## Core capabilities
 
-| Area | Included functionality |
+| Area | What it covers |
 | --- | --- |
-| Connections | WebSocket connection handling, reconnect support, connection events, pairing codes, and browser identity configuration |
-| Authentication | Multi-file, single-file, SQLite, and cache-manager authentication helpers |
-| Messages | Text, mentions, reactions, edits, deletes, forwards, replies, polls, contacts, locations, events, and group invites |
-| Media | Images, videos, audio, documents, stickers, albums, thumbnails, HD media processing, and GIF playback |
-| Interactive content | Buttons, lists, native flows, carousels, templates, and other interactive message structures |
-| Rich content | Code blocks, tables, inline entities, LaTeX content, link previews, and rich response utilities |
-| Groups | Group creation, participant management, settings, metadata, invites, communities, and labels |
-| Newsletters | Channel information, subscribers, following, unfollowing, posts, reactions, media, and polls |
-| Account features | Profiles, business information, privacy controls, usernames, interoperation, and account layers |
-| Storage | In-memory stores, ordered dictionaries, cache-manager stores, and persistent authentication storage |
-
-## Sending Messages
-
-A basic text message can be sent with `sendMessage`:
+| Connections & authentication | WebSocket connection events, reconnect handling, browser identity configuration, pairing-code flows, connection state transitions |
+| Auth persistence | Multi-file credentials, single-file state, SQLite-backed persistence (optional driver), cache-manager integrations |
+| Messages & conversations | Text, mentions, replies, reactions, edits, deletions, forwards, polls, contacts, locations, events, group invitations, quoted messages, disappearing messages, view-once envelopes |
+| Media & albums | Images, video, audio, documents, stickers, thumbnails, albums; sourced from URLs, local files, or buffers; optional `sharp` / `@napi-rs/image` / `jimp` image processing; GIF-style video playback |
+| Interactive content | Buttons, lists, native flows, hydrated templates, carousel layouts, button grids |
+| Rich content & previews | Code blocks, tables, inline entities, LaTeX-oriented content, link previews, structured response arrays |
+| Rich menus (experimental) | Header image, row/carousel cards, stable button IDs, toast metadata, disclaimers, footer action |
+| Groups & communities | Group creation, participant management, settings, metadata, invites, labels, community/subgroup relationships |
+| Newsletters & channels | Channel metadata, follow/unfollow, posts, reactions, media, polls |
+| Account, business & privacy | Profile/business helpers, product & catalog operations, privacy controls, username utilities, status publishing, favorites management |
+| Storage & protocol utilities | In-memory and ordered-dictionary stores, cache-manager support, LID/phone-number resolution, event utilities, message normalization, media retry handling, TypeScript declarations |
+
+## Everyday message usage
+
+| Message type | Key options | Example |
+| --- | --- | --- |
+| Text | `text` | `sock.sendMessage(jid, { text: '...' })` |
+| Media with caption | `image` / `video` / `audio` / `document`, `caption` | `sock.sendMessage(jid, { image: { url } , caption: '...' })` |
+| GIF-style video | `video`, `gifPlayback: true` | `sock.sendMessage(jid, { video: { url }, gifPlayback: true })` |
+| View-once media | `viewOnce: true` (also `viewOnceV2`, `viewOnceV2Extension`, `spoiler`) | `sock.sendMessage(jid, { image: { url }, viewOnce: true })` |
+| Spoiler / view-once (new) | `mediaSpoilerMode: 'viewOnce' \| 'native'` | see below |
 
 ```javascript
 await sock.sendMessage(jid, {
-  text: 'Your message text'
+  text: 'A message from Codex'
 })
-```
-
-A media message can be sent from a local file, URL, or buffer depending on the upload configuration:
 
-```javascript
 await sock.sendMessage(jid, {
-  image: { url: './image.jpg' },
-  caption: 'A caption from Codex'
+  image: { url: './media/photo.jpg' },
+  caption: 'A photo message'
 })
-```
 
-A video can be delivered with GIF playback enabled:
-
-```javascript
 await sock.sendMessage(jid, {
-  video: { url: './animation.mp4' },
+  video: { url: './media/animation.mp4' },
   gifPlayback: true,
   caption: 'Animated media'
 })
-```
-
-## Authentication
-
-The recommended authentication helper is `useMultiFileAuthState`:
-
-```javascript
-import { useMultiFileAuthState } from '@codexverified/baileys'
-
-const { state, saveCreds } = await useMultiFileAuthState('./session')
-```
 
-Authentication data contains sensitive account credentials. Keep the session directory private, exclude it from version control, and do not upload it to public repositories.
-
-## Explicit Newsletter Following
-
-The package does not automatically follow trusted channels, subscribe to fallback channels, or inject a fallback channel identifier into media messages. Newsletter following is consumer-controlled and must be requested explicitly:
-
-```javascript
 await sock.sendMessage(jid, {
-  followMe: true,
-  channelId: '123456789@newsletter',
-  count: 'once'
+  image: { url: './media/private-image.jpg' },
+  caption: 'Open once',
+  viewOnce: true
 })
-```
-
-Applications should validate channel identifiers before sending requests and should only follow channels when the behavior is clearly intended by the application owner and its users.
-
-## Media Attribution
-
-Generated image and video messages do not receive an automatic newsletter annotation or channel pill. If an application intentionally needs message context, it should provide that context explicitly through the supported message options rather than relying on hidden defaults.
-
-## CODEX Branding
-
-The package displays the following startup identity when a socket is created:
-
-```text
-CODEX TECHNOLOGY
-A premium Baileys developed and built by codex
-```
-
-Generated message identifiers use the `CODEX` marker. This branding is informational and does not change the WhatsApp protocol or the message transport format.
-
-## CODEX Rich Menu and Interactive Helpers
 
-The following helpers are available on a socket created with `makeWASocket`. They use the existing message relay and do not change the normal `sendMessage` behavior.
-
-### Spoiler media
-
-Use `spoiler: true` when sending supported media. The WhatsApp client controls the visual spoiler and download presentation.
-
-```javascript
 await sock.sendMessage(jid, {
   video: { url: './media/clip.mp4' },
-  caption: 'Spoiler media',
-  spoiler: true
+  caption: 'View-once video',
+  mediaSpoilerMode: 'viewOnce'
+})
+
+await sock.sendMessage(jid, {
+  image: { url: './media/hidden-preview.jpg' },
+  mediaSpoilerMode: 'native'
 })
 ```
 
-### Experimental Gen4 rich menu
+`mediaSpoilerMode` is an additional, opt-in path for supported image, video, document, or sticker media:
 
-`richMenu` creates a Meta AI-style rich-response card with a header, optional image, card sections, stable button IDs, optional toast metadata, disclaimers, carousel or row layout, and a footer URL or image. Buttons may be strings or objects. String buttons receive generated tool IDs; object buttons preserve their supplied `id`. Set `body.carousel: true` for horizontal carousel layout, or leave it false for row layout. On some WhatsApp versions, a button tap may arrive as ordinary message text or through another interactive response envelope, so receiving code should handle both the ID and visible label.
+| Value | Effect |
+| --- | --- |
+| `viewOnce` | Wraps supported media in a view-once envelope |
+| `native` | Applies the native spoiler context flag |
+
+The existing `viewOnce`, `viewOnceV2`, `viewOnceV2Extension`, and `spoiler` options remain supported and take precedence over `mediaSpoilerMode` when explicitly set.
+
+## Rich menu example
 
 ```javascript
 await sock.richMenu(jid, {
   header: {
-    title: 'Rich Menu',
-    image: { url: 'https://example.com/menu.jpg', mime_type: 'image/jpeg' }
+    title: 'Codex Menu',
+    image: {
+      url: 'https://example.com/menu.jpg',
+      mime_type: 'image/jpeg'
+    }
   },
   body: {
     row: true,
     carousel: false,
-    cards: [{
-      title: 'Menu 1',
-      toast: 'Menu 1 selected',
-      buttons: ['menu2', 'menu3', 'rich3']
-    }, {
-      title: 'Menu 2',
-      buttons: [
-        { id: 'test', text: 'test', toast: 'Test selected' },
-        { id: 'me', label: 'me' },
-        { id: 'rich2', text: 'rich2' }
-      ]
-    }]
+    cards: [
+      {
+        title: 'Account',
+        buttons: [
+          { id: 'profile', text: 'Profile' },
+          { id: 'settings', text: 'Settings' }
+        ]
+      },
+      {
+        title: 'Support',
+        buttons: ['help', 'contact']
+      }
+    ]
   },
   footer: {
-    text: 'Telegram channel',
-    url: 'https://t.me/example',
-    image: { url: 'https://example.com/footer.jpg', mime_type: 'image/jpeg' }
+    text: 'Codex Technology',
+    url: 'https://example.com'
   }
 })
 ```
 
-### Status, button grids, tables, and Flows
+| Rich menu field | Purpose |
+| --- | --- |
+| `header` | Optional title and image shown above the menu |
+| `body.row` / `body.carousel` | Layout mode for the cards |
+| `body.cards` | Rows of stable button IDs and labels |
+| `footer` | Text plus an optional action URL |
+
+## Status, grids, tables, and flows
+
+| Helper | Purpose |
+| --- | --- |
+| `sendStatus` | Post a status update, optionally with mentions via `statusJidList` |
+| `sendRichButtonGrid` | Send a card grid of stable-ID buttons |
+| `sendInteractiveTable` | Send tabular content with headers, rows, and action buttons |
+| `sendWhatsAppFlow` | Launch a published WhatsApp Flow |
 
 ```javascript
-await sock.sendStatus({ text: 'New status' }, {
+await sock.sendStatus({ text: 'New Codex status' }, {
   statusJidList: ['1234567890@s.whatsapp.net']
 })
 
-await sock.sendStatusMentions({ text: 'Mentioned status' }, [
-  '1234567890@s.whatsapp.net',
-  '9876543210@s.whatsapp.net'
-])
-
 await sock.sendRichButtonGrid(jid, {
   text: 'Choose an option',
   cards: [{
     title: 'Actions',
     buttons: [
-      { id: 'action_one', text: 'Action one' },
-      { id: 'action_two', text: 'Action two' }
+      { id: 'first_action', text: 'First action' },
+      { id: 'second_action', text: 'Second action' }
     ]
   }]
 })
@@ -274,53 +275,178 @@ await sock.sendWhatsAppFlow(jid, {
 })
 ```
 
-These helpers and the rich-menu format are client-dependent experimental features. Use stable IDs and test the receiving message normalization on the WhatsApp versions used by your application.
+These helpers are protocol- and client-dependent. Use graceful fallbacks when an application serves a wide range of WhatsApp client versions.
+
+## Authentication and deployment guidance
 
-## Development
+| Practice | Detail |
+| --- | --- |
+| Session privacy | Keep the session directory private and excluded from version control |
+| Access control | Use a dedicated service account or restricted filesystem permissions where possible |
+| Secrets handling | Do not place access tokens, private keys, phone numbers, or personal account data in the README, package archive, or a public repository |
+| Dependency pinning | Pin dependencies with a lockfile for production deployments |
+| Runtime | Use a supported Node.js runtime |
+| Connection handling | Monitor connection events; handle logout separately from recoverable disconnects; avoid uncontrolled parallel sockets on reconnect |
 
-Clone or extract the source archive, then install the package dependencies in the project directory:
+## Development workflow
 
 ```bash
-npm install --ignore-scripts
+npm test
 ```
 
-Run the package test command with:
+Before submitting changes, validate ESM syntax, CommonJS compatibility where applicable, generated protocol files, and the declarations in `lib/index.d.ts`. Keep package metadata, exports, runtime requirements, and documentation synchronized. When a protocol behavior is experimental, document the fallback behavior and the client versions used during testing.
 
-```bash
-npm test
+## Recent compatibility updates
+
+| Update | Detail |
+| --- | --- |
+| Album association fix | Album child messages use association type `1`, the compatible child-association wire value, rather than treating the `MEDIA_ALBUM` message category as the association value |
+| View-once preserved | Explicit view-once implementations remain unchanged |
+| `mediaSpoilerMode` | New opt-in path for a view-once envelope or native spoiler flag, without altering existing defaults |
+
+## About Codex
+
+This package is built and maintained by **Codex**, also known as **Dev Codex**. Codex is a developer from Nigeria who focuses on practical, accessible, and reliable software projects across the JavaScript and TypeScript ecosystem.
+
+| | |
+| --- | --- |
+| Tech stack | JavaScript, HTML, TypeScript, Node.js, GitHub, Baileys, APIs, key-value stores |
+| Project types | Application development, websites, WhatsApp bots, Telegram bots, API endpoints, games |
+| Telegram | [@codexverified](https://t.me/codexverified) |
+| Email | codexauthorized@gmail.com |
+
+The developer's work is driven by a commitment to learning, experimentation, clear documentation, and useful software that developers can understand and extend. This package reflects that commitment through its readable source, public declarations, practical examples, and emphasis on responsible automation.
+
+## Package layout
+
+| Path | Contents |
+| --- | --- |
+| `lib/` | JavaScript implementation, supporting utilities, public TypeScript declarations |
+| `WAProto/` | Generated WhatsApp protocol definitions |
+| `engine-requirements.js` | Installation-time runtime checks |
+| `package.json` | Package metadata, scripts, dependencies, exports |
+| `README.md` | User-facing installation and usage guide |
+
+## Security and responsible use
+
+This library interacts with WhatsApp accounts and user communications.
+
+| Guideline | Detail |
+| --- | --- |
+| Authorization | Use only with accounts and data you are authorized to control |
+| Compliance | Respect WhatsApp's terms, applicable law, and message participants' privacy expectations |
+| Messaging conduct | Avoid unsolicited messaging |
+| Credential safety | Protect authentication state and never commit session files, tokens, private keys, or personal data to a public repository |
+| Media access | Limit access to stored media |
+| Transparency | Provide clear notice when an application performs automated actions |
+| Dependency review | Review installation scripts and optional dependencies before deploying to production; use pinned versions for repeatable builds |
+
+## License and maintenance
+
+This distribution is provided under the license declared in `package.json` and the accompanying license file. Review those terms before redistributing or combining this package with third-party code.
+
+**@codexverified/baileys is built and maintained by Codex under the CodexVerified organization.** Contributions, bug reports, and carefully documented improvements are welcome through the project repository.
+
+## Compatibility additions
+
+The current source includes several independently implemented compatibility helpers identified during comparison with the published upstream package. These additions preserve the Codex package identity and do not copy package-specific attribution enforcement or remote licensing checks.
+
+### Copy-to-clipboard rich response
+
+`sendCopyButton` creates a forwarded GenAI-style rich response with a copy-to-clipboard addon action.
+
+| Option | Purpose |
+| --- | --- |
+| `text` | The content that gets copied |
+| `label` | Optional visible button text |
+| `alignment` | `END`, `START`, or `CENTER` |
+
+```javascript
+await sock.sendCopyButton(jid, {
+  text: 'npm install @codexverified/baileys',
+  label: 'Copy install command',
+  alignment: 'END'
+})
 ```
 
-Before submitting changes, check the following:
+As with other private or experimental WhatsApp rich-response layouts, clients may fall back to plain rendering or ignore the addon action.
 
-1. Preserve the public API unless a breaking change is intentional.
-2. Keep runtime requirements and package metadata synchronized.
-3. Keep authentication data and personal account information out of commits.
-4. Validate ESM syntax and CommonJS compatibility where applicable.
-5. Document user-visible behavior changes in this README.
+### Slot-machine HTML generator
 
-## Package Layout
+`generateSlotMachineHtml` produces a self-contained five-reel Fruit Bonanza game with adjustable starting credits. It is a standalone HTML payload and performs no network requests.
 
-| Path | Purpose |
+| Option | Purpose |
 | --- | --- |
-| `lib/` | Compiled JavaScript implementation and type declarations |
-| `WAProto/` | WhatsApp protocol definitions and generated protocol helpers |
-| `engine-requirements.js` | Runtime requirement checks used during installation |
-| `package.json` | Package metadata, dependencies, scripts, and exports |
-| `README.md` | Project documentation and usage reference |
+| `title` | Display title for the generated page |
+| `startingCredits` | Initial credit balance |
 
-## Security and Responsible Use
+```javascript
+import { generateSlotMachineHtml } from '@codexverified/baileys'
 
-This library interacts with WhatsApp accounts and user communications. Use it only with accounts and data you are authorized to control. Protect authentication files, avoid unsolicited messaging, respect platform rules, and provide clear notice when an application performs automated actions.
+const html = generateSlotMachineHtml({
+  title: 'Codex Fruit Bonanza',
+  startingCredits: 500
+})
+```
 
-Do not commit session files, access tokens, private keys, phone numbers, or other personal information to a public repository.
+The generator does not by itself send HTML through WhatsApp. Applications should only use an HTML-capable message primitive when that primitive is available and authorized for their deployment.
 
-## License
+### Optional ban-status checker
 
-This project is distributed under the MIT License. See the package license metadata for the applicable terms.
+`checkStatusWA` is an explicit, caller-invoked diagnostic helper. It is never called during installation, socket creation, reconnection, or message sending. The endpoint is configurable, credentials are not embedded, and callers should review the endpoint's terms and privacy implications before sending a phone number.
 
-## Maintained by Codex
+```javascript
+import { checkStatusWA } from '@codexverified/baileys'
 
-**@codexverified/baileys is built and maintained by Codex.** Contributions, bug reports, and carefully documented improvements are welcome through the project repository once it is published.
+const result = await checkStatusWA('+447700900123', {
+  diagnostic: true
+})
+console.log(result.status) // active, banned, blocked, not_registered, rate_limited, or unknown
+```
+
+| Status value | Meaning |
+| --- | --- |
+| `active` | Number appears active on WhatsApp |
+| `banned` | Number appears banned |
+| `blocked` | Number appears blocked |
+| `not_registered` | Number is not registered on WhatsApp |
+| `rate_limited` | Check was rate limited |
+| `unknown` | Status could not be determined |
+
+This helper is not an anti-ban guarantee, does not bypass enforcement, and should not be used for bulk enumeration or unsolicited checking.
+
+## Comparison references
+
+The feature comparison was based on the published package metadata and documentation available from [npm][1] and the independent package analysis page at [Socket][2]. The Codex implementation adds compatible behavior through readable, package-owned code rather than copying upstream-specific integrity, attribution, or remote-verification mechanisms.
+
+[1]: https://www.npmjs.com/
+[2]: https://socket.dev/
 
+## Additional functional compatibility helpers
 
+The source also exposes portable helpers for native-flow responses, view-once inspection, rich content preparation, HTML payload construction, and website previews. These are functional compatibility APIs only; package-specific identity checks, attribution enforcement, remote license gates, trusted-channel auto-follow behavior, and other ownership structures are not included.
 
+| Helper | Purpose |
+| --- | --- |
+| `parseNativeFlowResponse` | Normalize quick-reply, single-select, and Flow response envelopes |
+| `parseWhatsAppFlowResponse` | Return only responses identified as WhatsApp Flow responses |
+| `buildWhatsAppFlowButton` / `makeWhatsAppFlowButton` | Build published Flow button parameters for a caller-owned Flow ID and token |
+| `prepareRichTextMessage` | Build a forwarded rich text response |
+| `prepareRichImageMessage` | Build a forwarded rich image response |
+| `prepareRichLinkMessage` | Build a forwarded response with inline link entities |
+| `prepareRichGenerationMessage` | Build a rich response from caller-provided rich content |
+| `prepareHtmlMessage` | Build an HTML primitive payload for clients that support the experimental structure |
+| `prepareSlotMachineMessage` | Wrap the local slot-machine generator as an HTML message payload |
+| `generateLinkPreviewHtml` / `generateWebsitePreviewHtml` | Create escaped link cards or an explicitly requested metadata preview |
+| `parseViewOnceInfo` and related helpers | Inspect, download, reconstruct, and apply explicit view-once policies |
+
+All networked helpers are opt-in. Website previews fetch only when explicitly called, and Flow helpers require credentials and identifiers owned by the application. Experimental WhatsApp layouts remain client-dependent and should always have a plain-text fallback.
+
+## AI generation primitive
+
+`buildImaginePrimitive` creates the Meta-style AI image or animation generation-state payload used by rich responses. It is a pure payload builder — it does not call a generation service itself, generate media, or send anything on its own; callers wire it up to whatever AI generation backend they use, then pass the resulting primitive into a rich-response message.
+
+| Field | Purpose |
+| --- | --- |
+| `state` | Generation status: `GENERATING`, `COMPLETE`, or `ERROR` |
+| `mediaUrl` | URL of the generated media

package/lib/Socket/index.js

@@ -36,7 +36,7 @@ const makeWASocket = (config) => {
         };
         console.log(
             `\n${yellow}${center('CODEX TECHNOLOGY')}${reset}\n` +
-            `${blue}${center('@codexverified/Baileys')}${reset}\n` +
+            `${blue}${center('@codexverified/baileys')}${reset}\n` +
             `${yellow}${center('premium baileys built by codex')}${reset}\n`
         );
     }

package/lib/Socket/messages-send.js

@@ -4,7 +4,6 @@ import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
-import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
@@ -17,7 +16,7 @@ import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID }
 import { makeUsernameSocket } from './username.js';
 
 const STATUS_JID = 'status@broadcast';
-const normalizeStatusJidList = (value) => {
+export const normalizeStatusJidList = (value) => {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Boom('statusJidList must contain at least one recipient JID', { statusCode: 400 });
     }
@@ -1224,6 +1223,13 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
             return fullMsg;
         },
+        sendCopyButton: async (jid, content = {}, options = {}) => {
+            const { prepareCopyToClipboardMessage } = await import('../Utils/rich-message-utils.js');
+            const message = prepareCopyToClipboardMessage(content);
+            const fullMsg = await generateWAMessageFromContent(jid, message, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+            await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
+            return fullMsg;
+        },
         sendInteractiveTable: async (jid, table, options = {}) => {
             const { title = '', headers = [], rows = [], image, buttons = [], footer } = table || {};
             if (!Array.isArray(headers) || !Array.isArray(rows) || !Array.isArray(buttons)) throw new Boom('sendInteractiveTable expects headers, rows, and buttons arrays', { statusCode: 400 });
@@ -2040,7 +2046,9 @@ export const makeMessagesSocket = (config) => {
                         albumMsg.message.messageContextInfo ||= {};
                         albumMsg.message.messageContextInfo.messageAssociation = {
                             parentMessageKey: fullMsg.key,
-                            associationType: AssociationType.MEDIA_ALBUM
+                            // WhatsApp album child messages use association type 1.
+                            // MEDIA_ALBUM is a message category, not the child-association wire value.
+                            associationType: 1
                         };
                         await relayMessage(jid, albumMsg.message, {
                             messageId: albumMsg.key.id,

package/lib/Utils/ban-checker.js

@@ -0,0 +1,48 @@
+/**
+ * Optional WhatsApp registration-status checker.
+ *
+ * This module is deliberately opt-in. It does not run during installation,
+ * connection setup, or message sending, and it does not contain credentials.
+ * Callers should review the endpoint and applicable terms before use.
+ */
+
+const cleanNumber = (value) => String(value ?? '').replace(/[\s().\-/]/g, '').replace(/^00/, '').replace(/^\+/, '');
+
+export const normalizeBanCheckNumber = (value) => {
+    const number = cleanNumber(typeof value === 'object' ? value.number : value);
+    if (!/^\d{6,15}$/.test(number)) throw new TypeError('number must be an international phone number');
+    return `+${number}`;
+};
+
+export const checkStatusWA = async (number, options = {}) => {
+    const normalized = normalizeBanCheckNumber(number);
+    const endpoint = options.endpoint || 'https://v.whatsapp.net/v2/exist';
+    const fetchImpl = options.fetch || globalThis.fetch;
+    if (typeof fetchImpl !== 'function') throw new TypeError('a fetch implementation is required');
+    const url = new URL(endpoint);
+    url.searchParams.set('in', normalized.slice(1));
+    const response = await fetchImpl(url, {
+        method: 'GET',
+        headers: { ...(options.headers || {}) },
+        signal: options.signal
+    });
+    let body = null;
+    try { body = await response.json(); } catch { body = null; }
+    const reason = String(body?.reason || body?.error || body?.status || '').toLowerCase();
+    let status = 'unknown';
+    if (response.status === 429 || /rate.?limit|too many/.test(reason)) status = 'rate_limited';
+    else if (/blocked|official|banned|ban|temporar|perman/.test(reason)) status = /banned|ban|temporar|perman/.test(reason) ? 'banned' : 'blocked';
+    else if (/not.?registered|does.?not.?exist/.test(reason)) status = 'not_registered';
+    else if (response.ok) status = 'active';
+    return {
+        number: normalized,
+        status,
+        isBanned: status === 'banned',
+        isNeedOfficialWa: status === 'blocked',
+        diagnostics: options.diagnostic === true ? {
+            httpStatus: response.status,
+            ok: response.ok,
+            bodyKeys: body && typeof body === 'object' ? Object.keys(body).sort() : []
+        } : undefined
+    };
+};

package/lib/Utils/games/slot-machine.js

@@ -0,0 +1,19 @@
+/**
+ * Self-contained, dependency-free slot-machine HTML generator.
+ * The generated page is local-only and makes no network requests.
+ */
+
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>"']/g, (character) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+}[character]));
+
+export const generateSlotMachineHtml = (options = {}) => {
+    const title = escapeHtml(options.title || 'FRUIT BONANZA');
+    const startingCredits = Number.isFinite(Number(options.startingCredits)) && Number(options.startingCredits) >= 0
+        ? Math.floor(Number(options.startingCredits)) : 500;
+    return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><style>
+*{box-sizing:border-box}body{margin:0;padding:12px;background:#160704;color:#ffe8a3;font:14px system-ui,sans-serif}.machine{max-width:540px;margin:auto;padding:16px;border:4px solid #e6a139;border-radius:22px;background:linear-gradient(135deg,#230805,#8c3515,#2b0906);box-shadow:0 8px 18px #000a}.title{text-align:center;font-size:24px;font-weight:900;color:#fff2a1;text-shadow:0 2px #8f1c0c}.stats{display:flex;justify-content:space-around;margin:10px 0;padding:8px;border:2px solid #a55c19;border-radius:8px;background:#100303}.reels{display:grid;grid-template-columns:repeat(5,1fr);gap:5px;padding:8px;border:5px solid #9b4e12;border-radius:14px;background:#140604}.reel{height:78px;display:grid;place-items:center;border-radius:6px;background:linear-gradient(#fffce4,#d7bf87);color:#b20f1c;font-size:38px;font-weight:900;overflow:hidden}.reel.spin{animation:spin .16s linear infinite}.message{min-height:30px;margin:10px;text-align:center;font-weight:800}.controls{display:flex;gap:8px}.controls button{flex:1;padding:12px;border:2px solid #351006;border-radius:10px;font-weight:900;cursor:pointer}.bet{background:#1685a5;color:white}.spin{background:#27a93b;color:white}.spin:disabled{opacity:.5}@keyframes spin{50%{transform:translateY(5px);filter:blur(1px)}}small{display:block;margin-top:10px;text-align:center;color:#d6a15b}</style></head><body><main class="machine"><div class="title">${title}</div><div class="stats"><span>Credits <b id="credits">${startingCredits}</b></span><span>Bet <b id="bet">10</b></span><span>Best <b id="best">0</b></span></div><div class="reels">${[0,1,2,3,4].map((index) => `<div class="reel" id="r${index}">🍒</div>`).join('')}</div><div class="message" id="message">SPIN TO PLAY</div><div class="controls"><button class="bet" id="betButton" type="button">BET</button><button class="spin" id="spinButton" type="button">SPIN</button></div><small>Three matching symbols win. This is a local chat-embedded game.</small></main><script>
+(()=>{const symbols=['🍒','🍋','🔔','💎','7️⃣','🅱️'];let credits=${startingCredits},bet=10,best=0,busy=false;const $=id=>document.getElementById(id);const ui=()=>{$('credits').textContent=credits;$('bet').textContent=bet;$('best').textContent=best};$('betButton').onclick=()=>{if(busy)return;bet=bet===10?20:bet===20?50:10;if(bet>credits)bet=10;ui()};$('spinButton').onclick=()=>{if(busy||credits<bet)return;busy=true;credits-=bet;$('message').textContent='GOOD LUCK';ui();const reels=[0,1,2,3,4].map(i=>$('r'+i));reels.forEach(r=>r.classList.add('spin'));setTimeout(()=>{const values=reels.map(r=>{r.classList.remove('spin');const value=symbols[Math.floor(Math.random()*symbols.length)];r.textContent=value;return value});const counts=values.reduce((map,value)=>(map[value]=(map[value]||0)+1,map),{});const match=Math.max(...Object.values(counts));const win=match>=3?bet*(match===5?20:match===4?8:3):0;credits+=win;best=Math.max(best,win);$('message').textContent=win?'WIN +'+win:(credits?'TRY AGAIN':'GAME OVER');busy=false;ui()},700)};ui()})();</script></body></html>`;
+};
+
+export default generateSlotMachineHtml;

package/lib/Utils/index.js

@@ -32,3 +32,9 @@ export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
+export * from './games/slot-machine.js';
+export * from './ban-checker.js';
+export * from './native-flow.js';
+export * from './view-once-utils.js';
+export * from './website-preview.js';
+export * from './portable-compat.js';

package/lib/Utils/messages.js

@@ -1363,6 +1363,31 @@ export const generateWAMessageContent = async (message, options) => {
         };
         delete message.interactiveAsTemplate;
     }
+    // Codex compatibility: expose the public media-spoiler mode without changing
+    // the existing explicit viewOnce/viewOnceV2 behavior. The mode is opt-in.
+    // Supported values are `viewOnce` and `native` for image, video, document,
+    // and sticker messages. Existing `spoiler` and view-once flags take priority.
+    if (hasOptionalProperty(message, 'mediaSpoilerMode') &&
+        !message.viewOnce &&
+        !message.viewOnceV2 &&
+        !message.viewOnceV2Extension) {
+        const messageType = Object.keys(m)[0];
+        const isSpoilerMedia = ['imageMessage', 'videoMessage', 'documentMessage', 'stickerMessage'].includes(messageType);
+        const mode = message.mediaSpoilerMode;
+        if (isSpoilerMedia && mode === 'viewOnce') {
+            m = { viewOnceMessage: { message: m } };
+        }
+        else if (isSpoilerMedia && mode === 'native') {
+            const key = m[messageType];
+            if (key && 'contextInfo' in key && key.contextInfo) {
+                key.contextInfo.isSpoiler = true;
+            }
+            else if (key) {
+                key.contextInfo = { isSpoiler: true };
+            }
+        }
+        delete message.mediaSpoilerMode;
+    }
     // Lia@Changes 30-01-26 --- Add "ephemeral" boolean to wrap message into ephemeralMessage like "viewOnce"
     if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
         m = { ephemeralMessage: { message: m } };

package/lib/Utils/native-flow.js

@@ -0,0 +1,48 @@
+const parseJsonObject = (value) => {
+    if (!value) return {};
+    if (typeof value === 'object') return value;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch { return {}; }
+};
+
+export const parseNativeFlowResponse = (message) => {
+    const content = message?.message || message;
+    const response = content?.interactiveResponseMessage?.nativeFlowResponseMessage || content?.nativeFlowResponseMessage;
+    if (!response) return null;
+    const params = parseJsonObject(response.paramsJson);
+    const actionPayload = params.flow_action_payload || params.flowActionPayload || {};
+    const data = params.data || params.response || params.form_data || params.formData || actionPayload.data || {};
+    return {
+        name: response.name || '', version: response.version, paramsJson: response.paramsJson || '', params,
+        isFlow: response.name === 'galaxy_message' || response.name === 'flow' || Boolean(params.flow_id || params.flow_token || params.flow_message_version),
+        flowId: params.flow_id || params.flowId, flowToken: params.flow_token || params.flowToken,
+        screen: params.screen || actionPayload.screen, action: params.flow_action || params.flowAction || actionPayload.action,
+        actionPayload, data, buttonId: params.id || params.button_id || params.buttonId,
+        displayText: params.display_text || params.displayText, raw: response
+    };
+};
+
+export const parseWhatsAppFlowResponse = (message) => {
+    const response = parseNativeFlowResponse(message);
+    return response?.isFlow ? response : null;
+};
+
+export const buildWhatsAppFlowButton = ({ flowId, flowToken, cta = 'Open form', action = 'navigate', actionPayload, mode = 'published', flowMessageVersion = '3', metadata, name = 'galaxy_message' } = {}) => {
+    if (!flowId) throw new TypeError('flowId is required to launch a WhatsApp Flow');
+    if (!flowToken) throw new TypeError('flowToken is required to launch a WhatsApp Flow');
+    return {
+        name, flow_message_version: String(flowMessageVersion), flow_token: String(flowToken), flow_id: String(flowId),
+        flow_cta: String(cta), flow_action: action,
+        ...(actionPayload ? { flow_action_payload: actionPayload } : {}),
+        ...(metadata ? { flow_metadata: metadata } : {}),
+        ...(mode ? { flow_mode: String(mode) } : {})
+    };
+};
+
+export const makeWhatsAppFlowButton = (flow) => ({
+    name: flow?.nativeFlowName || 'galaxy_message',
+    buttonParamsJson: JSON.stringify(buildWhatsAppFlowButton(flow))
+});
+      

package/lib/Utils/portable-compat.js

@@ -0,0 +1,12 @@
+import { generateRichMenuContent } from './message-composer.js';
+import { prepareRichResponseMessage } from './rich-message-utils.js';
+
+/** Build a prepared rich-menu payload for direct message generation. */
+export const prepareRichMenuMessage = (content = {}, quoted, options = {}) => generateRichMenuContent(content, quoted, options);
+
+/** Convert unsupported premium content to a safe plain-text rich response. */
+export const downgradePremiumContent = (content = {}) => {
+    if (typeof content === 'string') return prepareRichResponseMessage({ contentText: content, noDonation: true });
+    const text = content.text || content.contentText || content.caption || '';
+    return prepareRichResponseMessage({ contentText: String(text), noDonation: true });
+};

package/lib/Utils/rich-message-utils.js

@@ -299,7 +299,7 @@ export const prepareRichResponseMessage = (content) => {
         const defaultDonationLink = {
             text: '',
             url: DONATE_URL,
-            title: 'PAIR CRYSNVA AI :',
+            title: 'PAIR CODEX AI :',
             displayName: 'pair bot'
         };
         const resolvedLinks = noDonation ? links : [...(links || []), defaultDonationLink];
@@ -436,4 +436,110 @@ export const wrapToBotForwardedMessage = (richResponseMessage) => ({
         message: { richResponseMessage }
     }
 });
-//# sourceMappingURL=rich-message-utils.js.map
+//# sourceMappingURL=rich-message-utils.js.map
+
+/**
+ * Build a forwarded rich response with an inline copy-to-clipboard action.
+ * The payload follows WhatsApp's GenAI addon-action layout and is opt-in.
+ * @param {{text?: string, label?: string, alignment?: 'END'|'START'|'CENTER'}} options
+ * @returns {{messageContextInfo: object, botForwardedMessage: object}}
+ */
+export const prepareCopyToClipboardMessage = (options = {}) => {
+    const text = String(options.text ?? '');
+    const label = String(options.label ?? text);
+    const alignment = ['END', 'START', 'CENTER'].includes(options.alignment) ? options.alignment : 'END';
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAIAddonActionLayoutViewModel',
+                addon_action_type: 'COPY_TO_CLIPBOARD',
+                addon_action_alignment: alignment,
+                primitives: [{
+                    __typename: 'GenAIMarkdownTextUXPrimitive',
+                    text: label,
+                    inline_entities: []
+                }]
+            }
+        }]
+    };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+/** Build a plain rich-text forwarded response. */
+export const prepareRichTextMessage = ({ text = '' } = {}) => prepareRichResponseMessage({ contentText: String(text), noDonation: true });
+
+/** Build a rich image forwarded response using a GenAI image primitive. */
+export const prepareRichImageMessage = ({ url = '', mimeType = 'image/png' } = {}) => {
+    const media = { __typename: 'GenAIMediaItem', mime_type: mimeType, url: String(url), url_fallback: String(url) };
+    const unified = { response_id: randomUUID(), sections: [{ __typename: 'GenAIUnifiedResponseSection', view_model: { __typename: 'GenAISingleLayoutViewModel', primitive: { __typename: 'GenAIImagePrimitive', preview_image: media, full_image: media } } }] };
+    const rich = proto.AIRichResponseMessage.create({ submessages: [], messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD, unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 } });
+    return wrapToBotForwardedMessage(rich);
+};
+
+/** Build a rich response containing clickable inline links. */
+export const prepareRichLinkMessage = ({ links = [], text = '' }= {}) => {
+    const entities = [];
+    let combined = '';
+    for (const [index, link] of links.entries()) {
+        const key = `INLINE_HYPERLINK_${index}`;
+        const display = String(link?.text || link?.displayName || link?.url || '');
+        combined += `{{${key}}}${display}{{/${key}}}`;
+        entities.push({ key, metadata: { display_name: display, is_trusted: link?.isTrusted !== false, url: String(link?.url || ''), __typename: 'GenAIInlineLinkItem' } });
+    }
+    return prepareRichResponseMessage({ contentText: combined || String(text), links: [], noDonation: true, noHeading: true, richResponse: [{ text: combined || String(text), inlineEntities: entities }] });
+};
+
+/** Build a rich-generation response from existing rich-response content. */
+export const prepareRichGenerationMessage = (content = {}) => prepareRichResponseMessage({ ...content, noDonation: true });
+
+/** Build an HTML primitive payload. Use only with an HTML-capable, authorized client. */
+export const prepareHtmlMessage = ({ html = '' } = {}) => {
+    const unified = { response_id: randomUUID(), sections: [{ view_model: { primitive: { __typename: 'FOAHtmlPrimitiveDemoDONOTUSE', html: String(html) }, __typename: 'GenAISingleLayoutViewModel' } }] };
+    const rich = proto.AIRichResponseMessage.create({ submessages: [], messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD, unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 } });
+    return wrapToBotForwardedMessage(rich);
+};
+
+/** Convenience wrapper for a slot-machine HTML message payload. */
+export const prepareSlotMachineMessage = async (options = {}) => {
+    const { generateSlotMachineHtml } = await import('./games/slot-machine.js');
+    return prepareHtmlMessage({ html: generateSlotMachineHtml(options) });
+};
+
+/**
+ * Build a Meta-style AI image/video generation primitive.
+ * The payload is useful for displaying generation progress without making any
+ * network request or enabling a hidden background process.
+ */
+export const buildImaginePrimitive = ({
+    mediaType = 'video',
+    url = '',
+    thumbnail,
+    mimeType,
+    fileLength = 0,
+    duration = 0,
+    status = 'GENERATING',
+    estimatedMs,
+    imagineType
+} = {}) => {
+    const normalizedType = String(mediaType).toLowerCase() === 'image' ? 'IMAGE' : 'ANIMATE';
+    return {
+        __typename: 'GenAIImaginePrimitive',
+        media_type: normalizedType,
+        imagine_type: imagineType || normalizedType,
+        status: String(status),
+        ...(url ? { url: String(url), url_fallback: String(url) } : {}),
+        ...(thumbnail ? { thumbnail_url: String(thumbnail) } : {}),
+        ...(mimeType ? { mime_type: String(mimeType) } : {}),
+        ...(fileLength ? { file_length: Number(fileLength) } : {}),
+        ...(duration ? { duration: Number(duration) } : {}),
+        ...(estimatedMs !== undefined ? { estimated_ms: Number(estimatedMs) } : {})
+    };
+};

package/lib/Utils/view-once-utils.js

@@ -0,0 +1,56 @@
+import { downloadContentFromMessage } from './messages-media.js';
+
+export const isViewOnceMessage = (message) => Boolean(message?.message?.viewOnceMessage || message?.message?.viewOnceMessageV2 || message?.message?.viewOnceMessageV2Extension || message?.viewOnceMessage || message?.viewOnceMessageV2 || message?.viewOnceMessageV2Extension);
+
+export const extractViewOnceContent = (message) => {
+    const content = message?.message || message;
+    return content?.viewOnceMessage?.message || content?.viewOnceMessageV2?.message || content?.viewOnceMessageV2Extension?.message || null;
+};
+
+export const getViewOnceMediaType = (message) => {
+    const content = extractViewOnceContent(message);
+    if (!content) return null;
+    for (const type of ['image', 'video', 'audio', 'document', 'sticker']) if (content[`${type}Message`]) return type;
+    return null;
+};
+
+export const getViewOnceMediaContent = (message) => {
+    const content = extractViewOnceContent(message);
+    if (!content) return null;
+    return content.imageMessage || content.videoMessage || content.audioMessage || content.documentMessage || content.stickerMessage || null;
+};
+
+export const downloadViewOnceMedia = async (message, options = {}) => {
+    const media = getViewOnceMediaContent(message);
+    const type = getViewOnceMediaType(message);
+    if (!media || !type) throw new Error('No supported media content found in view-once message');
+    const stream = await downloadContentFromMessage(media, type, options);
+    const chunks = [];
+    for await (const chunk of stream) chunks.push(chunk);
+    return Buffer.concat(chunks);
+};
+
+export const createRegularMessageFromViewOnce = (originalMessage, mediaBuffer) => {
+    const media = getViewOnceMediaContent(originalMessage);
+    const type = getViewOnceMediaType(originalMessage);
+    if (!media || !type) return null;
+    return {
+        key: originalMessage.key, messageTimestamp: originalMessage.messageTimestamp,
+        pushName: originalMessage.pushName, participant: originalMessage.participant,
+        decryptedMedia: { type, buffer: mediaBuffer, mimeType: media.mimetype, fileName: media.fileName, caption: media.caption, fileLength: media.fileLength },
+        originalViewOnceMessage: originalMessage.message
+    };
+};
+
+export const shouldAutoDecryptViewOnce = (message, config = {}) => isViewOnceMessage(message) && config.autoVV !== false && message.key?.fromMe !== true;
+export const shouldDeleteViewOnce = (message, config = {}) => isViewOnceMessage(message) && config.antiVV !== false && message.key?.fromMe !== true;
+
+export const parseViewOnceInfo = (message) => {
+    const media = getViewOnceMediaContent(message);
+    return {
+        isViewOnce: isViewOnceMessage(message), mediaType: getViewOnceMediaType(message), mimeType: media?.mimetype,
+        fileName: media?.fileName, caption: media?.caption, fileLength: media?.fileLength,
+        hasUrl: Boolean(media?.url), hasDirectPath: Boolean(media?.directPath), hasMediaKey: Boolean(media?.mediaKey)
+    };
+};
+  

package/lib/Utils/website-preview.js

@@ -0,0 +1,27 @@
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[character]));
+
+const validateUrl = (value) => {
+    const parsed = new URL(value);
+    if (!['http:', 'https:'].includes(parsed.protocol)) throw new TypeError('only HTTP(S) preview URLs are supported');
+    return parsed;
+};
+
+export const generateLinkPreviewHtml = (url, options = {}) => {
+    const parsed = validateUrl(url);
+    const title = options.title || parsed.hostname;
+    const description = options.description || `Open ${parsed.hostname}`;
+    const image = options.image ? `<img src="${escapeHtml(options.image)}" alt="" loading="lazy">` : '<div class="placeholder">🌐</div>';
+    return `<!doctype html><html><head><meta charset="utf-8"><style>body{margin:0;background:transparent;font:14px system-ui,sans-serif}.card{overflow:hidden;border:1px solid #333;border-radius:12px;background:#1a1a2e;color:#fff}.card img,.placeholder{display:block;width:100%;height:160px;object-fit:cover}.placeholder{display:grid;place-items:center;font-size:48px;background:linear-gradient(135deg,#1a1a2e,#2d2d44)}.body{padding:14px}.title{font-weight:700;margin-bottom:5px}.desc{color:#bbb;line-height:1.4}.url{margin-top:8px;color:#55c878;font-size:11px}</style></head><body><a href="${escapeHtml(parsed.href)}" target="_blank" rel="noopener noreferrer" style="text-decoration:none"><div class="card">${image}<div class="body"><div class="title">${escapeHtml(title)}</div><div class="desc">${escapeHtml(description)}</div><div class="url">${escapeHtml(parsed.hostname)}</div></div></div></a></body></html>`;
+};
+
+export const generateWebsitePreviewHtml = async (url, options = {}) => {
+    const parsed = validateUrl(url);
+    const response = await (options.fetch || globalThis.fetch)(parsed.href, { signal: options.signal, headers: options.headers || {} });
+    if (!response?.ok) throw new Error(`website preview request failed with status ${response?.status ?? 'unknown'}`);
+    const html = await response.text();
+    const title = html.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1] || parsed.hostname;
+    const description = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']*)["']/i)?.[1] || `Preview of ${parsed.hostname}`;
+    return generateLinkPreviewHtml(parsed.href, { ...options, title, description });
+};
+
+export default generateWebsitePreviewHtml;

package/lib/index.d.ts

@@ -259,6 +259,8 @@ export interface WASocket {
     richMenu(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a rich button-card grid. */
     sendRichButtonGrid(jid: string, grid: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a GenAI-style inline copy-to-clipboard rich response. */
+    sendCopyButton(jid: string, content: { text: string; label?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a markdown-style interactive table with buttons. */
     sendInteractiveTable(jid: string, table: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a WhatsApp native flow button. */
@@ -293,6 +295,37 @@ export declare function makeCacheManagerAuthState(store: CacheManagerStore, sess
     saveCreds: () => Promise<void>;
 }>;
 
+/** Generate a self-contained local slot-machine HTML payload. */
+export declare function generateSlotMachineHtml(options?: { title?: string; startingCredits?: number }): string;
+export declare function buildImaginePrimitive(options?: { mediaType?: 'image' | 'video'; url?: string; thumbnail?: string; mimeType?: string; fileLength?: number; duration?: number; status?: string; estimatedMs?: number; imagineType?: string }): Record<string, unknown>;
+export declare function parseNativeFlowResponse(message: unknown): Record<string, unknown> | null;
+export declare function parseWhatsAppFlowResponse(message: unknown): Record<string, unknown> | null;
+export declare function buildWhatsAppFlowButton(flow?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeWhatsAppFlowButton(flow?: Record<string, unknown>): { name: string; buttonParamsJson: string };
+export declare function isViewOnceMessage(message: unknown): boolean;
+export declare function extractViewOnceContent(message: unknown): Record<string, unknown> | null;
+export declare function getViewOnceMediaType(message: unknown): string | null;
+export declare function getViewOnceMediaContent(message: unknown): Record<string, unknown> | null;
+export declare function parseViewOnceInfo(message: unknown): Record<string, unknown>;
+export declare function shouldAutoDecryptViewOnce(message: unknown, config?: Record<string, unknown>): boolean;
+export declare function shouldDeleteViewOnce(message: unknown, config?: Record<string, unknown>): boolean;
+export declare function generateLinkPreviewHtml(url: string, options?: Record<string, unknown>): string;
+export declare function generateWebsitePreviewHtml(url: string, options?: Record<string, unknown>): Promise<string>;
+export declare function prepareRichTextMessage(options?: { text?: string }): Record<string, unknown>;
+export declare function prepareRichImageMessage(options?: { url?: string; mimeType?: string }): Record<string, unknown>;
+export declare function prepareRichLinkMessage(options?: { links?: Array<Record<string, unknown>>; text?: string }): Record<string, unknown>;
+export declare function prepareRichGenerationMessage(content?: Record<string, unknown>): Record<string, unknown>;
+export declare function prepareHtmlMessage(options?: { html?: string }): Record<string, unknown>;
+export declare function prepareSlotMachineMessage(options?: { title?: string; startingCredits?: number }): Promise<Record<string, unknown>>;
+export declare function prepareRichMenuMessage(content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function downgradePremiumContent(content?: unknown): Record<string, unknown>;
+
+/** Normalize an international phone number for an explicit status check. */
+export declare function normalizeBanCheckNumber(value: string | { number: string }): string;
+
+/** Perform an explicit, caller-configured WhatsApp registration-status check. */
+export declare function checkStatusWA(number: string | { number: string }, options?: { endpoint?: string; fetch?: typeof fetch; headers?: Record<string, string>; signal?: AbortSignal; diagnostic?: boolean }): Promise<{ number: string; status: string; isBanned: boolean; isNeedOfficialWa: boolean; diagnostics?: { httpStatus: number; ok: boolean; bodyKeys: string[] } }>;
+
 /** Wrap a socket with anti-ban protection (from the baileys-antiban bundle). */
 export declare function wrapSocket(socket: WASocket, config?: unknown): WASocket;
 

package/lib/index.js

@@ -1,4 +1,5 @@
 import makeWASocket from './Socket/index.js';
+export { normalizeStatusJidList } from './Socket/messages-send.js';
 export * from '../WAProto/index.js';
 export * from './Utils/index.js';
 export * from './Types/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.10.11",
+   "version": "2.11.12",
    "description": "CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex, with Meta compositing, bot planning replay, welcome flow, rich messages, interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",