@awangxcode/qiro-baileys 7.0.0-rc22 → 7.0.0-rc25

package/lib/Extensions/advanced.js

@@ -0,0 +1,821 @@
+import { mkdir, readFile, rename, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from '../Utils/auth-utils.js';
+import { BufferJSON, generateMessageIDV2 } from '../Utils/generics.js';
+import { normalizeMessageContent } from '../Utils/messages.js';
+import { buildInteractiveBizNodes, jidNormalizedUser } from '../WABinary/index.js';
+const isRecord = (value) => !!value && typeof value === 'object';
+/**
+ * Walks common WhatsApp message wrappers without mutating the original object.
+ * This also supports WebMessageInfo-like objects as input.
+ */
+export const unwrapMessage = (input) => {
+    if (!isRecord(input))
+        return undefined;
+    let current = isRecord(input.message) ? input.message : input;
+    const seen = new Set();
+    for (let i = 0; i < 20 && isRecord(current) && !seen.has(current); i++) {
+        seen.add(current);
+        const next = current.deviceSentMessage?.message ||
+            current.botForwardedMessage?.message ||
+            current.ephemeralMessage?.message ||
+            current.viewOnceMessage?.message ||
+            current.viewOnceMessageV2?.message ||
+            current.viewOnceMessageV2Extension?.message ||
+            current.documentWithCaptionMessage?.message ||
+            current.editedMessage?.message ||
+            current.associatedChildMessage?.message ||
+            current.groupStatusMessage?.message ||
+            current.groupStatusMessageV2?.message;
+        if (!isRecord(next) || next === current)
+            break;
+        current = next;
+    }
+    return current;
+};
+/** Decodes the AIRich protobuf payload used by Qiro's AIRich builder and compatible senders. */
+export const readRichMessage = (input) => {
+    const root = unwrapMessage(input);
+    if (!root)
+        return null;
+    const rich = root.richResponseMessage || root.botForwardedMessage?.message?.richResponseMessage;
+    if (isRecord(rich)) {
+        const typeNames = {
+            0: 'unknown', 1: 'grid-image', 2: 'text', 3: 'inline-image', 4: 'table', 5: 'code',
+            6: 'dynamic', 7: 'map', 8: 'latex', 9: 'content-items'
+        };
+        const sections = (Array.isArray(rich.submessages) ? rich.submessages : []).map((section) => {
+            const messageType = Number(section?.messageType ?? 0);
+            return {
+                kind: typeNames[messageType] || 'unknown',
+                messageType,
+                text: section?.messageText,
+                gridImageMetadata: section?.gridImageMetadata,
+                imageMetadata: section?.imageMetadata,
+                codeMetadata: section?.codeMetadata,
+                tableMetadata: section?.tableMetadata,
+                dynamicMetadata: section?.dynamicMetadata,
+                latexMetadata: section?.latexMetadata,
+                mapMetadata: section?.mapMetadata,
+                contentItemsMetadata: section?.contentItemsMetadata
+            };
+        });
+        const title = typeof rich.unifiedResponse?.title === 'string' ? rich.unifiedResponse.title : undefined;
+        return { kind: 'ai-rich', messageType: rich.messageType, title, sections, contextInfo: rich.contextInfo, raw: rich };
+    }
+    const interactive = root.interactiveMessage;
+    if (isRecord(interactive)) {
+        const widget = interactive.bloksWidget;
+        const flow = interactive.nativeFlowMessage;
+        const sections = [];
+        if (Array.isArray(flow?.buttons)) {
+            for (const button of flow.buttons) {
+                let params = button?.buttonParamsJson;
+                if (typeof params === 'string') {
+                    try {
+                        params = JSON.parse(params);
+                    }
+                    catch { /* retain the original parameter string */ }
+                }
+                sections.push({ kind: 'button', name: button?.name, text: button?.text, params });
+            }
+        }
+        const title = interactive.header?.title || interactive.body?.text || interactive.footer?.text;
+        return {
+            kind: widget ? 'a2ui' : (flow ? 'interactive' : 'bloks'),
+            title: typeof title === 'string' ? title : undefined,
+            sections,
+            contextInfo: interactive.contextInfo,
+            raw: interactive
+        };
+    }
+    if (isRecord(root.bloksWidget)) {
+        return { kind: 'a2ui', title: root.bloksWidget.fallback, sections: [], raw: root.bloksWidget };
+    }
+    return null;
+};
+/** Reads social/link-card metadata from common text, video, and forwarded message shapes. */
+export const readSocialPreview = (input) => {
+    const root = unwrapMessage(input);
+    if (!root)
+        return null;
+    const extended = root.extendedTextMessage || root.imageMessage || root.videoMessage || root.documentMessage || {};
+    const context = extended.contextInfo || root.messageContextInfo || {};
+    const external = context.externalAdReply || context.externalReply || {};
+    const link = context.linkPreview || context.externalAdReply || {};
+    const text = root.conversation || extended.text || root.videoMessage?.caption || root.imageMessage?.caption || '';
+    const candidateUrl = external.sourceUrl || external.mediaUrl || link['matched-text'] || link.canonicalUrl || link.canonical_url;
+    const foundUrl = typeof candidateUrl === 'string' ? candidateUrl : (String(text).match(/https?:\/\/[^\s<>]+/i)?.[0]);
+    const title = external.title || link.title || link['title'];
+    const description = external.body || link.description || link['description'];
+    const thumbnail = external.thumbnail || link.jpegThumbnail || link.highQualityThumbnail?.jpegThumbnail;
+    const thumbnailUrl = external.thumbnailUrl || link.thumbnailUrl || link.originalThumbnailUrl;
+    const hasAny = !!(foundUrl || title || description || thumbnail || thumbnailUrl || external.mediaType);
+    if (!hasAny)
+        return null;
+    const durationRaw = external.duration || link.duration || root.videoMessage?.seconds;
+    const duration = Number(durationRaw);
+    return {
+        url: foundUrl,
+        matchedText: typeof text === 'string' && text ? text : undefined,
+        title: typeof title === 'string' ? title : undefined,
+        description: typeof description === 'string' ? description : undefined,
+        thumbnailUrl: typeof thumbnailUrl === 'string' ? thumbnailUrl : undefined,
+        thumbnail: thumbnail instanceof Uint8Array ? thumbnail : undefined,
+        mediaType: Number.isFinite(Number(external.mediaType ?? link.mediaType)) ? Number(external.mediaType ?? link.mediaType) : undefined,
+        sourceType: typeof external.sourceType === 'string' ? external.sourceType : undefined,
+        hasVideo: !!(external.videoUrl || external.video || root.videoMessage || Number(external.mediaType) === 2),
+        durationSeconds: Number.isFinite(duration) && duration >= 0 ? duration : undefined,
+        raw: external && Object.keys(external).length ? external : link
+    };
+};
+/** Normalizes a phone number or PN JID, while leaving non-PN destinations untouched. */
+export const normalizeUserJid = (input) => {
+    if (typeof input !== 'string' || !input.trim())
+        throw new TypeError('jid must be a non-empty string');
+    const value = input.trim();
+    if (value.includes('@')) {
+        if (value.endsWith('@g.us') || value.endsWith('@newsletter') || value === 'status@broadcast' || value.endsWith('@lid'))
+            return value;
+        return jidNormalizedUser(value);
+    }
+    const digits = value.replace(/\D/g, '');
+    if (digits.length < 5 || digits.length > 20)
+        throw new TypeError('phone number must contain 5–20 digits including country code');
+    return `${digits}@s.whatsapp.net`;
+};
+/** Builds a classic reply-button protobuf message. Legacy buttons can be hidden by some WhatsApp clients. */
+export const buildButtonsMessage = (input) => {
+    if (!input || typeof input.text !== 'string' || !input.text.trim())
+        throw new TypeError('buttons message text is required');
+    if (!Array.isArray(input.buttons) || input.buttons.length < 1 || input.buttons.length > 3) {
+        throw new RangeError('classic buttons require between 1 and 3 buttons');
+    }
+    const seen = new Set();
+    const buttons = input.buttons.map((button, index) => {
+        const id = String(button?.id || '').trim();
+        const text = String(button?.text || '').trim();
+        if (!id || !text)
+            throw new TypeError(`button ${index + 1} requires a non-empty id and text`);
+        if (seen.has(id))
+            throw new TypeError(`duplicate button id: ${id}`);
+        if (text.length > 25)
+            throw new RangeError(`button ${index + 1} text must be 25 characters or fewer`);
+        seen.add(id);
+        return { buttonId: id, buttonText: { displayText: text }, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE };
+    });
+    return {
+        buttonsMessage: {
+            contentText: input.text,
+            text: input.title,
+            footerText: input.footer,
+            headerType: input.title ? proto.Message.ButtonsMessage.HeaderType.TEXT : proto.Message.ButtonsMessage.HeaderType.EMPTY,
+            buttons,
+            contextInfo: input.contextInfo
+        }
+    };
+};
+/** Builds a classic single-select list protobuf message and validates row limits before relay. */
+export const buildListMessage = (input) => {
+    if (!input || typeof input.text !== 'string' || !input.text.trim())
+        throw new TypeError('list message text is required');
+    if (!String(input.buttonText || '').trim())
+        throw new TypeError('list buttonText is required');
+    if (!Array.isArray(input.sections) || input.sections.length < 1 || input.sections.length > 10) {
+        throw new RangeError('list requires between 1 and 10 sections');
+    }
+    let totalRows = 0;
+    const ids = new Set();
+    const sections = input.sections.map((section, sectionIndex) => {
+        if (!Array.isArray(section.rows) || section.rows.length < 1)
+            throw new TypeError(`section ${sectionIndex + 1} requires rows`);
+        const rows = section.rows.map((row, rowIndex) => {
+            totalRows++;
+            const id = String(row?.id || '').trim();
+            const title = String(row?.title || '').trim();
+            if (!id || !title)
+                throw new TypeError(`row ${sectionIndex + 1}.${rowIndex + 1} requires a non-empty id and title`);
+            if (ids.has(id))
+                throw new TypeError(`duplicate list row id: ${id}`);
+            if (title.length > 24)
+                throw new RangeError(`row title ${sectionIndex + 1}.${rowIndex + 1} must be 24 characters or fewer`);
+            ids.add(id);
+            return { rowId: id, title, description: row.description };
+        });
+        return { title: section.title, rows };
+    });
+    if (totalRows > 10)
+        throw new RangeError('classic lists support at most 10 rows total');
+    return {
+        listMessage: {
+            title: input.title,
+            description: input.text,
+            buttonText: input.buttonText,
+            footerText: input.footer,
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT,
+            sections,
+            contextInfo: input.contextInfo
+        }
+    };
+};
+/** Relays a prebuilt protobuf message through the current Baileys socket. */
+export const sendClassicMessage = async (socket, jid, message, options = {}) => {
+    if (!socket || typeof socket.relayMessage !== 'function')
+        throw new TypeError('a connected Qiro Baileys socket is required');
+    if (!jid)
+        throw new TypeError('jid is required');
+    const normalized = normalizeMessageContent(message);
+    const additionalNodes = options.autoBizNode !== false && jid !== 'status@broadcast' && !jid.endsWith('@newsletter')
+        ? buildInteractiveBizNodes(normalized)
+        : [];
+    return socket.relayMessage(jid, message, {
+        messageId: options.messageId || generateMessageIDV2(socket.user?.id || undefined),
+        useCachedGroupMetadata: options.useCachedGroupMetadata,
+        statusJidList: options.statusJidList,
+        isSecret: options.isSecret,
+        protected: options.protected,
+        me: options.me,
+        additionalNodes
+    });
+};
+/** Sends media as a WhatsApp album using the album parent key already supported by Qiro Baileys. */
+export const sendAlbum = async (socket, jid, items, options = {}) => {
+    if (!Array.isArray(items) || items.length < 2 || items.length > 10) {
+        throw new RangeError('an album requires between 2 and 10 image/video items');
+    }
+    const imageCount = items.filter(item => 'image' in item).length;
+    const videoCount = items.length - imageCount;
+    if (imageCount + videoCount !== items.length)
+        throw new TypeError('album items must be image or video messages');
+    const { onProgress, ...sendOptions } = options;
+    const parent = await socket.sendMessage(jid, { album: { expectedImageCount: imageCount, expectedVideoCount: videoCount } }, sendOptions);
+    if (!parent?.key?.id)
+        throw new Error('WhatsApp did not return an album parent message key');
+    const messages = [];
+    for (let index = 0; index < items.length; index++) {
+        const item = items[index];
+        const child = { ...item, albumParentKey: parent.key };
+        const sent = await socket.sendMessage(jid, child, sendOptions);
+        if (!sent)
+            throw new Error(`WhatsApp did not return album item ${index + 1}; ${messages.length} item(s) already sent`);
+        messages.push(sent);
+        onProgress?.(index + 1, items.length);
+    }
+    return { parent, messages };
+};
+/** Sends a link-card using WhatsApp's externalAdReply context. The client decides whether to render it. */
+export const richLink = async (socket, jid, options) => {
+    let parsed;
+    try {
+        parsed = new URL(options.url);
+    }
+    catch {
+        throw new TypeError('richLink url must be an absolute URL');
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password)
+        throw new TypeError('richLink requires an http/https URL without embedded credentials');
+    const externalAdReply = {
+        title: options.title,
+        body: options.description || '',
+        sourceUrl: parsed.toString(),
+        mediaUrl: parsed.toString(),
+        thumbnailUrl: options.thumbnailUrl,
+        thumbnail: options.thumbnail,
+        mediaType: options.mediaType ?? 1,
+        renderLargerThumbnail: options.large ?? true,
+        showAdAttribution: false
+    };
+    return socket.sendMessage(jid, {
+        text: options.text || options.description || options.title || parsed.toString(),
+        contextInfo: { externalAdReply }
+    }, options.quoted ? { quoted: options.quoted } : {});
+};
+/** Adds convenience methods without replacing or wrapping core socket methods. */
+export const attachAdvancedSocketMethods = (socket, autoBizNode = true) => {
+    const extended = socket;
+    extended.sendAlbum = (jid, items, options) => sendAlbum(socket, jid, items, options);
+    extended.sendClassicMessage = (jid, message, options) => sendClassicMessage(socket, jid, message, { ...options, autoBizNode: options?.autoBizNode ?? autoBizNode });
+    extended.richLink = (jid, options) => richLink(socket, jid, options);
+    extended.sendStatus = (content, recipients = [], options = {}) => {
+        if (!Array.isArray(recipients) || recipients.length === 0) {
+            throw new TypeError('sendStatus requires an explicit, non-empty recipient list');
+        }
+        return socket.sendMessage('status@broadcast', content, {
+            ...options,
+            statusJidList: recipients.map(normalizeUserJid)
+        });
+    };
+    return extended;
+};
+export const makeInMemoryStore = (options = {}) => {
+    const maxMessages = Math.max(50, Math.floor(options.maxMessagesPerChat || 1000));
+    const chats = new Map();
+    const contacts = new Map();
+    const groupMetadata = new Map();
+    const messages = new Map();
+    const messageIndex = new Map();
+    let boundEvents;
+    let boundHandlers = [];
+    let fileWriteQueue = Promise.resolve();
+    const makeMessageKey = (jid, id) => `${jid}\u0000${id}`;
+    const addMessage = (message) => {
+        const jid = message?.key?.remoteJid;
+        const id = message?.key?.id;
+        if (!jid || !id)
+            return;
+        const key = makeMessageKey(jid, id);
+        const previous = messageIndex.get(key);
+        if (previous)
+            Object.assign(previous, message);
+        else
+            messageIndex.set(key, message);
+        const list = messages.get(jid) || [];
+        if (!previous)
+            list.push(messageIndex.get(key));
+        if (list.length > maxMessages) {
+            const removed = list.splice(0, list.length - maxMessages);
+            for (const old of removed)
+                if (old.key?.id)
+                    messageIndex.delete(makeMessageKey(jid, old.key.id));
+        }
+        messages.set(jid, list);
+    };
+    const store = {
+        chats,
+        contacts,
+        groupMetadata,
+        messages,
+        bind(ev) {
+            if (boundEvents)
+                this.unbind();
+            boundEvents = ev;
+            boundHandlers = [];
+            const add = (event, fn) => { ev.on(event, fn); boundHandlers.push([event, fn]); };
+            add('messages.upsert', (data) => (data?.messages || []).forEach(addMessage));
+            add('messages.update', (updates) => {
+                for (const update of updates || []) {
+                    const jid = update?.key?.remoteJid;
+                    const id = update?.key?.id;
+                    if (!jid || !id)
+                        continue;
+                    const current = messageIndex.get(makeMessageKey(jid, id));
+                    if (current) {
+                        if (update.update?.message)
+                            current.message = update.update.message;
+                        Object.assign(current, Object.fromEntries(Object.entries(update.update || {}).filter(([k]) => k !== 'message')));
+                    }
+                }
+            });
+            add('messages.delete', (data) => {
+                const keys = Array.isArray(data) ? data : data?.keys || [];
+                for (const key of keys) {
+                    if (!key.remoteJid || !key.id)
+                        continue;
+                    messageIndex.delete(makeMessageKey(key.remoteJid, key.id));
+                    messages.set(key.remoteJid, (messages.get(key.remoteJid) || []).filter(m => m.key.id !== key.id));
+                }
+            });
+            add('chats.upsert', (rows) => (rows || []).forEach(row => { if (row?.id)
+                chats.set(row.id, { ...(chats.get(row.id) || {}), ...row }); }));
+            add('chats.update', (rows) => (rows || []).forEach(row => { if (row?.id)
+                chats.set(row.id, { ...(chats.get(row.id) || {}), ...row }); }));
+            add('chats.delete', (ids) => (ids || []).forEach(id => chats.delete(id)));
+            add('contacts.upsert', (rows) => (rows || []).forEach(row => { if (row?.id)
+                contacts.set(row.id, { ...(contacts.get(row.id) || {}), ...row }); }));
+            add('contacts.update', (rows) => (rows || []).forEach(row => { if (row?.id)
+                contacts.set(row.id, { ...(contacts.get(row.id) || {}), ...row }); }));
+            add('groups.update', (rows) => (rows || []).forEach(row => { if (row?.id)
+                groupMetadata.set(row.id, { ...(groupMetadata.get(row.id) || {}), ...row }); }));
+            add('groups.upsert', (rows) => (rows || []).forEach(row => { if (row?.id)
+                groupMetadata.set(row.id, { ...(groupMetadata.get(row.id) || {}), ...row }); }));
+            return this;
+        },
+        unbind() {
+            for (const [event, handler] of boundHandlers) {
+                if (typeof boundEvents?.off === 'function')
+                    boundEvents.off(event, handler);
+                else
+                    boundEvents?.removeListener?.(event, handler);
+            }
+            boundHandlers = [];
+            boundEvents = undefined;
+        },
+        loadMessage(jid, id) { return messageIndex.get(makeMessageKey(jid, id)); },
+        async readFromFile(path) {
+            const parsed = JSON.parse(await readFile(path, 'utf8'), BufferJSON.reviver);
+            chats.clear();
+            contacts.clear();
+            groupMetadata.clear();
+            messages.clear();
+            messageIndex.clear();
+            for (const item of parsed.chats || [])
+                chats.set(item[0], item[1]);
+            for (const item of parsed.contacts || [])
+                contacts.set(item[0], item[1]);
+            for (const item of parsed.groupMetadata || [])
+                groupMetadata.set(item[0], item[1]);
+            for (const item of parsed.messages || [])
+                for (const message of item[1] || [])
+                    addMessage(message);
+            return this;
+        },
+        async writeToFile(path) {
+            const task = fileWriteQueue.then(async () => {
+                await mkdir(dirname(path), { recursive: true });
+                const tmp = `${path}.${process.pid}.tmp`;
+                const payload = { chats: [...chats], contacts: [...contacts], groupMetadata: [...groupMetadata], messages: [...messages] };
+                await writeFile(tmp, JSON.stringify(payload, BufferJSON.replacer));
+                await rename(tmp, path);
+            });
+            fileWriteQueue = task.catch(() => undefined);
+            return task;
+        }
+    };
+    return store;
+};
+const createAuthState = async (adapter) => {
+    const storedCreds = (await adapter.get('creds', 'current'));
+    const creds = storedCreds || initAuthCreds();
+    if (!storedCreds)
+        await adapter.set('creds', 'current', creds);
+    const keys = {
+        get: async (type, ids) => {
+            const entries = await Promise.all(ids.map(async (id) => [id, await adapter.get(type, id)]));
+            const result = {};
+            for (const [id, value] of entries) {
+                if (value && type === 'app-state-sync-key')
+                    result[id] = proto.Message.AppStateSyncKeyData.fromObject(value);
+                else
+                    result[id] = value;
+            }
+            return result;
+        },
+        set: async (data) => {
+            const apply = async () => {
+                for (const category of Object.keys(data)) {
+                    const values = data[category];
+                    for (const [id, value] of Object.entries(values || {})) {
+                        if (value == null)
+                            await adapter.delete(category, id);
+                        else
+                            await adapter.set(category, id, value);
+                    }
+                }
+            };
+            if (adapter.transaction)
+                await adapter.transaction(apply);
+            else
+                await apply();
+        }
+    };
+    return { state: { creds, keys }, saveCreds: () => adapter.set('creds', 'current', creds) };
+};
+/** Stores the complete auth state in one JSON file, with atomic replacement on each write. */
+export const useSingleFileAuthState = async (filePath) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    let snapshot = {};
+    try {
+        snapshot = JSON.parse(await readFile(filePath, 'utf8'), BufferJSON.reviver);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            throw new Error(`Could not read auth state file ${filePath}: ${error.message}`);
+        }
+    }
+    let persistQueue = Promise.resolve();
+    const persist = async () => {
+        const task = persistQueue.then(async () => {
+            const temp = `${filePath}.${process.pid}.tmp`;
+            await writeFile(temp, JSON.stringify(snapshot, BufferJSON.replacer));
+            await rename(temp, filePath);
+        });
+        persistQueue = task.catch(() => undefined);
+        return task;
+    };
+    const adapter = {
+        get: async (category, id) => snapshot[category]?.[id] ?? null,
+        set: async (category, id, value) => { snapshot[category] || (snapshot[category] = {}); snapshot[category][id] = value; await persist(); },
+        delete: async (category, id) => { if (snapshot[category])
+            delete snapshot[category][id]; await persist(); }
+    };
+    return createAuthState(adapter);
+};
+/** Built-in Node SQLite auth adapter; requires Node.js 22.5+ and does not use better-sqlite3. */
+export const useSqliteAuthState = async (filePath, sessionId = 'default') => {
+    if (!sessionId.trim())
+        throw new TypeError('sessionId must not be empty');
+    let sqlite;
+    try {
+        const specifier = 'node:sqlite';
+        sqlite = await import(specifier);
+    }
+    catch (error) {
+        throw new Error(`useSqliteAuthState requires Node.js 22.5+ with node:sqlite. Original error: ${error.message}`);
+    }
+    const DatabaseSync = sqlite.DatabaseSync;
+    await mkdir(dirname(filePath), { recursive: true });
+    const db = new DatabaseSync(filePath);
+    db.exec('CREATE TABLE IF NOT EXISTS qiro_baileys_auth (session_id TEXT NOT NULL, category TEXT NOT NULL, data_id TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(session_id, category, data_id))');
+    const getStmt = db.prepare('SELECT value FROM qiro_baileys_auth WHERE session_id = ? AND category = ? AND data_id = ?');
+    const setStmt = db.prepare('INSERT INTO qiro_baileys_auth(session_id, category, data_id, value) VALUES(?, ?, ?, ?) ON CONFLICT(session_id, category, data_id) DO UPDATE SET value = excluded.value');
+    const deleteStmt = db.prepare('DELETE FROM qiro_baileys_auth WHERE session_id = ? AND category = ? AND data_id = ?');
+    let transactionQueue = Promise.resolve();
+    const adapter = {
+        get: async (category, id) => {
+            const row = getStmt.get(sessionId, category, id);
+            if (!row?.value)
+                return null;
+            return JSON.parse(row.value, BufferJSON.reviver);
+        },
+        set: async (category, id, value) => { setStmt.run(sessionId, category, id, JSON.stringify(value, BufferJSON.replacer)); },
+        delete: async (category, id) => { deleteStmt.run(sessionId, category, id); },
+        transaction: async (work) => {
+            const task = transactionQueue.then(async () => {
+                db.exec('BEGIN IMMEDIATE');
+                try {
+                    await work();
+                    db.exec('COMMIT');
+                }
+                catch (error) {
+                    db.exec('ROLLBACK');
+                    throw error;
+                }
+            });
+            transactionQueue = task.catch(() => undefined);
+            return task;
+        },
+        close: () => db.close()
+    };
+    const result = await createAuthState(adapter);
+    return { ...result, close: () => db.close() };
+};
+const safeSqlName = (name) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+        throw new TypeError(`unsafe SQL identifier: ${name}`);
+    return name;
+};
+/** PostgreSQL adapter. Pass an already-connected pg Pool or Client. */
+export const usePostgresAuthState = async (pool, options = {}) => {
+    if (!pool?.query)
+        throw new TypeError('usePostgresAuthState expects a connected pg Pool/Client');
+    const session = options.sessionId || 'default';
+    const table = safeSqlName(options.tableName || 'qiro_baileys_auth');
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${table} (session_id TEXT NOT NULL, category TEXT NOT NULL, data_id TEXT NOT NULL, value JSONB NOT NULL, PRIMARY KEY(session_id, category, data_id))`);
+    const adapter = {
+        get: async (category, id) => {
+            const value = (await pool.query(`SELECT value FROM ${table} WHERE session_id=$1 AND category=$2 AND data_id=$3`, [session, category, id])).rows?.[0]?.value;
+            return value == null ? null : JSON.parse(JSON.stringify(value), BufferJSON.reviver);
+        },
+        set: async (category, id, value) => { await pool.query(`INSERT INTO ${table}(session_id,category,data_id,value) VALUES($1,$2,$3,$4::jsonb) ON CONFLICT(session_id,category,data_id) DO UPDATE SET value=EXCLUDED.value`, [session, category, id, JSON.stringify(value, BufferJSON.replacer)]); },
+        delete: async (category, id) => { await pool.query(`DELETE FROM ${table} WHERE session_id=$1 AND category=$2 AND data_id=$3`, [session, category, id]); }
+    };
+    return createAuthState(adapter);
+};
+/** MySQL/MariaDB adapter. Pass an already-connected mysql2-compatible pool/connection. */
+export const useMySQLAuthState = async (pool, options = {}) => {
+    if (!pool?.query && !pool?.execute)
+        throw new TypeError('useMySQLAuthState expects a connected mysql2-compatible pool/connection');
+    const session = options.sessionId || 'default';
+    const table = safeSqlName(options.tableName || 'qiro_baileys_auth');
+    const run = (sql, values = []) => (pool.execute || pool.query).call(pool, sql, values);
+    await run(`CREATE TABLE IF NOT EXISTS \`${table}\` (session_id VARCHAR(128) NOT NULL, category VARCHAR(128) NOT NULL, data_id VARCHAR(255) NOT NULL, value LONGTEXT NOT NULL, PRIMARY KEY(session_id, category, data_id))`);
+    const rowsOf = (result) => Array.isArray(result?.[0]) ? result[0] : result;
+    const adapter = {
+        get: async (category, id) => {
+            const result = await run(`SELECT value FROM \`${table}\` WHERE session_id=? AND category=? AND data_id=? LIMIT 1`, [session, category, id]);
+            const row = rowsOf(result)?.[0];
+            return row?.value ? JSON.parse(row.value, BufferJSON.reviver) : null;
+        },
+        set: async (category, id, value) => { await run(`INSERT INTO \`${table}\`(session_id,category,data_id,value) VALUES(?,?,?,?) ON DUPLICATE KEY UPDATE value=VALUES(value)`, [session, category, id, JSON.stringify(value, BufferJSON.replacer)]); },
+        delete: async (category, id) => { await run(`DELETE FROM \`${table}\` WHERE session_id=? AND category=? AND data_id=?`, [session, category, id]); }
+    };
+    return createAuthState(adapter);
+};
+/** MongoDB adapter. Pass a connected Db instance from the official mongodb driver. */
+export const useMongoAuthState = async (db, options = {}) => {
+    if (!db?.collection)
+        throw new TypeError('useMongoAuthState expects a connected MongoDB Db instance');
+    const session = options.sessionId || 'default';
+    const collection = db.collection(options.collectionName || 'qiro_baileys_auth');
+    if (typeof collection.createIndex === 'function') {
+        try {
+            await collection.createIndex({ session_id: 1, category: 1, data_id: 1 }, { unique: true });
+        }
+        catch { /* index may already exist or the deployment may manage indexes centrally */ }
+    }
+    const adapter = {
+        get: async (category, id) => {
+            const value = (await collection.findOne({ session_id: session, category, data_id: id }))?.value;
+            return value == null ? null : JSON.parse(typeof value === 'string' ? value : JSON.stringify(value), BufferJSON.reviver);
+        },
+        set: async (category, id, value) => { await collection.updateOne({ session_id: session, category, data_id: id }, { $set: { session_id: session, category, data_id: id, value: JSON.stringify(value, BufferJSON.replacer) } }, { upsert: true }); },
+        delete: async (category, id) => { await collection.deleteOne({ session_id: session, category, data_id: id }); }
+    };
+    return createAuthState(adapter);
+};
+/** Redis adapter. Supports node-redis and ioredis-style hash methods. */
+export const useRedisAuthState = async (client, options = {}) => {
+    if (!client)
+        throw new TypeError('useRedisAuthState expects a connected Redis client');
+    const session = options.sessionId || 'default';
+    const prefix = options.prefix || 'qiro:baileys-auth';
+    const hget = client.hGet?.bind(client) || client.hget?.bind(client);
+    const hset = client.hSet?.bind(client) || client.hset?.bind(client);
+    const hdel = client.hDel?.bind(client) || client.hdel?.bind(client);
+    if (!hget || !hset || !hdel)
+        throw new TypeError('Redis client must expose hGet/hSet/hDel or hget/hset/hdel');
+    const hash = (category) => `${prefix}:${session}:${category}`;
+    const adapter = {
+        get: async (category, id) => { const value = await hget(hash(category), id); return value == null ? null : JSON.parse(value, BufferJSON.reviver); },
+        set: async (category, id, value) => { await hset(hash(category), id, JSON.stringify(value, BufferJSON.replacer)); },
+        delete: async (category, id) => { await hdel(hash(category), id); }
+    };
+    return createAuthState(adapter);
+};
+export const useCacheManagerAuthState = async (cache, options = {}) => {
+    if (!cache?.get || !cache?.set || !(cache.del || cache.delete)) {
+        throw new TypeError('useCacheManagerAuthState expects a cache-manager-like get/set/del adapter');
+    }
+    const session = options.sessionId || 'default';
+    const prefix = options.prefix || 'qiro:baileys-auth';
+    const deleteValue = (cache.del || cache.delete).bind(cache);
+    const key = (category, id) => `${prefix}:${session}:${category}:${id}`;
+    const adapter = {
+        get: async (category, id) => {
+            const value = await cache.get(key(category, id));
+            if (value == null)
+                return null;
+            return typeof value === 'string' ? JSON.parse(value, BufferJSON.reviver) : value;
+        },
+        set: async (category, id, value) => { await cache.set(key(category, id), JSON.stringify(value, BufferJSON.replacer)); },
+        delete: async (category, id) => { await deleteValue(key(category, id)); }
+    };
+    return createAuthState(adapter);
+};
+export const makeCacheManagerAuthState = useCacheManagerAuthState;
+/** Generic adapter bridge for NekoDB or another async key-value backend. */
+export const useNekoDBAuth = async (adapterLike, namespace = 'qiro_baileys_auth') => {
+    if (!adapterLike)
+        throw new TypeError('useNekoDBAuth expects an adapter/database instance');
+    const getNative = adapterLike.get?.bind(adapterLike);
+    const setNative = adapterLike.set?.bind(adapterLike);
+    const deleteNative = (adapterLike.delete || adapterLike.del)?.bind(adapterLike);
+    if (!getNative || !setNative || !deleteNative)
+        throw new TypeError('NekoDB adapter must expose async get, set, and delete/del methods');
+    const adapter = {
+        get: async (category, id) => {
+            const value = await getNative(`${namespace}:${category}:${id}`);
+            return typeof value === 'string' ? JSON.parse(value, BufferJSON.reviver) : value ?? null;
+        },
+        set: async (category, id, value) => { await setNative(`${namespace}:${category}:${id}`, JSON.stringify(value, BufferJSON.replacer)); },
+        delete: async (category, id) => { await deleteNative(`${namespace}:${category}:${id}`); }
+    };
+    return createAuthState(adapter);
+};
+/** Common database-backed store contract for integrations without a built-in adapter. */
+export const useAdapterAuthState = createAuthState;
+const loadFfmpeg = async () => {
+    try {
+        const moduleName = 'fluent-ffmpeg';
+        const mod = await import(moduleName);
+        return mod.default || mod;
+    }
+    catch {
+        throw new Error('This media helper requires fluent-ffmpeg and an FFmpeg binary installed on the host');
+    }
+};
+const ffmpegInput = (ffmpeg, input) => {
+    if (typeof input !== 'string' || !input.trim())
+        throw new TypeError('FFmpeg helpers require a non-empty file path or URL');
+    return ffmpeg(input);
+};
+/** Inspect codecs, container, streams, and duration via ffprobe. */
+export const probeMedia = async (input) => {
+    const ffmpeg = await loadFfmpeg();
+    return new Promise((resolve, reject) => ffmpeg.ffprobe(input, (error, data) => error ? reject(error) : resolve(data)));
+};
+/** Converts a file to an MP4/H.264 WhatsApp-oriented profile. */
+export const convertToWhatsAppVideo = async (input, outputPath, options = {}) => {
+    if (!outputPath)
+        throw new TypeError('outputPath is required');
+    const ffmpeg = await loadFfmpeg();
+    const { width, height, crf = 23, preset = 'medium', audioBitrate = '128k' } = options;
+    return new Promise((resolve, reject) => {
+        let command = ffmpegInput(ffmpeg, input).videoCodec('libx264').audioCodec('aac').format('mp4')
+            .outputOptions(['-movflags +faststart', `-crf ${crf}`, `-preset ${preset}`, `-b:a ${audioBitrate}`]);
+        if (width || height)
+            command = command.size(`${width || '?'}x${height || '?'}`).autopad();
+        command.on('error', reject).on('end', () => resolve(outputPath)).save(outputPath);
+    });
+};
+/** Converts an audio file to OGG/Opus, suitable for voice-note/audio delivery. */
+export const convertToOpusAudio = async (input, outputPath, options = {}) => {
+    if (!outputPath)
+        throw new TypeError('outputPath is required');
+    const ffmpeg = await loadFfmpeg();
+    const { bitrate = '64k', sampleRate = 48000, channels = 1 } = options;
+    return new Promise((resolve, reject) => {
+        ffmpegInput(ffmpeg, input).noVideo().audioCodec('libopus').audioBitrate(bitrate).audioFrequency(sampleRate).audioChannels(channels)
+            .format('ogg').on('error', reject).on('end', () => resolve(outputPath)).save(outputPath);
+    });
+};
+/** Extracts one video thumbnail with FFmpeg and returns the output file path. */
+export const getVideoThumbnail = async (input, outputPath, options = {}) => {
+    const ffmpeg = await loadFfmpeg();
+    const timestamp = options.timestamp || '00:00:01.000';
+    const width = Math.max(64, Math.min(1920, Math.floor(options.width || 640)));
+    return new Promise((resolve, reject) => {
+        ffmpeg(input).screenshots({ timestamps: [timestamp], filename: outputPath.split(/[\\/]/).pop(), folder: dirname(outputPath), size: `${width}x?` })
+            .on('error', reject).on('end', () => resolve(outputPath));
+    });
+};
+/** Resizes an image buffer or path; lazily loads sharp, then falls back to Jimp. Returns a Buffer. */
+export const resizeImage = async (input, options) => {
+    if (!options || !Number.isFinite(options.width) || options.width < 1)
+        throw new TypeError('resizeImage requires width >= 1');
+    const buffer = Buffer.isBuffer(input) ? input : input instanceof Uint8Array ? Buffer.from(input) : await readFile(input);
+    const width = Math.floor(options.width);
+    const height = options.height && options.height > 0 ? Math.floor(options.height) : undefined;
+    const quality = Math.max(1, Math.min(100, Math.floor(options.quality ?? 85)));
+    try {
+        const moduleName = 'sharp';
+        const imported = await import(moduleName);
+        let image = (imported.default || imported)(buffer).resize(width, height, { fit: options.fit || 'inside', withoutEnlargement: true });
+        if (options.format === 'png')
+            image = image.png();
+        else if (options.format === 'webp')
+            image = image.webp({ quality });
+        else
+            image = image.jpeg({ quality });
+        return await image.toBuffer();
+    }
+    catch (sharpError) {
+        try {
+            const moduleName = 'jimp';
+            const imported = await import(moduleName);
+            const Jimp = imported.Jimp || imported.default?.Jimp;
+            if (!Jimp)
+                throw sharpError;
+            const image = await Jimp.read(buffer);
+            image.resize({ w: width, h: height || Math.round(image.height * width / image.width) });
+            if (options.format === 'png')
+                return await image.getBuffer('image/png');
+            if (options.format === 'webp')
+                throw new Error('Jimp fallback does not support WebP output in this configuration');
+            return await image.getBuffer('image/jpeg', { quality });
+        }
+        catch {
+            throw new Error('resizeImage requires the optional sharp or jimp package to be installed');
+        }
+    }
+};
+/** Reads an MP4/MOV movie-header duration directly from its atoms without FFmpeg. */
+export const getMp4Duration = async (input) => {
+    const buffer = Buffer.isBuffer(input) ? input : input instanceof Uint8Array ? Buffer.from(input) : await readFile(input);
+    const readDuration = (atomType) => {
+        let offset = 0;
+        while ((offset = buffer.indexOf(atomType, offset, 'ascii')) >= 0) {
+            const start = offset - 4;
+            offset += 4;
+            if (start < 0 || start + 8 > buffer.length)
+                continue;
+            const size = buffer.readUInt32BE(start);
+            if (size < 20 || start + size > buffer.length)
+                continue;
+            const dataStart = start + 8;
+            const version = buffer[dataStart];
+            try {
+                if (version === 0 && size >= 24) {
+                    const timescale = buffer.readUInt32BE(dataStart + 12);
+                    const duration = buffer.readUInt32BE(dataStart + 16);
+                    if (timescale > 0)
+                        return duration / timescale;
+                }
+                else if (version === 1 && size >= 32) {
+                    const timescale = buffer.readUInt32BE(dataStart + 20);
+                    const duration = Number(buffer.readBigUInt64BE(dataStart + 24));
+                    if (timescale > 0)
+                        return duration / timescale;
+                }
+            }
+            catch { /* try next matching atom */ }
+        }
+        return null;
+    };
+    const duration = readDuration('mvhd') ?? readDuration('mdhd');
+    if (duration == null || !Number.isFinite(duration) || duration < 0)
+        throw new Error('Could not read MP4/MOV duration; input may be fragmented, malformed, or not a supported file');
+    return duration;
+};
+/** View-once V2 flags are deliberately applied in the generation pipeline, not faked at the API surface. */
+export const inspectMessageContent = (message) => {
+    const normalized = normalizeMessageContent(message);
+    return {
+        contentType: normalized ? Object.keys(normalized).find(key => key === 'conversation' || key.endsWith('Message')) || 'unknown' : 'unknown',
+        normalized,
+        socialPreview: readSocialPreview(normalized),
+        richMessage: readRichMessage(normalized)
+    };
+};
+//# sourceMappingURL=advanced.js.map