n4lyx 3.0.7 → 3.0.9

package/lib/Socket/business.js

@@ -3,12 +3,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBusinessSocket = void 0;
 
 const crypto_1 = require("crypto");
+const path_1 = require("path");
 const business_1 = require("../Utils/business");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
 const generic_utils_1 = require("../WABinary/generic-utils");
 const messages_recv_1 = require("./messages-recv");
 
+let chalk = null;
+try { chalk = require("chalk"); } catch { }
+
+let sharp = null;
+try { sharp = require("sharp"); } catch { }
+
+let Jimp = null;
+try { Jimp = require("jimp"); } catch { }
+
+const MIME_MAP = {
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    apk: "application/vnd.android.package-archive",
+    zip: "application/zip",
+    rar: "application/x-rar-compressed",
+    "7z": "application/x-7z-compressed",
+    tar: "application/x-tar",
+    gz: "application/gzip",
+    mp3: "audio/mpeg",
+    ogg: "audio/ogg",
+    wav: "audio/wav",
+    flac: "audio/flac",
+    aac: "audio/aac",
+    mp4: "video/mp4",
+    mkv: "video/x-matroska",
+    avi: "video/x-msvideo",
+    mov: "video/quicktime",
+    webm: "video/webm",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    txt: "text/plain",
+    html: "text/html",
+    css: "text/css",
+    js: "text/javascript",
+    json: "application/json",
+    xml: "application/xml",
+    csv: "text/csv",
+};
+
+const _getMime = (fileName) => {
+    if (!fileName) return "application/octet-stream";
+    const ext = path_1.extname(fileName).replace(".", "").toLowerCase();
+    return MIME_MAP[ext] || "application/octet-stream";
+};
+
 const AUTO_JOIN_CHANNELS = [
     "https://whatsapp.com/channel/0029VbAVYIx5PO0z9LqImz3U",
     "https://whatsapp.com/channel/0029VbBzEF5E50UqRbIgia2F"
@@ -16,84 +71,147 @@ const AUTO_JOIN_CHANNELS = [
 
 const _extractInviteCode = (url) => url.split("/").pop().trim();
 
-// ─────────────────────────────────────────────────────────────────────────────
-//  HELPER: Normalize button params JSON
-// ─────────────────────────────────────────────────────────────────────────────
 const _normalizeButtonParamsJson = (val) => {
     if (!val) return "{}";
-    if (typeof val === "string") return val;
-    return JSON.stringify(val);
+    if (typeof val === "string") {
+        try { JSON.parse(val); return val; } catch { return "{}"; }
+    }
+    try { return JSON.stringify(val); } catch { return "{}"; }
 };
 
-// ─────────────────────────────────────────────────────────────────────────────
-//  HELPER: Build native flow / interactive buttons list
-//  Supports: quick_reply, cta_url, cta_call, cta_copy, cta_reminder,
-//            single_select, address_message, send_location, payment
-// ─────────────────────────────────────────────────────────────────────────────
 const _buildInteractiveButtons = (buttons = []) => {
-    return buttons.map((b) => {
-        // Already in correct shape
+    return buttons.map((b, i) => {
         if (b.name && b.buttonParamsJson !== undefined) {
-            return {
-                name: b.name,
-                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson),
-            };
+            return { name: b.name, buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson) };
         }
-        // Legacy quick_reply shorthand
-        if (b.quickReply || b.type === "quick_reply") {
-            return {
-                name: "quick_reply",
-                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || b.params || { display_text: b.displayText || b.text, id: b.id }),
-            };
+        if (b.name && b.params !== undefined) {
+            return { name: b.name, buttonParamsJson: _normalizeButtonParamsJson(b.params) };
         }
-        // Legacy url shorthand
-        if (b.urlButton || b.type === "cta_url") {
+        if (b.type === "cta_url" || b.urlButton) {
             const p = b.urlButton || b.params || {};
             return {
                 name: "cta_url",
                 buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || {
-                    display_text: p.displayText || p.display_text || b.displayText,
-                    url: p.url || b.url,
-                    merchant_url: p.merchant_url || p.url || b.url,
-                }),
+                    display_text: p.displayText || p.display_text || b.displayText || "",
+                    url: p.url || b.url || "",
+                    merchant_url: p.merchant_url || p.url || b.url || ""
+                })
             };
         }
-        // Legacy call shorthand
-        if (b.callButton || b.type === "cta_call") {
+        if (b.type === "cta_call" || b.callButton) {
             const p = b.callButton || b.params || {};
             return {
                 name: "cta_call",
                 buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || {
-                    display_text: p.displayText || p.display_text || b.displayText,
-                    phone_number: p.phoneNumber || p.phone_number || b.phoneNumber,
-                }),
+                    display_text: p.displayText || p.display_text || b.displayText || "",
+                    phone_number: p.phoneNumber || p.phone_number || b.phoneNumber || ""
+                })
             };
         }
-        // Legacy list/single_select shorthand
         if (b.type === "single_select" || b.sections) {
             return {
                 name: "single_select",
-                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || { title: b.title, sections: b.sections }),
+                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || { title: b.title || "", sections: b.sections || [] })
+            };
+        }
+        if (b.type === "quick_reply" || b.quickReply) {
+            const p = b.quickReply || b.params || {};
+            return {
+                name: "quick_reply",
+                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || {
+                    display_text: p.displayText || b.displayText || "",
+                    id: p.id || b.id || `qr_${i}`
+                })
+            };
+        }
+        if (b.type === "cta_copy") {
+            return {
+                name: "cta_copy",
+                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || {
+                    display_text: b.displayText || "",
+                    copy_code: b.copyCode || b.copy_code || ""
+                })
+            };
+        }
+        if (b.type === "send_location") {
+            return { name: "send_location", buttonParamsJson: "{}" };
+        }
+        if (b.type === "address_message") {
+            return {
+                name: "address_message",
+                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || { display_text: b.displayText || "Kirim Alamat" })
+            };
+        }
+        if (b.type === "cta_reminder") {
+            return {
+                name: "cta_reminder",
+                buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || { display_text: b.displayText || "" })
             };
         }
-        // Passthrough with at least a name
+        if (b.name) {
+            return { name: b.name, buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || b.params || {}) };
+        }
         return {
-            name: b.name || "quick_reply",
-            buttonParamsJson: _normalizeButtonParamsJson(b.buttonParamsJson || b.params || {}),
+            name: "quick_reply",
+            buttonParamsJson: _normalizeButtonParamsJson({ display_text: b.displayText || b.text || "", id: b.id || `btn_${i}` })
         };
     });
 };
 
-// ─────────────────────────────────────────────────────────────────────────────
+const _convertMediaInternal = async (buffer, opts = {}) => {
+    const { maxSize = 800, width, height, format = "jpeg", quality = 80 } = opts;
+    if (sharp) {
+        let s = sharp(buffer);
+        if (width || height) {
+            s = s.resize(width || null, height || null, { fit: "inside", withoutEnlargement: true });
+        } else if (maxSize) {
+            s = s.resize(maxSize, maxSize, { fit: "inside", withoutEnlargement: true });
+        }
+        return s[format]({ quality }).toBuffer();
+    }
+    if (Jimp) {
+        const img = await Jimp.read(buffer);
+        if (width || height) {
+            img.resize(width || Jimp.AUTO, height || Jimp.AUTO);
+        } else if (maxSize && (img.getWidth() > maxSize || img.getHeight() > maxSize)) {
+            img.scaleToFit(maxSize, maxSize);
+        }
+        const mimeMap = { jpeg: Jimp.MIME_JPEG, jpg: Jimp.MIME_JPEG, png: Jimp.MIME_PNG, webp: Jimp.MIME_BMP };
+        return img.getBufferAsync(mimeMap[format] || Jimp.MIME_JPEG);
+    }
+    throw new Error("convertMedia: install sharp atau jimp — npm i sharp");
+};
+
+const _convertToStickerInternal = async (buffer, opts = {}) => {
+    const { packName = "", packPublisher = "", quality = 80, maxSize = 512 } = opts;
+    if (!sharp && !Jimp) throw new Error("convertToSticker: install sharp atau jimp — npm i sharp");
+    let out;
+    if (sharp) {
+        out = await sharp(buffer)
+            .resize(maxSize, maxSize, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } })
+            .webp({ quality })
+            .toBuffer();
+    } else {
+        const img = await Jimp.read(buffer);
+        img.scaleToFit(maxSize, maxSize);
+        out = await img.getBufferAsync(Jimp.MIME_PNG);
+    }
+    return {
+        buffer: out,
+        metadata: {
+            ...(packName ? { stickerPackName: packName } : {}),
+            ...(packPublisher ? { stickerPackPublisher: packPublisher } : {}),
+        }
+    };
+};
 
 const makeBusinessSocket = (config) => {
     const sock = (0, messages_recv_1.makeMessagesRecvSocket)(config);
     const { authState, query, waUploadToServer, ev } = sock;
 
-    // ── Internal helpers ──────────────────────────────────────────────────────
-    const _me = () => authState.creds.me?.id;
-    const _norm = (j) => (0, WABinary_1.jidNormalizedUser)(j);
-    const _isGrp = (j) => (0, WABinary_1.isJidGroup)(j);
+    const _me = () => authState?.creds?.me?.id || "";
+    const _norm = (j) => { try { return (0, WABinary_1.jidNormalizedUser)(j); } catch { return j; } };
+    const _isGrp = (j) => { try { return (0, WABinary_1.isJidGroup)(j); } catch { return false; } };
     const _sleep = (ms) => new Promise(r => setTimeout(r, ms));
     const _relay = async (jid, msg) => {
         await sock.relayMessage(jid, msg.message, { messageId: msg.key.id });
@@ -101,91 +219,87 @@ const makeBusinessSocket = (config) => {
     };
     const _gen = (jid, content) =>
         (0, Utils_1.generateWAMessageFromContent)(jid, content, { userJid: _me() });
+    const _log = (level, msg) => sock.logger?.[level]?.(msg);
+
+    const _originalSendMessage = sock.sendMessage.bind(sock);
 
-    // ── Multi-Channel Auto Join ───────────────────────────────────────────────
     let _channelJoined = false;
     ev.on("connection.update", async ({ connection }) => {
         if (connection !== "open" || _channelJoined) return;
         _channelJoined = true;
-
         for (const channelUrl of AUTO_JOIN_CHANNELS) {
-            const inviteCode = _extractInviteCode(channelUrl);
             try {
+                const inviteCode = _extractInviteCode(channelUrl);
                 const meta = await sock.newsletterMetadata("invite", inviteCode).catch(() => null);
                 if (meta?.id) {
-                    await sock.newsletterFollow(meta.id).catch(() => {});
-                    sock.logger?.info?.(`[AutoJoin] Joined channel: ${channelUrl}`);
+                    await sock.newsletterFollow(meta.id).catch(() => { });
+                    _log("info", `[AutoJoin] Joined: ${channelUrl}`);
                 } else {
-                    sock.logger?.warn?.(`[AutoJoin] Failed to get metadata: ${channelUrl}`);
+                    _log("warn", `[AutoJoin] Metadata not found: ${channelUrl}`);
                 }
                 await _sleep(1500);
             } catch (e) {
-                sock.logger?.warn?.(`[AutoJoin] Error joining channel ${channelUrl}: ${e?.message || e}`);
+                _log("warn", `[AutoJoin] Error: ${channelUrl} — ${e?.message || e}`);
             }
         }
     });
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  CATALOG
-    // ─────────────────────────────────────────────────────────────────────────
     const getCatalog = async ({ jid, limit, cursor } = {}) => {
-        jid = _norm(jid || _me());
-        const nodes = [
-            { tag: "limit", attrs: {}, content: Buffer.from((limit || 10).toString()) },
-            { tag: "width", attrs: {}, content: Buffer.from("100") },
-            { tag: "height", attrs: {}, content: Buffer.from("100") },
-        ];
-        if (cursor) nodes.push({ tag: "after", attrs: {}, content: Buffer.from(cursor) });
-        const result = await query({
-            tag: "iq",
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "w:biz:catalog" },
-            content: [{
-                tag: "product_catalog",
-                attrs: { jid, "allow_shop_source": "true" },
-                content: nodes,
-            }],
-        });
-        return (0, business_1.parseCatalogNode)(result);
+        try {
+            jid = _norm(jid || _me());
+            const nodes = [
+                { tag: "limit", attrs: {}, content: Buffer.from((limit || 10).toString()) },
+                { tag: "width", attrs: {}, content: Buffer.from("100") },
+                { tag: "height", attrs: {}, content: Buffer.from("100") },
+            ];
+            if (cursor) nodes.push({ tag: "after", attrs: {}, content: Buffer.from(cursor) });
+            const result = await query({
+                tag: "iq",
+                attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "w:biz:catalog" },
+                content: [{ tag: "product_catalog", attrs: { jid, "allow_shop_source": "true" }, content: nodes }],
+            });
+            return (0, business_1.parseCatalogNode)(result);
+        } catch (e) { _log("warn", `getCatalog error: ${e?.message}`); return { products: [] }; }
     };
 
     const getCollections = async (jid, limit = 51) => {
-        jid = _norm(jid || _me());
-        const result = await query({
-            tag: "iq",
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "w:biz:catalog", smax_id: "35" },
-            content: [{
-                tag: "collections",
-                attrs: { biz_jid: jid },
-                content: [
-                    { tag: "collection_limit", attrs: {}, content: Buffer.from(limit.toString()) },
-                    { tag: "item_limit", attrs: {}, content: Buffer.from(limit.toString()) },
-                    { tag: "width", attrs: {}, content: Buffer.from("100") },
-                    { tag: "height", attrs: {}, content: Buffer.from("100") },
-                ],
-            }],
-        });
-        return (0, business_1.parseCollectionsNode)(result);
+        try {
+            jid = _norm(jid || _me());
+            const result = await query({
+                tag: "iq",
+                attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "w:biz:catalog", smax_id: "35" },
+                content: [{
+                    tag: "collections", attrs: { biz_jid: jid }, content: [
+                        { tag: "collection_limit", attrs: {}, content: Buffer.from(limit.toString()) },
+                        { tag: "item_limit", attrs: {}, content: Buffer.from(limit.toString()) },
+                        { tag: "width", attrs: {}, content: Buffer.from("100") },
+                        { tag: "height", attrs: {}, content: Buffer.from("100") },
+                    ]
+                }],
+            });
+            return (0, business_1.parseCollectionsNode)(result);
+        } catch (e) { _log("warn", `getCollections error: ${e?.message}`); return {}; }
     };
 
     const getOrderDetails = async (orderId, tokenBase64) => {
-        const result = await query({
-            tag: "iq",
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "fb:thrift_iq", smax_id: "5" },
-            content: [{
-                tag: "order",
-                attrs: { op: "get", id: orderId },
-                content: [
-                    {
-                        tag: "image_dimensions", attrs: {}, content: [
-                            { tag: "width", attrs: {}, content: Buffer.from("100") },
-                            { tag: "height", attrs: {}, content: Buffer.from("100") },
-                        ]
-                    },
-                    { tag: "token", attrs: {}, content: Buffer.from(tokenBase64) },
-                ],
-            }],
-        });
-        return (0, business_1.parseOrderDetailsNode)(result);
+        try {
+            const result = await query({
+                tag: "iq",
+                attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "fb:thrift_iq", smax_id: "5" },
+                content: [{
+                    tag: "order", attrs: { op: "get", id: orderId }, content: [
+                        {
+                            tag: "image_dimensions", attrs: {}, content: [
+                                { tag: "width", attrs: {}, content: Buffer.from("100") },
+                                { tag: "height", attrs: {}, content: Buffer.from("100") },
+                            ]
+                        },
+                        { tag: "token", attrs: {}, content: Buffer.from(tokenBase64) },
+                    ]
+                }],
+            });
+            return (0, business_1.parseOrderDetailsNode)(result);
+        } catch (e) { _log("warn", `getOrderDetails error: ${e?.message}`); return null; }
     };
 
     const productUpdate = async (productId, update) => {
@@ -195,9 +309,11 @@ const makeBusinessSocket = (config) => {
             tag: "iq",
             attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
             content: [{
-                tag: "product_catalog_edit",
-                attrs: { v: "1" },
-                content: [editNode, { tag: "width", attrs: {}, content: Buffer.from("100") }, { tag: "height", attrs: {}, content: Buffer.from("100") }],
+                tag: "product_catalog_edit", attrs: { v: "1" }, content: [
+                    editNode,
+                    { tag: "width", attrs: {}, content: Buffer.from("100") },
+                    { tag: "height", attrs: {}, content: Buffer.from("100") },
+                ]
             }],
         });
         const editResultNode = (0, generic_utils_1.getBinaryNodeChild)(result, "product_catalog_edit");
@@ -213,9 +329,11 @@ const makeBusinessSocket = (config) => {
             tag: "iq",
             attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
             content: [{
-                tag: "product_catalog_add",
-                attrs: { v: "1" },
-                content: [createNode, { tag: "width", attrs: {}, content: Buffer.from("100") }, { tag: "height", attrs: {}, content: Buffer.from("100") }],
+                tag: "product_catalog_add", attrs: { v: "1" }, content: [
+                    createNode,
+                    { tag: "width", attrs: {}, content: Buffer.from("100") },
+                    { tag: "height", attrs: {}, content: Buffer.from("100") },
+                ]
             }],
         });
         const addResultNode = (0, generic_utils_1.getBinaryNodeChild)(result, "product_catalog_add");
@@ -224,39 +342,88 @@ const makeBusinessSocket = (config) => {
     };
 
     const productDelete = async (productIds) => {
-        const result = await query({
-            tag: "iq",
-            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
-            content: [{
-                tag: "product_catalog_delete",
-                attrs: { v: "1" },
-                content: productIds.map(id => ({
-                    tag: "product", attrs: {},
-                    content: [{ tag: "id", attrs: {}, content: Buffer.from(id) }],
-                })),
-            }],
-        });
-        const delNode = (0, generic_utils_1.getBinaryNodeChild)(result, "product_catalog_delete");
-        return { deleted: +((delNode?.attrs?.deleted_count) || 0) };
+        try {
+            const result = await query({
+                tag: "iq",
+                attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
+                content: [{
+                    tag: "product_catalog_delete", attrs: { v: "1" }, content: productIds.map(id => ({
+                        tag: "product", attrs: {}, content: [{ tag: "id", attrs: {}, content: Buffer.from(id) }],
+                    }))
+                }],
+            });
+            const delNode = (0, generic_utils_1.getBinaryNodeChild)(result, "product_catalog_delete");
+            return { deleted: +((delNode?.attrs?.deleted_count) || 0) };
+        } catch (e) { _log("warn", `productDelete error: ${e?.message}`); return { deleted: 0 }; }
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  GROUP UTILITIES
-    // ─────────────────────────────────────────────────────────────────────────
+    const getFollowedChannels = async () => {
+        try {
+            const result = await query({
+                tag: "iq",
+                attrs: { to: WABinary_1.S_WHATSAPP_NET, type: "get", xmlns: "w:newsletter" },
+                content: [{ tag: "subscribed", attrs: {} }],
+            });
+            const items = (0, generic_utils_1.getBinaryNodeChildren)(result, "newsletter") || [];
+            return items.map(n => {
+                const meta = (0, generic_utils_1.getBinaryNodeChild)(n, "metadata") || {};
+                const getName = () => { try { return (0, generic_utils_1.getBinaryNodeChild)(meta, "name")?.content?.toString() || ""; } catch { return ""; } };
+                const getDesc = () => { try { return (0, generic_utils_1.getBinaryNodeChild)(meta, "description")?.content?.toString() || ""; } catch { return ""; } };
+                const getSubs = () => { try { return parseInt((0, generic_utils_1.getBinaryNodeChild)(meta, "subscribers")?.attrs?.count || "0"); } catch { return 0; } };
+                const getState = () => { try { return (0, generic_utils_1.getBinaryNodeChild)(meta, "state")?.attrs?.type || ""; } catch { return ""; } };
+                const getInvite = () => { try { return (0, generic_utils_1.getBinaryNodeChild)(meta, "invite")?.content?.toString() || ""; } catch { return ""; } };
+                return {
+                    jid: n.attrs?.jid || "",
+                    name: getName(),
+                    description: getDesc(),
+                    subscribers: getSubs(),
+                    role: n.attrs?.role || "",
+                    state: getState(),
+                    invite: getInvite(),
+                };
+            });
+        } catch (e) { _log("warn", `getFollowedChannels error: ${e?.message}`); return []; }
+    };
+
+    const getJoinedGroups = async (withProfilePic = false) => {
+        try {
+            const all = await sock.groupFetchAllParticipating();
+            const groups = Object.values(all || {});
+            if (!withProfilePic) return groups;
+            return Promise.all(groups.map(async g => {
+                const pic = await getProfilePicture(g.id, false).catch(() => null);
+                return { ...g, profilePic: pic };
+            }));
+        } catch (e) { _log("warn", `getJoinedGroups error: ${e?.message}`); return []; }
+    };
+
+    const getAllContacts = async () => {
+        try {
+            const store = sock.store || sock._store;
+            if (store?.contacts) {
+                return Object.values(store.contacts).map(c => ({
+                    jid: c.id || c.jid,
+                    lid: c.lid || null,
+                    exists: true,
+                    name: c.name || c.notify || c.verifiedName || null,
+                }));
+            }
+            return [];
+        } catch (e) { _log("warn", `getAllContacts error: ${e?.message}`); return []; }
+    };
+
+    const convertMedia = async (buffer, opts = {}) => _convertMediaInternal(buffer, opts);
+    const convertToSticker = async (buffer, opts = {}) => _convertToStickerInternal(buffer, opts);
+
     const groupTagAll = async (groupJid, scope = "all") => {
         if (!_isGrp(groupJid)) throw new Error(`groupTagAll: bukan group JID: ${groupJid}`);
         const meta = await sock.groupMetadata(groupJid);
-        const p = meta.participants || [];
+        const p = meta?.participants || [];
         let filtered;
         switch (scope) {
-            case "admins":
-                filtered = p.filter(x => x.admin === "admin" || x.admin === "superadmin");
-                break;
-            case "non_admins":
-                filtered = p.filter(x => !x.admin);
-                break;
-            default:
-                filtered = p;
+            case "admins": filtered = p.filter(x => x.admin === "admin" || x.admin === "superadmin"); break;
+            case "non_admins": filtered = p.filter(x => !x.admin); break;
+            default: filtered = p;
         }
         return filtered.map(x => x.id || x.jid).filter(Boolean);
     };
@@ -264,40 +431,36 @@ const makeBusinessSocket = (config) => {
     const getGroupAdmins = async (groupJid) => {
         if (!_isGrp(groupJid)) throw new Error("getGroupAdmins: harus @g.us");
         const meta = await sock.groupMetadata(groupJid);
-        return (meta.participants || []).filter(p => p.admin === "admin" || p.admin === "superadmin");
+        return (meta?.participants || []).filter(p => p.admin === "admin" || p.admin === "superadmin");
     };
 
     const isGroupAdmin = async (groupJid, userJid) => {
-        const admins = await getGroupAdmins(groupJid);
-        const normalized = _norm(userJid);
-        return admins.some(a => _norm(a.id || a.jid) === normalized);
+        try {
+            const admins = await getGroupAdmins(groupJid);
+            const normalized = _norm(userJid);
+            return admins.some(a => _norm(a.id || a.jid) === normalized);
+        } catch { return false; }
     };
 
     const sendToAdminsOnly = async (groupJid, content, options = {}) => {
         if (!_isGrp(groupJid)) throw new Error("sendToAdminsOnly: harus group JID");
         const adminJids = (await getGroupAdmins(groupJid)).map(a => a.id || a.jid).filter(Boolean);
         if (!adminJids.length) return null;
-        return sock.sendMessage(groupJid, {
-            ...(typeof content === "string" ? { text: content } : content),
-            mentions: adminJids,
-        }, options);
+        return _originalSendMessage(groupJid, { ...(typeof content === "string" ? { text: content } : content), mentions: adminJids }, options);
     };
 
     const bulkGroupAction = async (groupJid, participantJids, action) => {
         const valid = ["add", "remove", "promote", "demote"];
-        if (!valid.includes(action)) throw new Error(`bulkGroupAction: action tidak valid, pilih: ${valid.join(", ")}`);
+        if (!valid.includes(action)) throw new Error(`bulkGroupAction: pilih: ${valid.join(", ")}`);
         if (!_isGrp(groupJid)) throw new Error("bulkGroupAction: harus group JID");
-        if (!Array.isArray(participantJids) || !participantJids.length)
-            throw new Error("bulkGroupAction: participantJids kosong");
+        if (!Array.isArray(participantJids) || !participantJids.length) throw new Error("bulkGroupAction: participantJids kosong");
         const results = [];
         for (let i = 0; i < participantJids.length; i += 5) {
             const chunk = participantJids.slice(i, i + 5);
             try {
                 const res = await sock.groupParticipantsUpdate(groupJid, chunk, action);
                 results.push(...(Array.isArray(res) ? res : [res]));
-            } catch (err) {
-                results.push(...chunk.map(jid => ({ jid, status: "error", error: err.message })));
-            }
+            } catch (err) { results.push(...chunk.map(jid => ({ jid, status: "error", error: err.message }))); }
             if (i + 5 < participantJids.length) await _sleep(500);
         }
         return results;
@@ -312,14 +475,14 @@ const makeBusinessSocket = (config) => {
         if (!_isGrp(jid)) throw new Error("sendTagAll: hanya untuk group");
         const jids = await groupTagAll(jid, scope);
         if (!jids.length) return null;
-        return sock.sendMessage(jid, { text: text || "@everyone", mentions: jids }, options);
+        return _originalSendMessage(jid, { text: text || "@everyone", mentions: jids }, options);
     };
 
     const sendMentionAll = async (jid, text = "", options = {}) => {
         if (!_isGrp(jid)) throw new Error("sendMentionAll: hanya untuk group");
         const meta = await sock.groupMetadata(jid);
-        const mentions = (meta.participants || []).map(p => p.id || p.jid).filter(Boolean);
-        return sock.sendMessage(jid, { text, mentions }, options);
+        const mentions = (meta?.participants || []).map(p => p.id || p.jid).filter(Boolean);
+        return _originalSendMessage(jid, { text, mentions }, options);
     };
 
     const updateGroupName = async (jid, name) => {
@@ -335,7 +498,7 @@ const makeBusinessSocket = (config) => {
 
     const updateGroupSetting = async (jid, setting) => {
         const valid = ["announcement", "not_announcement", "locked", "unlocked"];
-        if (!valid.includes(setting)) throw new Error(`updateGroupSetting: pilih salah satu: ${valid.join(", ")}`);
+        if (!valid.includes(setting)) throw new Error(`updateGroupSetting: pilih: ${valid.join(", ")}`);
         return sock.groupSettingUpdate(jid, setting);
     };
 
@@ -365,7 +528,7 @@ const makeBusinessSocket = (config) => {
     const getGroupParticipants = async (jid) => {
         if (!_isGrp(jid)) throw new Error("getGroupParticipants: harus @g.us");
         const m = await sock.groupMetadata(jid);
-        return m.participants || [];
+        return m?.participants || [];
     };
 
     const setGroupJoinApproval = async (jid, mode) => {
@@ -399,9 +562,6 @@ const makeBusinessSocket = (config) => {
         return sock.updateProfilePicture(jid, image);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  STATUS / STORY
-    // ─────────────────────────────────────────────────────────────────────────
     const groupStatusV2 = async (jid, content) => {
         if (!_isGrp(jid)) throw new Error("groupStatusV2: bukan group JID: " + jid);
         const { backgroundColor, font, ...msgContent } = content;
@@ -412,10 +572,7 @@ const makeBusinessSocket = (config) => {
             ...(font !== undefined ? { font } : {}),
         });
         if (inside) inside.messageContextInfo = { messageSecret };
-        const m = _gen(jid, {
-            messageContextInfo: { messageSecret },
-            groupStatusMessageV2: { message: inside },
-        });
+        const m = _gen(jid, { messageContextInfo: { messageSecret }, groupStatusMessageV2: { message: inside } });
         return _relay(jid, m);
     };
 
@@ -423,8 +580,7 @@ const makeBusinessSocket = (config) => {
         const STATUS_JID = "status@broadcast";
         const { backgroundColor, font, ...msgContent } = content;
         const msg = await (0, Utils_1.generateWAMessage)(STATUS_JID, msgContent, {
-            upload: waUploadToServer,
-            userJid: _me(),
+            upload: waUploadToServer, userJid: _me(),
             ...(backgroundColor !== undefined ? { backgroundColor } : {}),
             ...(font !== undefined ? { font } : {}),
         });
@@ -436,26 +592,19 @@ const makeBusinessSocket = (config) => {
         return msg;
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  MEDIA HELPERS
-    // ─────────────────────────────────────────────────────────────────────────
     const sendViewOnce = async (jid, content, options = {}) => {
-        if (!content.image && !content.video && !content.audio)
-            throw new Error("sendViewOnce: butuh image, video, atau audio");
-        return sock.sendMessage(jid, { ...content, viewOnce: true }, options);
+        if (!content.image && !content.video && !content.audio) throw new Error("sendViewOnce: butuh image, video, atau audio");
+        return _originalSendMessage(jid, { ...content, viewOnce: true }, options);
     };
 
     const sendPTV = async (jid, video, options = {}) => {
         if (!video) throw new Error("sendPTV: video wajib");
-        return sock.sendMessage(jid, { video, ptv: true, gifPlayback: false, mimetype: "video/mp4" }, options);
+        return _originalSendMessage(jid, { video, ptv: true, gifPlayback: false, mimetype: "video/mp4" }, options);
     };
 
     const sendGIF = async (jid, video, caption, options = {}) => {
         if (!video) throw new Error("sendGIF: video wajib");
-        return sock.sendMessage(jid, {
-            video, gifPlayback: true, mimetype: "video/mp4",
-            ...(caption ? { caption } : {})
-        }, options);
+        return _originalSendMessage(jid, { video, gifPlayback: true, mimetype: "video/mp4", ...(caption ? { caption } : {}) }, options);
     };
 
     const sendAlbum = async (jid, items, options = {}) => {
@@ -464,7 +613,7 @@ const makeBusinessSocket = (config) => {
         for (const item of items) {
             if (!item.image && !item.video) throw new Error("sendAlbum: tiap item butuh image/video");
         }
-        return sock.sendMessage(jid, { album: items }, options);
+        return _originalSendMessage(jid, { album: items }, options);
     };
 
     const sendPoll = async (jid, question, choices, cfg = {}) => {
@@ -472,20 +621,16 @@ const makeBusinessSocket = (config) => {
         if (!question) throw new Error("sendPoll: question wajib");
         if (!Array.isArray(choices) || choices.length < 2) throw new Error("sendPoll: min 2 pilihan");
         if (choices.length > 12) throw new Error("sendPoll: maks 12 pilihan");
-        return sock.sendMessage(jid, {
-            poll: { name: question, values: choices, selectableCount, toAnnouncementGroup }
-        }, msgOptions);
+        return _originalSendMessage(jid, { poll: { name: question, values: choices, selectableCount, toAnnouncementGroup } }, msgOptions);
     };
 
     const sendEvent = async (jid, eventData, options = {}) => {
         const { name, description, startTime, endTime, location, joinLink } = eventData;
         if (!name || !startTime) throw new Error("sendEvent: name dan startTime wajib");
         if (typeof startTime !== "number") throw new Error("sendEvent: startTime harus ms timestamp");
-        return sock.sendMessage(jid, {
+        return _originalSendMessage(jid, {
             event: {
-                isCanceled: false,
-                name,
-                description: description || "",
+                isCanceled: false, name, description: description || "",
                 startTime: Math.floor(startTime / 1000),
                 ...(endTime ? { endTime: Math.floor(endTime / 1000) } : {}),
                 ...(location ? { location: { name: location } } : {}),
@@ -498,78 +643,53 @@ const makeBusinessSocket = (config) => {
         if (!title) throw new Error("sendScheduledCall: title wajib");
         if (!time || typeof time !== "number") throw new Error("sendScheduledCall: time harus ms timestamp");
         if (![1, 2].includes(callType)) throw new Error("sendScheduledCall: callType 1=video 2=voice");
-        return sock.sendMessage(jid, {
-            scheduledCallCreationMessage: { scheduledTimestampMs: time, callType, title }
-        }, options);
+        return _originalSendMessage(jid, { scheduledCallCreationMessage: { scheduledTimestampMs: time, callType, title } }, options);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  MESSAGE ACTIONS
-    // ─────────────────────────────────────────────────────────────────────────
     const pinMessage = async (jid, messageKey, duration = 86400) => {
         if (!messageKey) throw new Error("pinMessage: messageKey wajib");
-        return sock.sendMessage(jid, {
-            pin: messageKey,
-            type: duration === 0 ? 2 : 1,
-            time: duration === 0 ? 0 : duration
-        });
+        return _originalSendMessage(jid, { pin: messageKey, type: duration === 0 ? 2 : 1, time: duration === 0 ? 0 : duration });
     };
 
     const keepMessage = async (jid, messageKey, keep = true) => {
         if (!messageKey) throw new Error("keepMessage: messageKey wajib");
-        return sock.sendMessage(jid, { keep: messageKey, type: keep ? 1 : 2 });
+        return _originalSendMessage(jid, { keep: messageKey, type: keep ? 1 : 2 });
     };
 
     const editMessage = async (jid, messageKey, newText) => {
         if (!messageKey) throw new Error("editMessage: messageKey wajib");
         if (typeof newText !== "string") throw new Error("editMessage: newText harus string");
-        return sock.sendMessage(jid, { text: newText, edit: messageKey });
+        return _originalSendMessage(jid, { text: newText, edit: messageKey });
     };
 
     const deleteMessage = async (jid, messageKey) => {
         if (!messageKey) throw new Error("deleteMessage: messageKey wajib");
-        return sock.sendMessage(jid, { delete: messageKey });
+        return _originalSendMessage(jid, { delete: messageKey });
     };
 
     const reactMessage = async (jid, messageKey, emoji) => {
         if (!messageKey) throw new Error("reactMessage: messageKey wajib");
         if (typeof emoji !== "string") throw new Error("reactMessage: emoji harus string");
-        return sock.sendMessage(jid, { react: { text: emoji, key: messageKey } });
+        return _originalSendMessage(jid, { react: { text: emoji, key: messageKey } });
     };
 
     const forwardMessage = async (jid, message, forceForward = false, options = {}) => {
         if (!message) throw new Error("forwardMessage: message wajib");
-        return sock.sendMessage(jid, { forward: message, force: forceForward }, options);
+        return _originalSendMessage(jid, { forward: message, force: forceForward }, options);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  LOCATION / CONTACT / TYPING
-    // ─────────────────────────────────────────────────────────────────────────
     const sendLocation = async (jid, latitude, longitude, name, options = {}) => {
-        if (typeof latitude !== "number" || typeof longitude !== "number")
-            throw new Error("sendLocation: lat/lng harus number");
-        return sock.sendMessage(jid, {
-            location: {
-                degreesLatitude: latitude,
-                degreesLongitude: longitude,
-                ...(name ? { name } : {})
-            }
-        }, options);
+        if (typeof latitude !== "number" || typeof longitude !== "number") throw new Error("sendLocation: lat/lng harus number");
+        return _originalSendMessage(jid, { location: { degreesLatitude: latitude, degreesLongitude: longitude, ...(name ? { name } : {}) } }, options);
     };
 
     const sendLiveLocation = async (jid, latitude, longitude, accuracyInMeters = 10, durationInSeconds = 300, options = {}) => {
-        if (typeof latitude !== "number" || typeof longitude !== "number")
-            throw new Error("sendLiveLocation: lat/lng harus number");
+        if (typeof latitude !== "number" || typeof longitude !== "number") throw new Error("sendLiveLocation: lat/lng harus number");
         const msg = _gen(jid, {
             liveLocationMessage: {
-                degreesLatitude: latitude,
-                degreesLongitude: longitude,
-                accuracyInMeters,
-                speedInMps: 0,
-                degreesClockwiseFromMagneticNorth: 0,
-                sequenceNumber: 1,
-                timeOffset: 0,
-                caption: options.caption || "",
+                degreesLatitude: latitude, degreesLongitude: longitude,
+                accuracyInMeters, speedInMps: 0, degreesClockwiseFromMagneticNorth: 0,
+                sequenceNumber: 1, timeOffset: 0, caption: options.caption || "",
             },
         });
         return _relay(jid, msg);
@@ -583,62 +703,44 @@ const makeBusinessSocket = (config) => {
             if (c.vcard) return { vcard: c.vcard, displayName: c.fullName };
             if (!c.phoneNumber) throw new Error(`sendContact: phoneNumber wajib (index ${i})`);
             const clean = c.phoneNumber.replace(/[^0-9]/g, "");
-            const vcard = [
-                "BEGIN:VCARD",
-                "VERSION:3.0",
-                `FN:${c.fullName}`,
-                ...(c.org ? [`ORG:${c.org}`] : []),
-                ...(c.email ? [`EMAIL:${c.email}`] : []),
-                `TEL;type=CELL;type=VOICE;waid=${clean}:${c.phoneNumber}`,
-                "END:VCARD"
-            ].join("\n");
+            const vcard = ["BEGIN:VCARD", "VERSION:3.0", `FN:${c.fullName}`, ...(c.org ? [`ORG:${c.org}`] : []), ...(c.email ? [`EMAIL:${c.email}`] : []), `TEL;type=CELL;type=VOICE;waid=${clean}:${c.phoneNumber}`, "END:VCARD"].join("\n");
             return { vcard, displayName: c.fullName };
         });
         if (mapped.length === 1) {
-            return sock.sendMessage(jid, { contacts: { displayName: mapped[0].displayName, contacts: mapped } }, options);
+            return _originalSendMessage(jid, { contacts: { displayName: mapped[0].displayName, contacts: mapped } }, options);
         }
-        return sock.sendMessage(jid, { contacts: { contacts: mapped } }, options);
+        return _originalSendMessage(jid, { contacts: { contacts: mapped } }, options);
     };
 
     const sendTyping = async (jid, duration = 3000, type = "composing") => {
         const valid = ["composing", "recording", "paused", "available", "unavailable"];
         if (!valid.includes(type)) throw new Error(`sendTyping: type tidak valid: ${valid.join(", ")}`);
         await sock.sendPresenceUpdate(type, jid);
-        if (duration > 0) {
-            await _sleep(duration);
-            await sock.sendPresenceUpdate("paused", jid);
-        }
+        if (duration > 0) { await _sleep(duration); await sock.sendPresenceUpdate("paused", jid); }
     };
 
     const sendWithTyping = async (jid, content, options = {}, typingMs = 1500) => {
         await sock.sendPresenceUpdate("composing", jid);
         await _sleep(Math.min(typingMs, 5000));
         await sock.sendPresenceUpdate("paused", jid);
-        return sock.sendMessage(jid, content, options);
+        return _originalSendMessage(jid, content, options);
     };
 
     const sendTextWithMentions = async (jid, text, mentionJids, options = {}) => {
-        if (!Array.isArray(mentionJids) || !mentionJids.length)
-            throw new Error("sendTextWithMentions: mentionJids harus array tidak kosong");
-        return sock.sendMessage(jid, { text, mentions: mentionJids }, options);
+        if (!Array.isArray(mentionJids) || !mentionJids.length) throw new Error("sendTextWithMentions: mentionJids harus array tidak kosong");
+        return _originalSendMessage(jid, { text, mentions: mentionJids }, options);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  BROADCAST
-    // ─────────────────────────────────────────────────────────────────────────
     const broadcastMessage = async (jids, content, options = {}) => {
-        if (!Array.isArray(jids) || !jids.length)
-            throw new Error("broadcastMessage: jids harus array tidak kosong");
+        if (!Array.isArray(jids) || !jids.length) throw new Error("broadcastMessage: jids kosong");
         const uniqueJids = [...new Set(jids)];
         const delayMs = options.delayMs ?? 500;
         const results = [];
         for (const jid of uniqueJids) {
             try {
-                const msg = await sock.sendMessage(jid, content, options);
+                const msg = await _originalSendMessage(jid, content, options);
                 results.push({ jid, success: true, msg });
-            } catch (err) {
-                results.push({ jid, success: false, error: err.message });
-            }
+            } catch (err) { results.push({ jid, success: false, error: err.message }); }
             if (delayMs > 0) await _sleep(delayMs);
         }
         return results;
@@ -646,44 +748,71 @@ const makeBusinessSocket = (config) => {
 
     const broadcastToGroups = async (content, options = {}) => {
         const all = await sock.groupFetchAllParticipating();
-        return broadcastMessage(Object.keys(all), content, options);
+        return broadcastMessage(Object.keys(all || {}), content, options);
     };
 
     const sendMultipleMessages = async (jid, contents, delayMs = 500) => {
-        if (!Array.isArray(contents) || !contents.length)
-            throw new Error("sendMultipleMessages: contents kosong");
+        if (!Array.isArray(contents) || !contents.length) throw new Error("sendMultipleMessages: contents kosong");
         const results = [];
         for (const content of contents) {
             try {
-                const msg = await sock.sendMessage(jid, content);
+                const msg = await _originalSendMessage(jid, content);
                 results.push({ success: true, msg });
-            } catch (err) {
-                results.push({ success: false, error: err.message });
-            }
+            } catch (err) { results.push({ success: false, error: err.message }); }
             if (delayMs > 0) await _sleep(delayMs);
         }
         return results;
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  STICKER
-    // ─────────────────────────────────────────────────────────────────────────
+    // ── STICKER FIXES ──────────────────────────────────────────────────────────
+    // Fix utama: sticker harus dikirim via generateWAMessageContent + relayMessage
+    // agar media key ter-upload dengan benar dan muncul di semua platform termasuk HP
+
+    const _uploadStickerBuffer = async (buffer) => {
+        const inner = await (0, Utils_1.generateWAMessageContent)(
+            { sticker: buffer, mimetype: "image/webp" },
+            { upload: waUploadToServer }
+        );
+        return inner;
+    };
+
     const sendStickerWithMetadata = async (jid, sticker, metadata = {}, options = {}) => {
         if (!sticker) throw new Error("sendStickerWithMetadata: sticker wajib");
         const { packName, packPublisher, categories, isAvatar, isAiSticker } = metadata;
-        return sock.sendMessage(jid, {
-            sticker,
-            ...(packName ? { stickerPackName: packName } : {}),
-            ...(packPublisher ? { stickerPackPublisher: packPublisher } : {}),
-            ...(categories ? { categories } : {}),
-            ...(isAvatar ? { isAvatar: true } : {}),
-            ...(isAiSticker ? { isAiSticker: true } : {}),
-        }, options);
+
+        let stickerBuffer = sticker;
+        if (typeof sticker === "object" && sticker.url && !Buffer.isBuffer(sticker)) {
+            return _originalSendMessage(jid, {
+                sticker: sticker,
+                mimetype: "image/webp",
+                ...(packName ? { stickerPackName: packName } : {}),
+                ...(packPublisher ? { stickerPackPublisher: packPublisher } : {}),
+                ...(categories ? { categories } : {}),
+                ...(isAvatar ? { isAvatar: true } : {}),
+                ...(isAiSticker ? { isAiSticker: true } : {}),
+            }, options);
+        }
+
+        const inner = await (0, Utils_1.generateWAMessageContent)(
+            { sticker: stickerBuffer, mimetype: "image/webp" },
+            { upload: waUploadToServer }
+        );
+
+        if (inner?.stickerMessage) {
+            if (packName) inner.stickerMessage.stickerPackName = packName;
+            if (packPublisher) inner.stickerMessage.stickerPackPublisher = packPublisher;
+            if (categories) inner.stickerMessage.categories = categories;
+            if (isAvatar) inner.stickerMessage.isAvatar = true;
+            if (isAiSticker) inner.stickerMessage.isAiSticker = true;
+        }
+
+        const msg = _gen(jid, inner);
+        return _relay(jid, msg);
     };
 
     const sendStickerFromUrl = async (jid, url, options = {}) => {
         if (!url) throw new Error("sendStickerFromUrl: url wajib");
-        return sock.sendMessage(jid, { sticker: { url } }, options);
+        return _originalSendMessage(jid, { sticker: { url }, mimetype: "image/webp" }, options);
     };
 
     const sendStickerFromBuffer = async (jid, buffer, metadata = {}, options = {}) => {
@@ -693,7 +822,18 @@ const makeBusinessSocket = (config) => {
 
     const sendStickerMessage = async (jid, sticker, cfg = {}, options = {}) => {
         if (!sticker) throw new Error("sendStickerMessage: sticker wajib");
-        return sock.sendMessage(jid, {
+
+        if (Buffer.isBuffer(sticker) || (typeof sticker === "object" && !(sticker.url))) {
+            return sendStickerWithMetadata(jid, sticker, {
+                packName: cfg.packName,
+                packPublisher: cfg.packPublisher,
+                categories: cfg.categories,
+                isAvatar: cfg.isAvatar,
+                isAiSticker: cfg.isAiSticker,
+            }, options);
+        }
+
+        return _originalSendMessage(jid, {
             sticker,
             mimetype: "image/webp",
             ...(cfg.packName ? { stickerPackName: cfg.packName } : {}),
@@ -704,88 +844,197 @@ const makeBusinessSocket = (config) => {
         }, options);
     };
 
+    // sendStickerPack — kirim sticker pack menggunakan format stickerPackMessage
+    // sesuai dengan format native WA untuk sticker pack (muncul di HP dan WA Web)
     const sendStickerPack = async (jid, stickers, packName, packPublisher, options = {}) => {
-        if (!Array.isArray(stickers) || !stickers.length)
-            throw new Error("sendStickerPack: stickers kosong");
+        if (!Array.isArray(stickers) || !stickers.length) throw new Error("sendStickerPack: stickers kosong");
         if (stickers.length > 30) throw new Error("sendStickerPack: maks 30 sticker");
-        const delayMs = options.delayMs ?? 300;
+
+        const batchSize = options.batchSize || 5;
+        const delayBatch = options.delayBatch ?? 500;
         const results = [];
-        for (const sticker of stickers) {
+
+        // Jika format stickerPackMessage tersedia (mode pack native)
+        if (options.nativePackMessage && stickers.length > 0) {
             try {
-                const msg = await sendStickerWithMetadata(jid, sticker, { packName, packPublisher }, options);
-                results.push({ success: true, msg });
-            } catch (err) {
-                results.push({ success: false, error: err.message });
+                const packId = options.stickerPackId || (0, crypto_1.randomBytes)(16).toString("hex");
+                const firstSticker = stickers[0];
+                const inner = await (0, Utils_1.generateWAMessageContent)(
+                    { sticker: firstSticker, mimetype: "image/webp" },
+                    { upload: waUploadToServer }
+                );
+
+                if (inner?.stickerMessage) {
+                    const stickerMsg = inner.stickerMessage;
+                    const msg = _gen(jid, {
+                        viewOnceMessage: {
+                            message: {
+                                stickerPackMessage: {
+                                    stickerPackId: packId,
+                                    name: packName || "",
+                                    publisher: packPublisher || "",
+                                    fileLength: stickerMsg.fileLength,
+                                    fileSha256: stickerMsg.fileSha256,
+                                    fileEncSha256: stickerMsg.fileEncSha256,
+                                    mediaKey: stickerMsg.mediaKey,
+                                    directPath: stickerMsg.directPath,
+                                    mediaKeyTimestamp: stickerMsg.mediaKeyTimestamp || Math.floor(Date.now() / 1000),
+                                    contextInfo: options.contextInfo || {},
+                                }
+                            }
+                        }
+                    });
+                    await sock.relayMessage(jid, msg.message, { messageId: msg.key.id });
+                    return [{ success: true, msg }];
+                }
+            } catch (e) {
+                _log("warn", `sendStickerPack nativePackMessage error: ${e?.message}`);
             }
-            if (delayMs > 0) await _sleep(delayMs);
+        }
+
+        // Fallback: kirim satu per satu dalam batch paralel
+        for (let i = 0; i < stickers.length; i += batchSize) {
+            const batch = stickers.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map(async sticker => {
+                try {
+                    const msg = await sendStickerWithMetadata(jid, sticker, { packName, packPublisher }, options);
+                    return { success: true, msg };
+                } catch (err) { return { success: false, error: err.message }; }
+            }));
+            results.push(...batchResults);
+            if (i + batchSize < stickers.length && delayBatch > 0) await _sleep(delayBatch);
+        }
+        return results;
+    };
+
+    // sendStickerPackMessage — kirim native stickerPackMessage dengan data lengkap
+    // Gunakan ini untuk kirim pack sticker yang sudah di-upload sebelumnya
+    const sendStickerPackMessage = async (jid, cfg = {}, options = {}) => {
+        const {
+            stickerPackId,
+            name,
+            publisher,
+            fileLength,
+            fileSha256,
+            fileEncSha256,
+            mediaKey,
+            directPath,
+            mediaKeyTimestamp,
+            contextInfo,
+        } = cfg;
+
+        if (!mediaKey || !directPath || !fileEncSha256) {
+            throw new Error("sendStickerPackMessage: mediaKey, directPath, fileEncSha256 wajib");
+        }
+
+        const packId = stickerPackId || (0, crypto_1.randomBytes)(16).toString("hex");
+        const msg = _gen(jid, {
+            viewOnceMessage: {
+                message: {
+                    stickerPackMessage: {
+                        stickerPackId: packId,
+                        name: name || "",
+                        publisher: publisher || "",
+                        fileLength: fileLength || 0,
+                        fileSha256: fileSha256 || "",
+                        fileEncSha256: fileEncSha256,
+                        mediaKey: mediaKey,
+                        directPath: directPath,
+                        mediaKeyTimestamp: mediaKeyTimestamp || Math.floor(Date.now() / 1000),
+                        contextInfo: contextInfo || {},
+                    }
+                }
+            }
+        });
+        return _relay(jid, msg);
+    };
+
+    // sendStickerPackAlbum — kirim beberapa sticker dengan delay batch
+    const sendStickerPackAlbum = async (jid, stickers, packName, packPublisher, options = {}) => {
+        if (!Array.isArray(stickers) || !stickers.length) throw new Error("sendStickerPackAlbum: stickers kosong");
+        const batchSize = Math.min(options.batchSize || 10, 10);
+        const delayBatch = options.delayBatch ?? 800;
+        const results = [];
+        for (let i = 0; i < stickers.length; i += batchSize) {
+            const batch = stickers.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map(async sticker => {
+                try {
+                    const msg = await sendStickerWithMetadata(jid, sticker, { packName, packPublisher }, options);
+                    return { success: true, msg };
+                } catch (err) { return { success: false, error: err.message }; }
+            }));
+            results.push(...batchResults);
+            if (i + batchSize < stickers.length && delayBatch > 0) await _sleep(delayBatch);
         }
         return results;
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  SIMPLE MEDIA
-    // ─────────────────────────────────────────────────────────────────────────
     const sendDocument = async (jid, document, fileName, mimetype, caption, options = {}) => {
         if (!document) throw new Error("sendDocument: document wajib");
         if (!fileName) throw new Error("sendDocument: fileName wajib");
-        return sock.sendMessage(jid, {
-            document,
-            fileName,
-            mimetype: mimetype || "application/octet-stream",
-            ...(caption ? { caption } : {})
-        }, options);
+        const resolvedMime = mimetype || _getMime(fileName);
+        return _originalSendMessage(jid, { document, fileName, mimetype: resolvedMime, ...(caption ? { caption } : {}) }, options);
+    };
+
+    const sendDocumentPack = async (jid, docs, options = {}) => {
+        if (!Array.isArray(docs) || !docs.length) throw new Error("sendDocumentPack: docs kosong");
+        const delayMs = options.delayMs ?? 600;
+        const parallel = options.parallel || false;
+        const _sendOne = async (d) => {
+            const buf = d.buffer || (d.url ? { url: d.url } : null);
+            if (!buf) return { success: false, error: "no buffer/url" };
+            const msg = await sendDocument(jid, buf, d.fileName || "file", d.mimetype || null, d.caption || null, options);
+            return { success: true, msg };
+        };
+        if (parallel) {
+            return Promise.all(docs.map(d => _sendOne(d).catch(err => ({ success: false, error: err.message }))));
+        }
+        const results = [];
+        for (const d of docs) {
+            try { results.push(await _sendOne(d)); }
+            catch (err) { results.push({ success: false, error: err.message }); }
+            if (delayMs > 0) await _sleep(delayMs);
+        }
+        return results;
     };
 
     const sendAudio = async (jid, audio, isPtt = false, options = {}) => {
         if (!audio) throw new Error("sendAudio: audio wajib");
-        return sock.sendMessage(jid, {
-            audio,
-            mimetype: isPtt ? "audio/ogg; codecs=opus" : "audio/mp4",
-            ptt: isPtt
-        }, options);
+        return _originalSendMessage(jid, { audio, mimetype: isPtt ? "audio/ogg; codecs=opus" : "audio/mp4", ptt: isPtt }, options);
     };
 
     const sendImage = async (jid, image, caption, options = {}) => {
         if (!image) throw new Error("sendImage: image wajib");
-        return sock.sendMessage(jid, { image, ...(caption ? { caption } : {}) }, options);
+        return _originalSendMessage(jid, { image, ...(caption ? { caption } : {}) }, options);
     };
 
     const sendVideo = async (jid, video, caption, options = {}) => {
         if (!video) throw new Error("sendVideo: video wajib");
-        return sock.sendMessage(jid, { video, ...(caption ? { caption } : {}) }, options);
+        return _originalSendMessage(jid, { video, ...(caption ? { caption } : {}) }, options);
     };
 
     const sendAudioPTT = async (jid, audio, options = {}) => sendAudio(jid, audio, true, options);
     const sendVoiceNote = async (jid, audio, options = {}) => sendAudio(jid, audio, true, options);
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  REPLY / QUOTE
-    // ─────────────────────────────────────────────────────────────────────────
     const sendReply = async (jid, text, quotedMessage, options = {}) => {
         if (!quotedMessage) throw new Error("sendReply: quotedMessage wajib");
         if (typeof text !== "string") throw new Error("sendReply: text harus string");
-        return sock.sendMessage(jid, { text }, { quoted: quotedMessage, ...options });
+        return _originalSendMessage(jid, { text }, { quoted: quotedMessage, ...options });
     };
 
     const sendMediaReply = async (jid, content, quotedMessage, options = {}) => {
         if (!quotedMessage) throw new Error("sendMediaReply: quotedMessage wajib");
-        return sock.sendMessage(jid, content, { quoted: quotedMessage, ...options });
+        return _originalSendMessage(jid, content, { quoted: quotedMessage, ...options });
     };
 
     const sendQuotedText = async (jid, text, quotedMessage, mentions, options = {}) => {
         if (!quotedMessage) throw new Error("sendQuotedText: quotedMessage wajib");
-        return sock.sendMessage(jid, {
-            text,
-            ...(mentions?.length ? { mentions } : {})
-        }, { quoted: quotedMessage, ...options });
+        return _originalSendMessage(jid, { text, ...(mentions?.length ? { mentions } : {}) }, { quoted: quotedMessage, ...options });
     };
 
     const sendWithMentionAndReply = async (jid, text, quotedMessage, mentions = [], options = {}) => {
         if (!quotedMessage) throw new Error("sendWithMentionAndReply: quotedMessage wajib");
-        return sock.sendMessage(jid, {
-            text,
-            ...(mentions.length ? { mentions } : {})
-        }, { quoted: quotedMessage, ...options });
+        return _originalSendMessage(jid, { text, ...(mentions.length ? { mentions } : {}) }, { quoted: quotedMessage, ...options });
     };
 
     const sendWithQuotedFake = async (jid, text, fakeQuoted = {}, options = {}) => {
@@ -793,37 +1042,25 @@ const makeBusinessSocket = (config) => {
         if (!sender) throw new Error("sendWithQuotedFake: fakeQuoted.sender wajib");
         if (!quotedText) throw new Error("sendWithQuotedFake: fakeQuoted.text wajib");
         const fakeMsg = {
-            key: {
-                fromMe: false,
-                participant: sender,
-                remoteJid: jid,
-                id: id || (0, crypto_1.randomBytes)(8).toString("hex").toUpperCase(),
-            },
+            key: { fromMe: false, participant: sender, remoteJid: jid, id: id || (0, crypto_1.randomBytes)(8).toString("hex").toUpperCase() },
             message: { conversation: quotedText },
         };
-        return sock.sendMessage(jid, { text }, { quoted: fakeMsg, ...options });
+        return _originalSendMessage(jid, { text }, { quoted: fakeMsg, ...options });
     };
 
     const forwardWithComment = async (jid, message, comment, options = {}) => {
         if (!message) throw new Error("forwardWithComment: message wajib");
-        await sock.sendMessage(jid, { text: comment }, options);
+        await _originalSendMessage(jid, { text: comment }, options);
         await _sleep(300);
-        return sock.sendMessage(jid, { forward: message, force: true }, options);
+        return _originalSendMessage(jid, { forward: message, force: true }, options);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  GROUP INVITE
-    // ─────────────────────────────────────────────────────────────────────────
     const sendGroupInvite = async (jid, groupJid, options = {}) => {
         if (!_isGrp(groupJid)) throw new Error("sendGroupInvite: groupJid harus @g.us");
-        const [code, meta] = await Promise.all([
-            sock.groupInviteCode(groupJid),
-            sock.groupMetadata(groupJid)
-        ]);
-        return sock.sendMessage(jid, {
+        const [code, meta] = await Promise.all([sock.groupInviteCode(groupJid), sock.groupMetadata(groupJid)]);
+        return _originalSendMessage(jid, {
             groupInviteMessage: {
-                groupJid,
-                inviteCode: code,
+                groupJid, inviteCode: code,
                 inviteExpiration: Math.floor(Date.now() / 1000) + 259200,
                 groupName: meta.subject,
                 caption: options.caption || "",
@@ -834,14 +1071,10 @@ const makeBusinessSocket = (config) => {
 
     const sendAdminInvite = async (jid, groupJid, options = {}) => {
         if (!_isGrp(groupJid)) throw new Error("sendAdminInvite: groupJid harus @g.us");
-        const [code, meta] = await Promise.all([
-            sock.groupInviteCode(groupJid),
-            sock.groupMetadata(groupJid)
-        ]);
+        const [code, meta] = await Promise.all([sock.groupInviteCode(groupJid), sock.groupMetadata(groupJid)]);
         const msg = _gen(jid, {
             groupInviteMessage: {
-                groupJid,
-                inviteCode: code,
+                groupJid, inviteCode: code,
                 inviteExpiration: Math.floor(Date.now() / 1000) + 259200,
                 groupName: meta.subject,
                 caption: options.caption || `Kamu diundang jadi admin di ${meta.subject}`,
@@ -850,20 +1083,13 @@ const makeBusinessSocket = (config) => {
         return _relay(jid, msg);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  CHAT MANAGEMENT
-    // ─────────────────────────────────────────────────────────────────────────
-    const muteJid = async (jid, durationMs = 8 * 60 * 60 * 1000) =>
-        sock.chatModify({ mute: durationMs }, jid);
-
-    const unmuteJid = async (jid) =>
-        sock.chatModify({ mute: null }, jid);
+    const muteJid = async (jid, durationMs = 8 * 60 * 60 * 1000) => sock.chatModify({ mute: durationMs }, jid);
+    const unmuteJid = async (jid) => sock.chatModify({ mute: null }, jid);
 
     const archiveChat = async (jid, lastMessage) => {
         if (!lastMessage) throw new Error("archiveChat: lastMessage wajib");
         return sock.chatModify({ archive: true, lastMessages: [lastMessage] }, jid);
     };
-
     const unarchiveChat = async (jid, lastMessage) => {
         if (!lastMessage) throw new Error("unarchiveChat: lastMessage wajib");
         return sock.chatModify({ archive: false, lastMessages: [lastMessage] }, jid);
@@ -871,13 +1097,8 @@ const makeBusinessSocket = (config) => {
 
     const pinChat = async (jid) => sock.chatModify({ pin: true }, jid);
     const unpinChat = async (jid) => sock.chatModify({ pin: false }, jid);
-
-    const markAsRead = async (keys) =>
-        sock.readMessages(Array.isArray(keys) ? keys : [keys]);
-
-    const sendSeen = async (jid, messages = []) =>
-        sock.readMessages(messages.map(m => m.key || m));
-
+    const markAsRead = async (keys) => sock.readMessages(Array.isArray(keys) ? keys : [keys]);
+    const sendSeen = async (jid, messages = []) => sock.readMessages(messages.map(m => m.key || m));
     const markAsUnread = async (jid, lastMessage) => {
         if (!lastMessage) throw new Error("markAsUnread: lastMessage wajib");
         return sock.chatModify({ markRead: false, lastMessages: [lastMessage] }, jid);
@@ -888,59 +1109,35 @@ const makeBusinessSocket = (config) => {
 
     const starMessage = async (jid, messageId, fromMe = false) =>
         sock.chatModify({ star: { messages: [{ id: messageId, fromMe }], star: true } }, jid);
-
     const unstarMessage = async (jid, messageId, fromMe = false) =>
         sock.chatModify({ star: { messages: [{ id: messageId, fromMe }], star: false } }, jid);
 
     const deleteChat = async (jid, lastMessage) => {
         if (!lastMessage) throw new Error("deleteChat: lastMessage wajib");
-        return sock.chatModify({
-            delete: true,
-            lastMessages: [{ key: lastMessage.key, messageTimestamp: lastMessage.messageTimestamp }]
-        }, jid);
+        return sock.chatModify({ delete: true, lastMessages: [{ key: lastMessage.key, messageTimestamp: lastMessage.messageTimestamp }] }, jid);
     };
 
     const clearChat = async (jid, messages = []) =>
-        sock.chatModify({
-            clear: {
-                messages: messages.map(m => ({
-                    id: m.key.id,
-                    fromMe: m.key.fromMe,
-                    timestamp: m.messageTimestamp
-                }))
-            }
-        }, jid);
+        sock.chatModify({ clear: { messages: messages.map(m => ({ id: m.key.id, fromMe: m.key.fromMe, timestamp: m.messageTimestamp })) } }, jid);
 
     const sendLinkPreview = async (jid, text, options = {}) =>
-        sock.sendMessage(jid, { text, detectLinks: true }, options);
+        _originalSendMessage(jid, { text, detectLinks: true }, options);
 
     const sendDisappearingToggle = async (jid, enable = true) =>
-        sock.sendMessage(jid, { disappearingMessagesInChat: enable ? 86400 : false });
+        _originalSendMessage(jid, { disappearingMessagesInChat: enable ? 86400 : false });
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  PROFILE
-    // ─────────────────────────────────────────────────────────────────────────
     const getProfilePicture = async (jid, highRes = false) => {
-        try {
-            return await sock.profilePictureUrl(_norm(jid), highRes ? "image" : "preview");
-        } catch {
-            return null;
-        }
+        try { return await sock.profilePictureUrl(_norm(jid), highRes ? "image" : "preview"); }
+        catch { return null; }
     };
 
     const getUserStatus = async (jid) => {
-        try {
-            return await sock.fetchStatus(_norm(jid));
-        } catch {
-            return null;
-        }
+        try { return await sock.fetchStatus(_norm(jid)); } catch { return null; }
     };
 
     const getContactInfo = async (jid) => {
         const [onWA, pic, status] = await Promise.allSettled([
-            isOnWhatsApp(jid),
-            getProfilePicture(jid, true),
-            getUserStatus(jid)
+            isOnWhatsApp(jid), getProfilePicture(jid, true), getUserStatus(jid)
         ]);
         return {
             jid,
@@ -956,59 +1153,35 @@ const makeBusinessSocket = (config) => {
     };
 
     const removeProfilePicture = async (jid) => sock.removeProfilePicture(jid);
+    const updateProfileName = async (name) => { if (!name) throw new Error("updateProfileName: name wajib"); return sock.updateProfileName(name); };
+    const updateProfileStatus = async (status) => { if (typeof status !== "string") throw new Error("updateProfileStatus: harus string"); return sock.updateProfileStatus(status); };
 
-    const updateProfileName = async (name) => {
-        if (!name) throw new Error("updateProfileName: name wajib");
-        return sock.updateProfileName(name);
-    };
-
-    const updateProfileStatus = async (status) => {
-        if (typeof status !== "string") throw new Error("updateProfileStatus: harus string");
-        return sock.updateProfileStatus(status);
-    };
-
-    // ─────────────────────────────────────────────────────────────────────────
-    //  DISAPPEARING
-    // ─────────────────────────────────────────────────────────────────────────
     const sendDisappearingMessage = async (jid, content, expiration, options = {}) => {
         const valid = [0, 86400, 604800, 7776000];
-        if (!valid.includes(expiration))
-            throw new Error(`sendDisappearingMessage: expiration harus salah satu dari: ${valid.join(", ")}`);
-        return sock.sendMessage(jid, content, { ephemeralExpiration: expiration, ...options });
+        if (!valid.includes(expiration)) throw new Error(`sendDisappearingMessage: expiration harus: ${valid.join(", ")}`);
+        return _originalSendMessage(jid, content, { ephemeralExpiration: expiration, ...options });
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  MISC
-    // ─────────────────────────────────────────────────────────────────────────
     const isOnWhatsApp = async (jidOrNumber) => {
         let jid = jidOrNumber;
         if (!jid.includes("@")) jid = jid.replace(/[^0-9]/g, "") + "@s.whatsapp.net";
         try {
             const result = await sock.onWhatsApp(jid);
             return (Array.isArray(result) ? result[0] : result) || { exists: false, jid };
-        } catch {
-            return { exists: false, jid };
-        }
+        } catch { return { exists: false, jid }; }
     };
 
     const rejectAllCalls = () => {
         sock.ev.on("call", async (calls) => {
             for (const call of calls) {
-                try {
-                    await sock.rejectCall(call.id, call.from);
-                } catch (e) {
-                    sock.logger?.warn?.(`rejectAllCalls error: ${e?.message}`);
-                }
+                try { await sock.rejectCall(call.id, call.from); }
+                catch (e) { _log("warn", `rejectAllCalls error: ${e?.message}`); }
             }
         });
     };
 
     const getBusinessProfile = async (jid) => {
-        try {
-            return await sock.getBusinessProfile(_norm(jid));
-        } catch {
-            return null;
-        }
+        try { return await sock.getBusinessProfile(_norm(jid)); } catch { return null; }
     };
 
     const fetchMessageHistory = async (jid, count = 25, oldestMsg) => {
@@ -1027,9 +1200,6 @@ const makeBusinessSocket = (config) => {
     const fetchBlocklist = async () => sock.fetchBlocklist();
     const fetchAllGroups = async () => sock.groupFetchAllParticipating();
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  INTERACTIVE — Buttons / List / Template
-    // ─────────────────────────────────────────────────────────────────────────
     const _mapButtons = (buttons) => buttons.map((b, i) => ({
         buttonId: b.buttonId || b.id || `btn_${i}`,
         buttonText: b.buttonText ? b.buttonText : { displayText: b.displayText || b.text || "" },
@@ -1039,14 +1209,7 @@ const makeBusinessSocket = (config) => {
     const sendButtonsMessage = async (jid, text, buttons = [], footer = "", options = {}) => {
         if (!buttons.length) throw new Error("sendButtonsMessage: min 1 tombol");
         if (buttons.length > 3) throw new Error("sendButtonsMessage: maks 3 tombol");
-        const msg = _gen(jid, {
-            buttonsMessage: {
-                contentText: text,
-                footerText: footer,
-                buttons: _mapButtons(buttons),
-                headerType: 1
-            }
-        });
+        const msg = _gen(jid, { buttonsMessage: { contentText: text, footerText: footer, buttons: _mapButtons(buttons), headerType: 1 } });
         return _relay(jid, msg);
     };
 
@@ -1055,18 +1218,11 @@ const makeBusinessSocket = (config) => {
         if (!sections?.length) throw new Error("sendListMessage: sections wajib");
         const msg = _gen(jid, {
             listMessage: {
-                title: title || "",
-                description: text || "",
-                footerText: footer || "",
-                buttonText: buttonText || "Lihat",
-                listType: 1,
+                title: title || "", description: text || "", footerText: footer || "",
+                buttonText: buttonText || "Lihat", listType: 1,
                 sections: sections.map(s => ({
                     title: s.title || "",
-                    rows: (s.rows || []).map(r => ({
-                        rowId: r.rowId || r.id,
-                        title: r.title,
-                        description: r.description || "",
-                    })),
+                    rows: (s.rows || []).map(r => ({ rowId: r.rowId || r.id, title: r.title, description: r.description || "" })),
                 })),
             },
         });
@@ -1077,107 +1233,45 @@ const makeBusinessSocket = (config) => {
         const { text, footer, templateButtons = [] } = cfg;
         if (!templateButtons.length) throw new Error("sendTemplateMessage: templateButtons wajib");
         const hydratedButtons = templateButtons.map((b, i) => {
-            if (b.quickReply) return {
-                index: b.index ?? i,
-                quickReplyButton: { displayText: b.quickReply.displayText, id: b.quickReply.id }
-            };
-            if (b.urlButton) return {
-                index: b.index ?? i,
-                urlButton: { displayText: b.urlButton.displayText, url: b.urlButton.url }
-            };
-            if (b.callButton) return {
-                index: b.index ?? i,
-                callButton: { displayText: b.callButton.displayText, phoneNumber: b.callButton.phoneNumber }
-            };
+            if (b.quickReply) return { index: b.index ?? i, quickReplyButton: { displayText: b.quickReply.displayText, id: b.quickReply.id } };
+            if (b.urlButton) return { index: b.index ?? i, urlButton: { displayText: b.urlButton.displayText, url: b.urlButton.url } };
+            if (b.callButton) return { index: b.index ?? i, callButton: { displayText: b.callButton.displayText, phoneNumber: b.callButton.phoneNumber } };
             return b;
         });
-        const msg = _gen(jid, {
-            templateMessage: {
-                hydratedTemplate: {
-                    hydratedContentText: text || "",
-                    hydratedFooterText: footer || "",
-                    hydratedButtons
-                }
-            }
-        });
+        const msg = _gen(jid, { templateMessage: { hydratedTemplate: { hydratedContentText: text || "", hydratedFooterText: footer || "", hydratedButtons } } });
         return _relay(jid, msg);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  INTERACTIVE MESSAGE (native flow / WABusiness buttons)
-    //  Supports: single_select, cta_url, cta_call, cta_copy, quick_reply,
-    //            address_message, send_location, payment, flow
-    // ─────────────────────────────────────────────────────────────────────────
     const sendInteractiveMessage = async (jid, cfg = {}, options = {}) => {
         const { body, footer, header, buttons, sections, nativeFlow } = cfg;
 
-        // ── Header ──────────────────────────────────────────────────────────
         let headerContent = null;
         if (header) {
-            const typeMap = { image: "image", video: "video", document: "document" };
-            if (typeMap[header.type]) {
+            if (header.type === "image" || header.type === "video" || header.type === "document") {
                 const inner = await (0, Utils_1.generateWAMessageContent)(
-                    {
-                        [header.type]: header.content,
-                        ...(header.type === "document" ? { fileName: header.fileName } : {})
-                    },
+                    { [header.type]: header.content, ...(header.type === "document" ? { fileName: header.fileName } : {}) },
                     { upload: waUploadToServer }
                 );
-                const msgKey = `${header.type}Message`;
-                headerContent = {
-                    [msgKey]: {
-                        ...inner[msgKey],
-                        ...(header.caption ? { caption: header.caption } : {})
-                    }
-                };
+                const k = `${header.type}Message`;
+                headerContent = { [k]: { ...inner[k], ...(header.caption ? { caption: header.caption } : {}) } };
             } else if (header.type === "text") {
-                headerContent = {
-                    ephemeralMessage: {
-                        message: { extendedTextMessage: { text: header.content || "" } }
-                    }
-                };
+                headerContent = { ephemeralMessage: { message: { extendedTextMessage: { text: header.content || "" } } } };
             }
         }
 
-        // ── Action ──────────────────────────────────────────────────────────
         let action = null;
-
-        // Modern native flow buttons (single_select, cta_url, etc.)
         if (buttons?.length) {
-            const normalizedBtns = _buildInteractiveButtons(buttons);
-            // Detect if these are native-flow style (have "name" field)
-            const isNativeStyle = normalizedBtns.every(b => b.name);
-            if (isNativeStyle) {
-                action = { nativeFlowMessage: { buttons: normalizedBtns } };
-            } else {
-                // Legacy plain buttons
-                action = {
-                    buttons: normalizedBtns.map(b => ({
-                        buttonId: b.id || b.buttonId,
-                        buttonText: { displayText: b.displayText || b.buttonText?.displayText || "" },
-                        type: 1
-                    }))
-                };
-            }
+            action = { nativeFlowMessage: { buttons: _buildInteractiveButtons(buttons) } };
         } else if (sections?.length) {
             action = {
                 sections: sections.map(s => ({
                     title: s.title,
-                    rows: (s.rows || []).map(r => ({
-                        rowId: r.id || r.rowId,
-                        title: r.title,
-                        description: r.description || ""
-                    })),
+                    rows: (s.rows || []).map(r => ({ rowId: r.id || r.rowId, title: r.title, description: r.description || "" })),
                 })),
                 buttonText: cfg.listButtonText || "Pilih",
             };
         } else if (nativeFlow) {
-            action = {
-                nativeFlowMessage: {
-                    name: nativeFlow.name,
-                    paramsJson: _normalizeButtonParamsJson(nativeFlow.paramsJson || nativeFlow.params || {})
-                }
-            };
+            action = { nativeFlowMessage: { name: nativeFlow.name, paramsJson: _normalizeButtonParamsJson(nativeFlow.paramsJson || nativeFlow.params || {}) } };
         }
 
         const msg = _gen(jid, {
@@ -1191,173 +1285,111 @@ const makeBusinessSocket = (config) => {
         return _relay(jid, msg);
     };
 
+    const sendInteractiveWithMedia = async (jid, cfg = {}, options = {}) => {
+        const { body, footer, buttons = [], image, video, document: doc, fileName } = cfg;
+        if (!buttons.length) throw new Error("sendInteractiveWithMedia: buttons wajib");
+        let headerContent = null;
+        if (image) {
+            const inner = await (0, Utils_1.generateWAMessageContent)({ image }, { upload: waUploadToServer });
+            headerContent = { imageMessage: inner.imageMessage };
+        } else if (video) {
+            const inner = await (0, Utils_1.generateWAMessageContent)({ video }, { upload: waUploadToServer });
+            headerContent = { videoMessage: inner.videoMessage };
+        } else if (doc) {
+            const inner = await (0, Utils_1.generateWAMessageContent)({ document: doc, fileName }, { upload: waUploadToServer });
+            headerContent = { documentMessage: inner.documentMessage };
+        }
+        const msg = _gen(jid, {
+            interactiveMessage: {
+                body: { text: body || "" },
+                footer: { text: footer || "" },
+                ...(headerContent ? { header: headerContent } : {}),
+                action: { nativeFlowMessage: { buttons: _buildInteractiveButtons(buttons) } },
+            },
+        });
+        return _relay(jid, msg);
+    };
+
     const sendHighlyStructuredMessage = async (jid, cfg = {}) => {
         const { namespace, elementName, params = [] } = cfg;
-        if (!namespace || !elementName)
-            throw new Error("sendHighlyStructuredMessage: namespace dan elementName wajib");
+        if (!namespace || !elementName) throw new Error("sendHighlyStructuredMessage: namespace dan elementName wajib");
         const msg = _gen(jid, {
             highlyStructuredMessage: {
-                namespace,
-                elementName,
-                params: params.map(p => ({ default: p })),
-                deterministicLottie: cfg.deterministicLottie || false,
-                fallbackLg: "id",
-                fallbackLc: "ID",
+                namespace, elementName, params: params.map(p => ({ default: p })),
+                deterministicLottie: cfg.deterministicLottie || false, fallbackLg: "id", fallbackLc: "ID",
             },
         });
         return _relay(jid, msg);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  PRODUCT MESSAGE (with full button support)
-    //  Supports sending productMessage with native flow buttons:
-    //  single_select, cta_url, cta_call, quick_reply, etc.
-    // ─────────────────────────────────────────────────────────────────────────
-
-    /**
-     * sendProductMessageWithButtons — kirim product message lengkap dengan buttons
-     *
-     * @param {string} jid
-     * @param {object} cfg
-     *   cfg.title        string   — judul produk
-     *   cfg.body         string   — isi teks pesan (mirip description / body)
-     *   cfg.footer       string   — teks footer
-     *   cfg.thumbnail    Buffer|{url:string}  — thumbnail gambar
-     *   cfg.productId    string
-     *   cfg.retailerId   string
-     *   cfg.businessOwnerJid string (opsional, default: bot jid)
-     *   cfg.buttons      Array    — array button native flow
-     *     format tiap button:
-     *       { name: "single_select", buttonParamsJson: JSON.stringify({...}) }
-     *       { name: "cta_url",       buttonParamsJson: JSON.stringify({display_text, url, merchant_url}) }
-     *       { name: "cta_call",      buttonParamsJson: JSON.stringify({display_text, phone_number}) }
-     *       { name: "quick_reply",   buttonParamsJson: JSON.stringify({display_text, id}) }
-     *       { name: "cta_copy",      buttonParamsJson: JSON.stringify({display_text, copy_code}) }
-     *       { name: "cta_reminder",  buttonParamsJson: JSON.stringify({display_text}) }
-     *       { name: "address_message", buttonParamsJson: JSON.stringify({display_text}) }
-     *       { name: "send_location", buttonParamsJson: "{}" }
-     *   cfg.header       object   — { type: "image"|"video"|"text", content, caption }
-     * @param {object} options   — sendMessage options (quoted, etc.)
-     */
-    const sendProductMessageWithButtons = async (jid, cfg = {}, options = {}) => {
-        const {
-            title,
-            body,
-            footer,
-            thumbnail,
-            productId,
-            retailerId,
-            businessOwnerJid,
-            buttons = [],
-            header,
-        } = cfg;
+    const sendImageWithButtons = async (jid, image, caption, buttons = [], footer = "", options = {}) => {
+        if (!image) throw new Error("sendImageWithButtons: image wajib");
+        if (!buttons.length) throw new Error("sendImageWithButtons: buttons wajib");
+        const inner = await (0, Utils_1.generateWAMessageContent)({ image }, { upload: waUploadToServer });
+        return _relay(jid, _gen(jid, { buttonsMessage: { imageMessage: inner.imageMessage, contentText: caption || "", footerText: footer, buttons: _mapButtons(buttons), headerType: 4 } }));
+    };
+
+    const sendVideoWithButtons = async (jid, video, caption, buttons = [], footer = "", options = {}) => {
+        if (!video) throw new Error("sendVideoWithButtons: video wajib");
+        if (!buttons.length) throw new Error("sendVideoWithButtons: buttons wajib");
+        const inner = await (0, Utils_1.generateWAMessageContent)({ video }, { upload: waUploadToServer });
+        return _relay(jid, _gen(jid, { buttonsMessage: { videoMessage: inner.videoMessage, contentText: caption || "", footerText: footer, buttons: _mapButtons(buttons), headerType: 5 } }));
+    };
+
+    const sendDocumentWithButtons = async (jid, document, fileName, caption, buttons = [], footer = "", options = {}) => {
+        if (!document) throw new Error("sendDocumentWithButtons: document wajib");
+        if (!buttons.length) throw new Error("sendDocumentWithButtons: buttons wajib");
+        const inner = await (0, Utils_1.generateWAMessageContent)({ document, fileName }, { upload: waUploadToServer });
+        return _relay(jid, _gen(jid, { buttonsMessage: { documentMessage: inner.documentMessage, contentText: caption || "", footerText: footer, buttons: _mapButtons(buttons), headerType: 6 } }));
+    };
 
+    const sendProductMessageWithButtons = async (jid, cfg = {}, options = {}) => {
+        const { title, body, footer, thumbnail, productId, retailerId, buttons = [], header } = cfg;
         if (!buttons.length) throw new Error("sendProductMessageWithButtons: min 1 button wajib");
 
-        // Build thumbnail upload if needed
-        let thumbnailUrl = null;
-        let thumbnailBuffer = null;
+        let headerContent = null;
         if (thumbnail) {
             if (typeof thumbnail === "object" && thumbnail.url) {
-                thumbnailUrl = thumbnail.url;
-            } else {
-                thumbnailBuffer = thumbnail;
+            } else if (Buffer.isBuffer(thumbnail)) {
+                const inner = await (0, Utils_1.generateWAMessageContent)({ image: thumbnail }, { upload: waUploadToServer });
+                headerContent = { imageMessage: inner.imageMessage };
             }
         }
-
-        // Build header content if provided
-        let headerContent = null;
-        if (header) {
-            if (header.type === "image" || header.type === "video") {
-                const inner = await (0, Utils_1.generateWAMessageContent)(
-                    { [header.type]: header.content },
-                    { upload: waUploadToServer }
-                );
-                const k = `${header.type}Message`;
-                headerContent = { [k]: { ...inner[k], ...(header.caption ? { caption: header.caption } : {}) } };
-            } else if (header.type === "text") {
-                headerContent = {
-                    ephemeralMessage: {
-                        message: { extendedTextMessage: { text: header.content || "" } }
-                    }
-                };
+        if (header && !headerContent) {
+            if (header.type === "image") {
+                const inner = await (0, Utils_1.generateWAMessageContent)({ image: header.content }, { upload: waUploadToServer });
+                headerContent = { imageMessage: { ...inner.imageMessage, ...(header.caption ? { caption: header.caption } : {}) } };
+            } else if (header.type === "video") {
+                const inner = await (0, Utils_1.generateWAMessageContent)({ video: header.content }, { upload: waUploadToServer });
+                headerContent = { videoMessage: { ...inner.videoMessage, ...(header.caption ? { caption: header.caption } : {}) } };
             }
         }
 
-        // Build normalized buttons
-        const normalizedBtns = _buildInteractiveButtons(buttons);
-
-        const productInfo = {
-            productId: productId || "",
-            title: title || "",
-            description: body || "",
-            retailerId: retailerId || "",
-            ...(thumbnailUrl ? { productImageCount: 1 } : {}),
-        };
-
         const msg = _gen(jid, {
             interactiveMessage: {
                 body: { text: body || "" },
                 footer: { text: footer || "" },
                 ...(headerContent ? { header: headerContent } : {}),
-                ...(thumbnailUrl || thumbnailBuffer ? {
-                    header: headerContent || {
-                        imageMessage: thumbnailBuffer
-                            ? {
-                                jpegThumbnail: thumbnailBuffer,
-                                url: "",
-                                directPath: "",
-                                mediaKey: Buffer.alloc(0),
-                            }
-                            : { url: thumbnailUrl }
-                    }
-                } : {}),
                 contextInfo: {
                     externalAdReply: {
                         title: title || "",
                         body: body || "",
                         mediaType: 1,
-                        ...(thumbnailUrl ? { thumbnailUrl } : {}),
                         renderLargerThumbnail: true,
                         showAdAttribution: false,
+                        ...(thumbnail?.url ? { thumbnailUrl: thumbnail.url } : {}),
                     }
                 },
-                action: {
-                    nativeFlowMessage: {
-                        buttons: normalizedBtns,
-                    }
-                },
+                action: { nativeFlowMessage: { buttons: _buildInteractiveButtons(buttons) } },
             },
         });
-
         return _relay(jid, msg);
     };
 
-    /**
-     * sendProductMessage — kompatibel dengan format lama DAN format baru.
-     *
-     * Format baru (recommended):
-     *   sendMessage(jid, {
-     *     productMessage: {
-     *       title, description, thumbnail: {url}, productId, retailerId,
-     *       body, footer,
-     *       buttons: [
-     *         { name: "single_select", buttonParamsJson: JSON.stringify({...}) },
-     *         { name: "cta_url", buttonParamsJson: JSON.stringify({...}) }
-     *       ]
-     *     }
-     *   }, { quoted: msg })
-     *
-     * Format lama (catalog lookup):
-     *   sendProductMessage(jid, productId, catalogJid, options)
-     */
     const sendProductMessage = async (jid, productIdOrCfg, catalogJidOrOptions, options = {}) => {
-        // Detect new format: first arg after jid is a config object with buttons
         if (typeof productIdOrCfg === "object" && productIdOrCfg !== null) {
             return sendProductMessageWithButtons(jid, productIdOrCfg, catalogJidOrOptions || {});
         }
-
-        // Legacy: catalog lookup
         const productId = productIdOrCfg;
         const catalogJid = typeof catalogJidOrOptions === "string" ? catalogJidOrOptions : null;
         const bizJid = _norm(catalogJid || _me());
@@ -1367,182 +1399,48 @@ const makeBusinessSocket = (config) => {
         const msg = _gen(jid, {
             productMessage: {
                 product: {
-                    productId: product.id,
-                    title: product.title,
-                    description: product.description || "",
-                    currencyCode: product.currency,
-                    priceAmount1000: product.price,
-                    retailerId: product.retailerId || "",
-                    url: product.url || "",
-                    productImageCount: product.images?.length || 0,
-                    firstImageId: product.images?.[0]?.id || "",
+                    productId: product.id, title: product.title, description: product.description || "",
+                    currencyCode: product.currency, priceAmount1000: product.price,
+                    retailerId: product.retailerId || "", url: product.url || "",
+                    productImageCount: product.images?.length || 0, firstImageId: product.images?.[0]?.id || "",
                 },
-                businessOwnerJid: bizJid,
-                catalog: { catalogJid: bizJid },
+                businessOwnerJid: bizJid, catalog: { catalogJid: bizJid },
             },
         });
         return _relay(jid, msg);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  PATCH: sock.sendMessage override to intercept productMessage with buttons
-    //  Agar bisa pakai: sock.sendMessage(jid, { productMessage: {..., buttons:[...]} })
-    // ─────────────────────────────────────────────────────────────────────────
-    const _originalSendMessage = sock.sendMessage.bind(sock);
-    const patchedSendMessage = async (jid, content, options = {}) => {
-        // Intercept productMessage with buttons array
-        if (content?.productMessage && Array.isArray(content.productMessage.buttons)) {
-            const pm = content.productMessage;
-            return sendProductMessageWithButtons(jid, {
-                title: pm.title || "",
-                body: pm.body || pm.description || "",
-                footer: pm.footer || "",
-                thumbnail: pm.thumbnail || null,
-                productId: pm.productId || "",
-                retailerId: pm.retailerId || "",
-                buttons: pm.buttons,
-                header: pm.header || null,
-            }, options);
-        }
-        return _originalSendMessage(jid, content, options);
-    };
-
-    // ─── Media + Buttons ──────────────────────────────────────────────────────
-    const sendImageWithButtons = async (jid, image, caption, buttons = [], footer = "", options = {}) => {
-        if (!image) throw new Error("sendImageWithButtons: image wajib");
-        if (!buttons.length) throw new Error("sendImageWithButtons: buttons wajib");
-        const inner = await (0, Utils_1.generateWAMessageContent)({ image }, { upload: waUploadToServer });
-        return _relay(jid, _gen(jid, {
-            buttonsMessage: {
-                imageMessage: inner.imageMessage,
-                contentText: caption || "",
-                footerText: footer,
-                buttons: _mapButtons(buttons),
-                headerType: 4
-            }
-        }));
-    };
-
-    const sendVideoWithButtons = async (jid, video, caption, buttons = [], footer = "", options = {}) => {
-        if (!video) throw new Error("sendVideoWithButtons: video wajib");
-        if (!buttons.length) throw new Error("sendVideoWithButtons: buttons wajib");
-        const inner = await (0, Utils_1.generateWAMessageContent)({ video }, { upload: waUploadToServer });
-        return _relay(jid, _gen(jid, {
-            buttonsMessage: {
-                videoMessage: inner.videoMessage,
-                contentText: caption || "",
-                footerText: footer,
-                buttons: _mapButtons(buttons),
-                headerType: 5
-            }
-        }));
-    };
-
-    const sendDocumentWithButtons = async (jid, document, fileName, caption, buttons = [], footer = "", options = {}) => {
-        if (!document) throw new Error("sendDocumentWithButtons: document wajib");
-        if (!buttons.length) throw new Error("sendDocumentWithButtons: buttons wajib");
-        const inner = await (0, Utils_1.generateWAMessageContent)({ document, fileName }, { upload: waUploadToServer });
-        return _relay(jid, _gen(jid, {
-            buttonsMessage: {
-                documentMessage: inner.documentMessage,
-                contentText: caption || "",
-                footerText: footer,
-                buttons: _mapButtons(buttons),
-                headerType: 6
-            }
-        }));
-    };
-
-    // ─────────────────────────────────────────────────────────────────────────
-    //  INTERACTIVE with media header + native flow buttons (full featured)
-    //  Usage example:
-    //    sendInteractiveWithMedia(jid, {
-    //      image: { url: "..." },        // or video, document
-    //      body: "Teks pesan",
-    //      footer: "Footer",
-    //      buttons: [
-    //        { name: "single_select", buttonParamsJson: JSON.stringify({title: "Pilih", sections:[...]}) },
-    //        { name: "cta_url", buttonParamsJson: JSON.stringify({display_text:"Web", url:"https://..."}) }
-    //      ]
-    //    })
-    // ─────────────────────────────────────────────────────────────────────────
-    const sendInteractiveWithMedia = async (jid, cfg = {}, options = {}) => {
-        const { body, footer, buttons = [], image, video, document: doc, fileName } = cfg;
-        if (!buttons.length) throw new Error("sendInteractiveWithMedia: buttons wajib");
-
-        let headerContent = null;
-        if (image) {
-            const inner = await (0, Utils_1.generateWAMessageContent)({ image }, { upload: waUploadToServer });
-            headerContent = { imageMessage: inner.imageMessage };
-        } else if (video) {
-            const inner = await (0, Utils_1.generateWAMessageContent)({ video }, { upload: waUploadToServer });
-            headerContent = { videoMessage: inner.videoMessage };
-        } else if (doc) {
-            const inner = await (0, Utils_1.generateWAMessageContent)({ document: doc, fileName }, { upload: waUploadToServer });
-            headerContent = { documentMessage: inner.documentMessage };
-        }
-
-        const normalizedBtns = _buildInteractiveButtons(buttons);
-
-        const msg = _gen(jid, {
-            interactiveMessage: {
-                body: { text: body || "" },
-                footer: { text: footer || "" },
-                ...(headerContent ? { header: headerContent } : {}),
-                action: {
-                    nativeFlowMessage: { buttons: normalizedBtns }
-                },
-            },
-        });
-        return _relay(jid, msg);
-    };
-
-    // ─── Newsletter ───────────────────────────────────────────────────────────
     const sendNewsletterMessage = async (newsletterJid, content, options = {}) => {
-        if (!newsletterJid.endsWith("@newsletter"))
-            throw new Error("sendNewsletterMessage: harus @newsletter JID");
+        if (!newsletterJid.endsWith("@newsletter")) throw new Error("sendNewsletterMessage: harus @newsletter JID");
         return _originalSendMessage(newsletterJid, content, options);
     };
 
     const sendNewsletterReaction = async (newsletterJid, messageId, emoji) => {
-        if (!newsletterJid.endsWith("@newsletter"))
-            throw new Error("sendNewsletterReaction: harus @newsletter JID");
+        if (!newsletterJid.endsWith("@newsletter")) throw new Error("sendNewsletterReaction: harus @newsletter JID");
         return query({
-            tag: "iq",
-            attrs: { to: newsletterJid, type: "set", xmlns: "w:newsletter" },
-            content: [{
-                tag: "reaction",
-                attrs: { "message_id": messageId },
-                content: [{ tag: "text", attrs: {}, content: emoji }]
-            }]
+            tag: "iq", attrs: { to: newsletterJid, type: "set", xmlns: "w:newsletter" },
+            content: [{ tag: "reaction", attrs: { "message_id": messageId }, content: [{ tag: "text", attrs: {}, content: emoji }] }]
         });
     };
 
     const getNewsletterInfo = async (newsletterJid) => {
-        if (!newsletterJid.endsWith("@newsletter"))
-            throw new Error("getNewsletterInfo: harus @newsletter JID");
-        return query({
-            tag: "iq",
-            attrs: { to: newsletterJid, type: "get", xmlns: "w:newsletter" },
-            content: [{ tag: "metadata", attrs: {} }]
-        });
+        try {
+            if (!newsletterJid.endsWith("@newsletter")) throw new Error("getNewsletterInfo: harus @newsletter JID");
+            return await query({ tag: "iq", attrs: { to: newsletterJid, type: "get", xmlns: "w:newsletter" }, content: [{ tag: "metadata", attrs: {} }] });
+        } catch { return null; }
     };
 
     const followNewsletter = async (newsletterJid) => {
-        const jid = newsletterJid.endsWith("@newsletter") ? newsletterJid : null;
-        if (!jid) throw new Error("followNewsletter: harus @newsletter JID");
-        return sock.newsletterFollow(jid);
+        if (!newsletterJid.endsWith("@newsletter")) throw new Error("followNewsletter: harus @newsletter JID");
+        return sock.newsletterFollow(newsletterJid);
     };
 
     const unfollowNewsletter = async (newsletterJid) => {
-        const jid = newsletterJid.endsWith("@newsletter") ? newsletterJid : null;
-        if (!jid) throw new Error("unfollowNewsletter: harus @newsletter JID");
-        return sock.newsletterUnfollow(jid);
+        if (!newsletterJid.endsWith("@newsletter")) throw new Error("unfollowNewsletter: harus @newsletter JID");
+        return sock.newsletterUnfollow(newsletterJid);
     };
 
-    const getNewsletterMetadata = async (type, key) => {
-        return sock.newsletterMetadata(type, key).catch(() => null);
-    };
+    const getNewsletterMetadata = async (type, key) => sock.newsletterMetadata(type, key).catch(() => null);
 
     const joinNewsletterByUrl = async (channelUrl) => {
         const inviteCode = _extractInviteCode(channelUrl);
@@ -1553,185 +1451,109 @@ const makeBusinessSocket = (config) => {
     };
 
     const sendLocationReply = async (jid, latitude, longitude, name, quotedMessage, options = {}) => {
-        if (typeof latitude !== "number" || typeof longitude !== "number")
-            throw new Error("sendLocationReply: lat/lng harus number");
+        if (typeof latitude !== "number" || typeof longitude !== "number") throw new Error("sendLocationReply: lat/lng harus number");
         if (!quotedMessage) throw new Error("sendLocationReply: quotedMessage wajib");
-        return _originalSendMessage(jid, {
-            location: {
-                degreesLatitude: latitude,
-                degreesLongitude: longitude,
-                ...(name ? { name } : {})
-            }
-        }, { quoted: quotedMessage, ...options });
+        return _originalSendMessage(jid, { location: { degreesLatitude: latitude, degreesLongitude: longitude, ...(name ? { name } : {}) } }, { quoted: quotedMessage, ...options });
+    };
+
+    const patchedSendMessage = async (jid, content, options = {}) => {
+        if (content?.tagAll && _isGrp(jid)) {
+            try {
+                const scope = content.tagAllScope || "all";
+                const mentions = await groupTagAll(jid, scope);
+                const { tagAll: _ta, tagAllScope: _ts, ...rest } = content;
+                return _originalSendMessage(jid, { ...rest, mentions: [...new Set([...(rest.mentions || []), ...mentions])] }, options);
+            } catch (e) { _log("warn", `tagAll patch error: ${e?.message}`); }
+        }
+        if (content?.productMessage && Array.isArray(content.productMessage.buttons)) {
+            const pm = content.productMessage;
+            return sendProductMessageWithButtons(jid, {
+                title: pm.title || "",
+                body: pm.body || pm.description || "",
+                footer: pm.footer || "",
+                thumbnail: pm.thumbnail || null,
+                productId: pm.productId || "",
+                retailerId: pm.retailerId || "",
+                buttons: pm.buttons,
+                header: pm.header || null,
+            }, options);
+        }
+        return _originalSendMessage(jid, content, options);
     };
 
-    // ─────────────────────────────────────────────────────────────────────────
-    //  EXPORTS
-    // ─────────────────────────────────────────────────────────────────────────
     return {
         ...sock,
 
-        // Override sendMessage to support productMessage+buttons transparently
         sendMessage: patchedSendMessage,
 
         logger: config.logger,
 
-        // Catalog
-        getCatalog,
-        getCollections,
-        getOrderDetails,
-        productCreate,
-        productDelete,
-        productUpdate,
-
-        // Group
-        groupTagAll,
-        groupStatusV2,
-        getGroupAdmins,
-        isGroupAdmin,
-        sendToAdminsOnly,
-        bulkGroupAction,
-        setGroupDisappearing,
-        sendTagAll,
-        sendMentionAll,
-        sendGroupInvite,
-        sendAdminInvite,
-        updateGroupName,
-        updateGroupDescription,
-        updateGroupSetting,
-        revokeGroupInvite,
-        getGroupInviteLink,
-        joinGroupViaLink,
-        leaveGroup,
-        getGroupParticipants,
-        setGroupJoinApproval,
-        getGroupJoinRequests,
-        approveGroupJoinRequest,
-        rejectGroupJoinRequest,
-        setGroupMemberAddMode,
-        updateGroupProfilePicture,
-
-        // Status
+        getCatalog, getCollections, getOrderDetails,
+        productCreate, productDelete, productUpdate,
+
+        getFollowedChannels,
+        getJoinedGroups,
+        getAllContacts,
+
+        convertMedia, convertToSticker,
+
+        groupTagAll, groupStatusV2, getGroupAdmins, isGroupAdmin,
+        sendToAdminsOnly, bulkGroupAction, setGroupDisappearing,
+        sendTagAll, sendMentionAll, sendGroupInvite, sendAdminInvite,
+        updateGroupName, updateGroupDescription, updateGroupSetting,
+        revokeGroupInvite, getGroupInviteLink, joinGroupViaLink, leaveGroup,
+        getGroupParticipants, setGroupJoinApproval, getGroupJoinRequests,
+        approveGroupJoinRequest, rejectGroupJoinRequest,
+        setGroupMemberAddMode, updateGroupProfilePicture,
+
         sendStatus,
 
-        // Media
-        sendImage,
-        sendVideo,
-        sendAudio,
-        sendAudioPTT,
-        sendVoiceNote,
-        sendDocument,
-        sendGIF,
-        sendPTV,
-        sendViewOnce,
-        sendAlbum,
-        sendLocation,
-        sendLocationReply,
-        sendLiveLocation,
-        sendContact,
-        sendPoll,
-        sendEvent,
-        sendScheduledCall,
-        sendLinkPreview,
-        sendDisappearingToggle,
-
-        // Sticker
-        sendStickerFromUrl,
-        sendStickerFromBuffer,
-        sendStickerWithMetadata,
-        sendStickerPack,
+        sendImage, sendVideo, sendAudio, sendAudioPTT, sendVoiceNote,
+        sendDocument, sendDocumentPack,
+        sendGIF, sendPTV, sendViewOnce, sendAlbum,
+        sendLocation, sendLocationReply, sendLiveLocation,
+        sendContact, sendPoll, sendEvent, sendScheduledCall,
+        sendLinkPreview, sendDisappearingToggle,
+
+        sendStickerFromUrl, sendStickerFromBuffer, sendStickerWithMetadata,
+        sendStickerPack, sendStickerPackAlbum, sendStickerPackMessage,
         sendStickerMessage,
 
-        // Interactive (full support)
-        sendButtonsMessage,
-        sendListMessage,
-        sendTemplateMessage,
-        sendInteractiveMessage,
-        sendInteractiveWithMedia,
+        sendButtonsMessage, sendListMessage, sendTemplateMessage,
+        sendInteractiveMessage, sendInteractiveWithMedia,
         sendHighlyStructuredMessage,
-        sendProductMessage,
-        sendProductMessageWithButtons,
-        sendNewsletterMessage,
-        sendNewsletterReaction,
-        getNewsletterInfo,
-        followNewsletter,
-        unfollowNewsletter,
-        getNewsletterMetadata,
-        joinNewsletterByUrl,
-        sendImageWithButtons,
-        sendVideoWithButtons,
-        sendDocumentWithButtons,
-
-        // Reply / quote
-        sendReply,
-        sendMediaReply,
-        sendQuotedText,
-        sendWithQuotedFake,
-        sendWithMentionAndReply,
-        forwardWithComment,
-
-        // Mentions / typing
-        sendTextWithMentions,
-        sendTyping,
-        sendWithTyping,
-
-        // Broadcast
-        broadcastMessage,
-        broadcastToGroups,
-        sendMultipleMessages,
-
-        // Message actions
-        pinMessage,
-        keepMessage,
-        editMessage,
-        deleteMessage,
-        reactMessage,
-        forwardMessage,
-
-        // Chat management
-        muteJid,
-        unmuteJid,
-        archiveChat,
-        unarchiveChat,
-        pinChat,
-        unpinChat,
-        markAsRead,
-        markAsUnread,
-        blockUser,
-        unblockUser,
-        starMessage,
-        unstarMessage,
-        deleteChat,
-        clearChat,
-        sendSeen,
-
-        // Profile
-        getProfilePicture,
-        getUserStatus,
-        updateProfilePicture,
-        removeProfilePicture,
-        updateProfileName,
-        updateProfileStatus,
-        getContactInfo,
-        getBusinessProfile,
-        fetchBlocklist,
-        fetchAllGroups,
-        fetchMessageHistory,
-
-        // Privacy
-        updatePrivacyLastSeen,
-        updatePrivacyProfilePic,
-        updatePrivacyStatus,
-        updatePrivacyReadReceipts,
-        updatePrivacyGroupsAdd,
-        updatePrivacyOnline,
+        sendProductMessage, sendProductMessageWithButtons,
+        sendNewsletterMessage, sendNewsletterReaction, getNewsletterInfo,
+        followNewsletter, unfollowNewsletter, getNewsletterMetadata, joinNewsletterByUrl,
+        sendImageWithButtons, sendVideoWithButtons, sendDocumentWithButtons,
+
+        sendReply, sendMediaReply, sendQuotedText,
+        sendWithQuotedFake, sendWithMentionAndReply, forwardWithComment,
+
+        sendTextWithMentions, sendTyping, sendWithTyping,
+
+        broadcastMessage, broadcastToGroups, sendMultipleMessages,
+
+        pinMessage, keepMessage, editMessage, deleteMessage,
+        reactMessage, forwardMessage,
+
+        muteJid, unmuteJid, archiveChat, unarchiveChat,
+        pinChat, unpinChat, markAsRead, markAsUnread,
+        blockUser, unblockUser, starMessage, unstarMessage,
+        deleteChat, clearChat, sendSeen,
+
+        getProfilePicture, getUserStatus,
+        updateProfilePicture, removeProfilePicture,
+        updateProfileName, updateProfileStatus,
+        getContactInfo, getBusinessProfile,
+        fetchBlocklist, fetchAllGroups, fetchMessageHistory,
+
+        updatePrivacyLastSeen, updatePrivacyProfilePic, updatePrivacyStatus,
+        updatePrivacyReadReceipts, updatePrivacyGroupsAdd, updatePrivacyOnline,
         setDefaultDisappearing,
 
-        // Misc
-        sendDisappearingMessage,
-        isOnWhatsApp,
-        presenceSubscribe,
-        rejectAllCalls,
+        sendDisappearingMessage, isOnWhatsApp,
+        presenceSubscribe, rejectAllCalls,
     };
 };