@awangxcode/qiro-baileys 7.0.0-rc23 → 7.0.0-rc25.1

package/lib/Extensions/experimental.js

@@ -0,0 +1,628 @@
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { generateWAMessageFromContent, prepareWAMessageMedia } from '../Utils/messages.js';
+import { sha256 } from '../Utils/crypto.js';
+import { generateMessageIDV2 } from '../Utils/generics.js';
+import { normalizeUserJid } from './advanced.js';
+const resolveUserJid = (sock) => sock.user?.id || sock.authState?.creds?.me?.id;
+const messageId = (sock) => sock?.generateMessageTag?.() || generateMessageIDV2();
+const safeHttpUrl = (value) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError('A valid absolute URL is required');
+    }
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+        throw new TypeError('Only credential-free http/https URLs are supported');
+    return url.toString();
+};
+export const WEBUI_PRIMITIVE_TYPENAME = 'GenAIaeacdsnwHtmlPrimitive';
+export const DEFAULT_WEBUI_BOT_JID = '867051314767696@bot';
+export const WEBUI_MAX_PAYLOAD_BYTES = 64 * 1024;
+/** Builds an internal WhatsApp WebUI payload. Rendering depends on WhatsApp client-side gates and can stop working without notice. */
+export const buildWebuiMessage = ({ html, title = 'WebUI', botJid = DEFAULT_WEBUI_BOT_JID, forwardOrigin = proto.ContextInfo.ForwardOrigin.META_AI, responseId = randomUUID() }) => {
+    if (typeof html !== 'string' || html.length === 0)
+        throw new TypeError('html must be a non-empty string');
+    if (Buffer.byteLength(html, 'utf8') > WEBUI_MAX_PAYLOAD_BYTES)
+        throw new RangeError(`HTML payload exceeds ${WEBUI_MAX_PAYLOAD_BYTES} bytes`);
+    const data = {
+        response_id: responseId,
+        sections: [{ view_model: { primitive: { __typename: WEBUI_PRIMITIVE_TYPENAME, payload: html, trusted_sources: [] }, __typename: 'GenAISingleLayoutViewModel' } }]
+    };
+    return {
+        messageContextInfo: { deviceListMetadata: {}, deviceListMetadataVersion: 2, botMetadata: { botResponseId: responseId } },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: 1,
+                    submessages: [{ messageType: 2, messageText: title }],
+                    unifiedResponse: { data: Buffer.from(JSON.stringify(data), 'utf8').toString('base64') },
+                    contextInfo: { forwardingScore: 1, isForwarded: true, forwardedAiBotMessageInfo: { botJid }, forwardOrigin }
+                }
+            }
+        }
+    };
+};
+export const sendInlineWebUI = async (sock, jid, html, title = 'WebUI', options = {}) => {
+    if (!sock || typeof sock.relayMessage !== 'function')
+        throw new TypeError('sock.relayMessage() is required');
+    const { messageId: customId, ...buildOptions } = options;
+    const message = buildWebuiMessage({ html, title, ...buildOptions });
+    const id = customId || messageId(sock);
+    await sock.relayMessage(normalizeUserJid(jid), message, { messageId: id });
+    return { messageId: id, message };
+};
+const DEFAULT_A2UI_CATALOG = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json';
+/** Declarative A2UI builder. The WhatsApp Bloks widget wire format is experimental. */
+export class A2UI {
+    constructor(options = {}) {
+        this.components = new Map();
+        this.counter = 0;
+        this.rootChildren = [];
+        this.version = options.version || 'v0.9';
+        this.catalogId = options.catalogId || DEFAULT_A2UI_CATALOG;
+    }
+    nextId(prefix) { return `${prefix.toLowerCase()}_${(this.counter++).toString(36)}`; }
+    register(id, component, extra = {}) {
+        const finalId = id || this.nextId(component);
+        if (this.components.has(finalId))
+            throw new Error(`A2UI component id already exists: ${finalId}`);
+        this.components.set(finalId, { id: finalId, component, ...extra });
+        return finalId;
+    }
+    text(text, options = {}) { return this.register(options.id, 'Text', { text, variant: options.variant || 'body' }); }
+    image(url, options = {}) { return this.register(options.id, 'Image', { url: safeHttpUrl(url), ...(options.variant ? { variant: options.variant } : {}), fit: options.fit || 'cover' }); }
+    video(url, options = {}) { return this.register(options.id, 'Video', { url: safeHttpUrl(url) }); }
+    checkbox(label, options = {}) { return this.register(options.id, 'CheckBox', { label, value: options.value ?? false }); }
+    textField(label, options = {}) { return this.register(options.id, 'TextField', { label, variant: options.variant || 'text' }); }
+    button(childId, options = {}) {
+        if (!childId)
+            throw new TypeError('button() requires a child component id');
+        return this.register(options.id, 'Button', { child: childId, variant: options.variant || 'primary', ...(options.action ? { action: options.action } : {}) });
+    }
+    card(childId, options = {}) { return this.register(options.id, 'Card', { child: childId }); }
+    column(children, options = {}) {
+        if (!Array.isArray(children) || children.length === 0)
+            throw new TypeError('column() requires child ids');
+        return this.register(options.id, 'Column', { children, ...(options.justify ? { justify: options.justify } : {}), ...(options.align ? { align: options.align } : {}) });
+    }
+    row(children, options = {}) {
+        if (!Array.isArray(children) || children.length === 0)
+            throw new TypeError('row() requires child ids');
+        return this.register(options.id, 'Row', { children });
+    }
+    divider(options = {}) { return this.register(options.id, 'Divider', {}); }
+    choicePicker(label, optionsList, options = {}) {
+        if (!Array.isArray(optionsList) || !optionsList.length)
+            throw new TypeError('choicePicker() requires at least one option');
+        return this.register(options.id, 'ChoicePicker', { label, variant: options.variant || 'mutuallyExclusive', ...(options.value !== undefined ? { value: options.value } : {}), options: optionsList, displayStyle: options.displayStyle || 'checkbox', filterable: options.filterable ?? false });
+    }
+    root(children) {
+        if (!Array.isArray(children) || !children.length)
+            throw new TypeError('root() requires at least one top-level child id');
+        this.rootChildren = [...children];
+        return this;
+    }
+    listCard(options) {
+        if (!options?.title || !Array.isArray(options.items) || options.items.length === 0)
+            throw new TypeError('listCard() requires title and items');
+        const uuid = options.uuid || randomUUID();
+        this.listCardPayload = {
+            uuid,
+            type: 'im_a2ui',
+            fallback: options.fallbackText || '',
+            data: JSON.stringify({ type: 'list_card', title: options.title, fallback_text: options.fallbackText || '', items: options.items.map(item => ({ asset_id: item.assetId || randomUUID().replace(/-/g, '').slice(0, 17), asset_type: item.assetType || 'PRODUCT_ITEM', title: item.title, trailing_label: item.price || item.trailingLabel || '', trailing_emphasis: item.emphasis || 'strong' })) })
+        };
+        return this;
+    }
+    build(options = {}) {
+        if (this.listCardPayload)
+            return { ...this.listCardPayload };
+        if (!this.rootChildren.length)
+            throw new Error('Call root([...ids]) before build()');
+        const uuid = options.uuid || randomUUID();
+        const components = [{ id: 'root', component: 'Column', children: this.rootChildren }, ...this.components.values()];
+        const data = options.wrapped === false ? { components } : { version: this.version, createSurface: { surfaceId: options.surfaceId || `starcore-widget=${uuid}`, catalogId: this.catalogId, components } };
+        return { uuid, data: JSON.stringify(data), type: options.type || 'im_a2ui' };
+    }
+}
+export const sendA2UIWidget = async (sock, jid, options) => {
+    if (!sock || typeof sock.relayMessage !== 'function')
+        throw new TypeError('sock.relayMessage() is required');
+    if (!(options?.a2ui instanceof A2UI))
+        throw new TypeError('options.a2ui must be an A2UI instance');
+    const { a2ui, bodyText = '', footer = '', buttons = [], contextInfo = {}, expiration, quoted, type = 'im_a2ui', wrapped = true, singleScreen = false } = options;
+    const nativeFlowMessage = buttons.length ? { buttons: buttons.map(button => ({ name: button.name || 'cta_url', buttonParamsJson: typeof button.params === 'string' ? button.params : JSON.stringify(button.params ?? {}) })), messageParamsJson: '{}', messageVersion: 1 } : { messageParamsJson: '' };
+    const interactiveMessage = {
+        ...(singleScreen ? {} : { header: { hasMediaAttachment: false }, body: { text: bodyText }, footer: { text: footer } }),
+        nativeFlowMessage,
+        bloksWidget: a2ui.build({ type, wrapped }),
+        ...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
+    };
+    const message = generateWAMessageFromContent(normalizeUserJid(jid), { messageContextInfo: { messageSecret: randomBytes(32) }, interactiveMessage }, { userJid: resolveUserJid(sock), quoted });
+    await sock.relayMessage(message.key.remoteJid, message.message, {
+        messageId: message.key.id,
+        additionalNodes: [{ tag: 'biz', attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: String(Math.floor(Date.now() / 1000)) }, content: [
+                    { tag: 'interactive', attrs: { type: 'native_flow', v: '1' }, content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }] },
+                    { tag: 'quality_control', attrs: { decision_id: randomUUID().replace(/-/g, ''), source_type: 'third_party' }, content: [{ tag: 'decision_source', attrs: { value: 'df' } }] }
+                ] }]
+    });
+    return message;
+};
+const WEBUI_TTL_MS = 24 * 60 * 60 * 1000;
+const toolCallId = () => randomBytes(8).toString('hex');
+const richSection = (viewModel) => ({ __typename: 'GenAIUnifiedResponseSection', view_model: viewModel });
+const richSingle = (primitive) => richSection({ __typename: 'GenAISingleLayoutViewModel', primitive });
+const inlineRichImage = (image, options = {}) => ({
+    __typename: 'GenAIMarkdownTextUXPrimitive', text: '{{header}}.{{/header}}', inline_entities: [{
+            __typename: 'GenAITextInlineEntity', key: 'header', metadata: {
+                __typename: 'GenAILatexItem', latex_expression: '.', font_height: 24, padding: options.padding ?? 4,
+                latex_image: { __typename: 'GenAIMediaItem', mime_type: image.mime_type || 'image/png', url: image.url, url_fallback: image.url, width: image.width || options.width || 500, height: image.height || options.height || 500, expiration_timestamp_ms: Date.now() + WEBUI_TTL_MS }
+            }
+        }]
+});
+const normalizeRichButton = (button, fallbackToast) => ({
+    label: String(typeof button === 'string' ? button : button?.label ?? button?.text ?? ''), state: 'PENDING', kind: 'OTHER', tool_call_id: toolCallId(),
+    toast: { label: (typeof button === 'object' && button?.toast !== undefined ? button.toast : fallbackToast) || '', __typename: 'GenAI3PExtWidgetToast' },
+    __typename: 'GenAI3PExtWidgetCTA'
+});
+const richWidget = (title, buttons, toast) => ({
+    __typename: 'GenAI3PExtWidgetPrimitive', header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: title || '' },
+    body: { __typename: 'GenAI3PExtCalendarEventList', ctas: buttons.map(button => normalizeRichButton(button, toast)), sections: [] }
+});
+/** Builds a GenAI rich-menu wire payload. Button CTAs may be decorative and not bot reply-buttons. */
+export const buildRichMenuMessage = (content = {}) => {
+    const { header, body, footer } = content;
+    const sections = [];
+    let messageContextInfo;
+    if (header) {
+        const { disclaimer = false, disclaimerText = ' ', image, title = '' } = header;
+        if (disclaimer)
+            messageContextInfo = { botMetadata: { messageDisclaimerText: disclaimerText } };
+        if (title)
+            sections.push(richSingle({ __typename: 'FOATextPrimitive', text: `# ${title}` }));
+        if (image?.url) {
+            const url = safeHttpUrl(image.url);
+            sections.push(richSingle(image.inline ? inlineRichImage({ ...image, url }, { width: 500, height: 500, padding: 4 }) : {
+                __typename: 'GenAIImagePrimitive', preview_image: { __typename: 'GenAIMediaItem', mime_type: image.mime_type || 'image/png', url },
+                full_image: { __typename: 'GenAIMediaItem', mime_type: image.mime_type || 'image/png', url }
+            }));
+        }
+    }
+    if (body) {
+        const { cards, buttons, title = '', toast = '', carousel = false, row = false } = body;
+        if ((carousel || row) && Array.isArray(cards) && cards.length)
+            sections.push(richSection({ __typename: carousel ? 'GenAIHScrollLayoutViewModel' : 'GenAIActionRowLayoutViewModel', primitives: cards.map((card) => richWidget(card?.title, card?.buttons || [], card?.toast || '')) }));
+        else if (Array.isArray(buttons) && buttons.length)
+            sections.push(richSingle(richWidget(title, buttons, toast)));
+    }
+    if (footer) {
+        const primitives = [];
+        if (footer.url)
+            primitives.push({ __typename: 'GenAIFooterActionPrimitive', cta_text: footer.text || 'Open', cta_type: 'OPEN_URL', cta_url: safeHttpUrl(footer.url) });
+        if (footer.image?.url)
+            primitives.push(inlineRichImage({ ...footer.image, url: safeHttpUrl(footer.image.url) }, { width: 100, height: 100, padding: -5 }));
+        if (primitives.length)
+            sections.push({ view_model: { __typename: 'GenAIActionRowLayoutViewModel', primitives } });
+    }
+    if (!sections.length)
+        throw new TypeError('richMenu requires at least one non-empty header, body, or footer section');
+    return {
+        ...(messageContextInfo ? { messageContextInfo } : {}),
+        botForwardedMessage: { message: { richResponseMessage: { messageType: 1, unifiedResponse: { data: Buffer.from(JSON.stringify({ sections })).toString('base64') }, contextInfo: { isForwarded: true, forwardOrigin: proto.ContextInfo.ForwardOrigin.META_AI, ...(content.contextInfo || {}) } } } }
+    };
+};
+export const sendRichMenu = async (sock, jid, content, options = {}) => {
+    if (!sock || typeof sock.relayMessage !== 'function')
+        throw new TypeError('sock.relayMessage() is required');
+    const message = buildRichMenuMessage(content);
+    const id = options.messageId || messageId(sock);
+    await sock.relayMessage(normalizeUserJid(jid), message, { messageId: id });
+    return { messageId: id, message };
+};
+export const hashImagePollOption = (optionName, fileSha256) => {
+    const nameHash = sha256(Buffer.from(String(optionName), 'utf8')).toString('hex');
+    const mediaHashBase64 = fileSha256 ? Buffer.from(fileSha256).toString('base64') : '';
+    return sha256(Buffer.from(nameHash + mediaHashBase64, 'utf8')).toString('hex');
+};
+export const sendImagePoll = async (sock, jid, options) => {
+    if (!sock?.relayMessage || !sock.waUploadToServer)
+        throw new TypeError('sendImagePoll requires a connected socket with waUploadToServer()');
+    if (!options?.name?.trim())
+        throw new TypeError('image poll name is required');
+    if (!Array.isArray(options.options) || options.options.length < 2 || options.options.length > 12)
+        throw new RangeError('image poll requires 2–12 options');
+    const names = options.options.map(option => String(option?.name || '').trim());
+    if (names.some(name => !name) || new Set(names).size !== names.length)
+        throw new TypeError('every image poll option needs a unique non-empty name');
+    const selectableCount = options.selectableCount ?? 1;
+    if (!Number.isInteger(selectableCount) || selectableCount < 1 || selectableCount > options.options.length)
+        throw new RangeError('selectableCount must be between 1 and the number of options');
+    const uploaded = [];
+    const pollOptions = [];
+    for (let index = 0; index < options.options.length; index++) {
+        const option = options.options[index];
+        const name = names[index];
+        if (!option || !name)
+            throw new TypeError(`image poll option ${index + 1} is invalid`);
+        const media = await prepareWAMessageMedia({ image: option.image }, { upload: sock.waUploadToServer, logger: sock.logger });
+        uploaded.push(media);
+        pollOptions.push({ optionName: name, optionHash: hashImagePollOption(name, media.imageMessage?.fileSha256) });
+    }
+    const secret = options.messageSecret ? Buffer.from(options.messageSecret) : randomBytes(32);
+    if (secret.length !== 32)
+        throw new RangeError('messageSecret must be exactly 32 bytes');
+    const poll = generateWAMessageFromContent(normalizeUserJid(jid), {
+        pollCreationMessageV3: { name: options.name, selectableOptionsCount: selectableCount, options: pollOptions, pollContentType: 2 },
+        messageContextInfo: { messageSecret: secret }
+    }, { userJid: resolveUserJid(sock), quoted: options.quoted });
+    await sock.relayMessage(poll.key.remoteJid, poll.message, { messageId: poll.key.id, additionalNodes: [{ tag: 'meta', attrs: { polltype: 'creation' } }] });
+    for (const media of uploaded) {
+        const optionContent = proto.Message.create({
+            pollCreationOptionImageMessage: { message: media },
+            messageContextInfo: { messageAssociation: { associationType: proto.MessageAssociation.AssociationType.MEDIA_POLL, parentMessageKey: poll.key } }
+        });
+        const optionMessage = generateWAMessageFromContent(normalizeUserJid(jid), optionContent, { userJid: resolveUserJid(sock) });
+        await sock.relayMessage(optionMessage.key.remoteJid, optionMessage.message, { messageId: optionMessage.key.id });
+    }
+    return poll;
+};
+export const SCHEDULED_MSG_WINDOW = Object.freeze({ minDelaySeconds: 600, maxChatDelaySeconds: 14 * 24 * 60 * 60, maxChannelDelaySeconds: 30 * 24 * 60 * 60, maxPerChat: 30, revealKeyRetentionSeconds: 30 * 24 * 60 * 60 });
+export const isScheduledTimeValid = (timestampSeconds, options = {}) => {
+    if (!Number.isFinite(timestampSeconds))
+        return false;
+    const now = options.nowSeconds ?? Math.floor(Date.now() / 1000);
+    const delta = Math.floor(timestampSeconds) - now;
+    return delta >= SCHEDULED_MSG_WINDOW.minDelaySeconds && delta <= (options.channel ? SCHEDULED_MSG_WINDOW.maxChannelDelaySeconds : SCHEDULED_MSG_WINDOW.maxChatDelaySeconds);
+};
+/** Encrypts a protobuf message for WhatsApp's conditional-reveal scheduled-message protocol. Server/account support is not guaranteed. */
+export const encodeScheduledMessage = (content, options = {}) => {
+    const revealKey = options.revealKey ? Buffer.from(options.revealKey) : randomBytes(32);
+    const encIv = options.encIv ? Buffer.from(options.encIv) : randomBytes(12);
+    if (revealKey.length !== 32 || encIv.length !== 12)
+        throw new RangeError('scheduled-message key must be 32 bytes and IV must be 12 bytes');
+    const revealKeyId = options.revealKeyId || randomUUID().replace(/-/g, '').slice(0, 16);
+    const plaintext = Buffer.from(proto.Message.encode(proto.Message.create(content)).finish());
+    const cipher = createCipheriv('aes-256-gcm', revealKey, encIv);
+    const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
+    return { revealKey, revealKeyId, encIv, encPayload: encrypted, message: { conditionalRevealMessage: { encPayload: encrypted, encIv, conditionalRevealMessageType: 1, revealKeyId } } };
+};
+export const decodeScheduledMessage = (message, revealKeyInput) => {
+    const revealKey = Buffer.from(revealKeyInput);
+    if (revealKey.length !== 32)
+        throw new RangeError('revealKey must be 32 bytes');
+    const wrapper = message?.conditionalRevealMessage || message?.message?.conditionalRevealMessage || message;
+    if (!wrapper?.encPayload || !wrapper?.encIv)
+        throw new TypeError('conditionalRevealMessage with encPayload and encIv is required');
+    const encrypted = Buffer.from(wrapper.encPayload);
+    if (encrypted.length < 16)
+        throw new Error('scheduled-message payload is too short');
+    const encIv = Buffer.from(wrapper.encIv);
+    const decipher = createDecipheriv('aes-256-gcm', revealKey, encIv);
+    decipher.setAuthTag(encrypted.subarray(encrypted.length - 16));
+    const plaintext = Buffer.concat([decipher.update(encrypted.subarray(0, encrypted.length - 16)), decipher.final()]);
+    return proto.Message.decode(plaintext);
+};
+export const buildScheduledMsgMetaNode = ({ scheduledTimestampS, revealKeyId, revealKey }) => {
+    if (!Number.isInteger(scheduledTimestampS) || !revealKeyId)
+        throw new TypeError('scheduledTimestampS and revealKeyId are required');
+    const key = Buffer.from(revealKey);
+    if (key.length !== 32)
+        throw new RangeError('revealKey must be 32 bytes');
+    return { tag: 'meta', attrs: { type: 'scheduled_message', st: String(scheduledTimestampS) }, content: [{ tag: 'key', attrs: { rkid: revealKeyId }, content: key }] };
+};
+export const sendScheduledMessage = async (sock, jid, content, scheduledTimestampS, options = {}) => {
+    if (!isScheduledTimeValid(scheduledTimestampS, { channel: options.channel }))
+        throw new RangeError('Scheduled time must be at least 10 minutes in the future and within the client-derived window');
+    const scheduled = encodeScheduledMessage(content, options);
+    const id = messageId(sock);
+    await sock.relayMessage(normalizeUserJid(jid), scheduled.message, { messageId: id, additionalNodes: [buildScheduledMsgMetaNode({ scheduledTimestampS, revealKeyId: scheduled.revealKeyId, revealKey: scheduled.revealKey })] });
+    return { ...scheduled, messageId: id, scheduledTimestampS };
+};
+/** Builds message payload for an experimental poll option append (requires a poll created with canAddOption on supported clients). */
+export const makePollAddOptionMessage = (pollCreationMessageKey, option) => {
+    if (!pollCreationMessageKey?.id || !option?.trim())
+        throw new TypeError('poll key and option text are required');
+    return {
+        pollAddOptionMessage: { pollCreationMessageKey, addOption: { optionName: option.trim() } },
+        messageContextInfo: { messageAssociation: { associationType: proto.MessageAssociation.AssociationType.POLL_ADD_OPTION, parentMessageKey: pollCreationMessageKey } }
+    };
+};
+export const sendPollAddOption = async (sock, jid, pollCreationMessageKey, option) => {
+    const generated = generateWAMessageFromContent(normalizeUserJid(jid), makePollAddOptionMessage(pollCreationMessageKey, option), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const makeNewsletterAdminInviteMessage = (options) => {
+    if (!options?.newsletterJid?.endsWith('@newsletter'))
+        throw new TypeError('newsletterJid must end in @newsletter');
+    if (!options.newsletterName?.trim())
+        throw new TypeError('newsletterName is required');
+    if (options.inviteExpiration !== undefined && (!Number.isFinite(options.inviteExpiration) || options.inviteExpiration <= 0))
+        throw new RangeError('inviteExpiration must be a positive Unix timestamp');
+    return { newsletterAdminInviteMessage: { ...options, newsletterName: options.newsletterName.trim() } };
+};
+export const makeNewsletterFollowerInviteMessage = (options) => {
+    if (!options?.newsletterJid?.endsWith('@newsletter'))
+        throw new TypeError('newsletterJid must end in @newsletter');
+    if (!options.newsletterName?.trim())
+        throw new TypeError('newsletterName is required');
+    return { newsletterFollowerInviteMessageV2: { newsletterJid: options.newsletterJid, newsletterName: options.newsletterName.trim(), caption: options.caption, jpegThumbnail: options.jpegThumbnail, contextInfo: options.contextInfo } };
+};
+export const sendNewsletterAdminInvite = async (sock, recipientJid, options) => {
+    const jid = normalizeUserJid(recipientJid);
+    const generated = generateWAMessageFromContent(jid, makeNewsletterAdminInviteMessage(options), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendNewsletterFollowerInvite = async (sock, recipientJid, options) => {
+    const jid = normalizeUserJid(recipientJid);
+    const generated = generateWAMessageFromContent(jid, makeNewsletterFollowerInviteMessage(options), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const makeScheduledCallCreationMessage = (options) => {
+    if (!Number.isFinite(options?.scheduledTimestampMs) || options.scheduledTimestampMs <= Date.now())
+        throw new RangeError('scheduledTimestampMs must be a future Unix timestamp in milliseconds');
+    if (![1, 2].includes(options.callType))
+        throw new RangeError('callType must be 1 (voice) or 2 (video)');
+    return { scheduledCallCreationMessage: { scheduledTimestampMs: Math.trunc(options.scheduledTimestampMs), callType: options.callType, title: options.title?.trim() } };
+};
+export const makeScheduledCallEditMessage = (key, editType = 1) => {
+    if (!key?.id)
+        throw new TypeError('scheduled call message key is required');
+    if (![1].includes(editType))
+        throw new RangeError('editType must be 1 (cancel)');
+    return { scheduledCallEditMessage: { key, editType } };
+};
+export const sendScheduledCallCreation = async (sock, jid, options) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeScheduledCallCreationMessage(options), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendScheduledCallEdit = async (sock, jid, key, editType = 1) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeScheduledCallEditMessage(key, editType), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const makeStatusAudienceMetadata = (options = {}) => ({
+    audienceType: options.audienceType ?? proto.ContextInfo.StatusAudienceMetadata.AudienceType.CLOSE_FRIENDS,
+    ...(options.listName ? { listName: options.listName } : {}),
+    ...(options.listEmoji ? { listEmoji: options.listEmoji } : {})
+});
+export const makeNewsletterStatusAttribution = (newsletterJid, channelMessageId, duration) => {
+    if (!newsletterJid?.endsWith('@newsletter'))
+        throw new TypeError('newsletterJid must end in @newsletter');
+    if (!Number.isInteger(channelMessageId) || channelMessageId < 0)
+        throw new RangeError('channelMessageId must be a non-negative integer');
+    return { type: proto.StatusAttribution.Type.RESHARE, statusReshare: { source: proto.StatusAttribution.StatusReshare.Source.CHANNEL_RESHARE, metadata: { channelJid: newsletterJid, channelMessageId, ...(duration !== undefined ? { duration } : {}) } } };
+};
+export const makeGroupStatusAttribution = (authorJid) => {
+    const jid = normalizeUserJid(authorJid);
+    return { type: proto.StatusAttribution.Type.GROUP_STATUS, groupStatus: { authorJid: jid } };
+};
+export const LOCATION_BROADCAST_JID = 'location@broadcast';
+export const isJidLocationBroadcast = (jid) => jid === LOCATION_BROADCAST_JID;
+export const makeQuestionMessage = (question) => {
+    if (!question?.trim())
+        throw new TypeError('question text is required');
+    return { questionMessage: { message: { extendedTextMessage: { text: question.trim(), contextInfo: { isQuestion: true } } } } };
+};
+export const makeQuestionResponseMessage = (questionKey, text) => {
+    if (!questionKey?.id || !text?.trim())
+        throw new TypeError('question key and response text are required');
+    return { questionResponseMessage: { key: questionKey, text: text.trim() } };
+};
+export const makeStatusLinkPreviewMetadata = (style) => {
+    if (!Number.isInteger(style) || style < 0)
+        throw new RangeError('status link preview style must be a non-negative integer');
+    return { statusLinkPreviewMetadata: { style } };
+};
+export const sendStatusLinkPreview = async (sock, text, style, recipients, options = {}) => {
+    if (!text?.trim())
+        throw new TypeError('status text is required');
+    if (!Array.isArray(recipients) || recipients.length === 0)
+        throw new TypeError('explicit status recipients are required');
+    const generated = generateWAMessageFromContent('status@broadcast', {
+        extendedTextMessage: { text: text.trim() },
+        ...makeStatusLinkPreviewMetadata(style),
+        messageContextInfo: { messageSecret: randomBytes(32) }
+    }, { userJid: resolveUserJid(sock) });
+    await sock.relayMessage('status@broadcast', generated.message, { messageId: options.messageId || generated.key.id, statusJidList: recipients.map(normalizeUserJid) });
+    return generated;
+};
+export const sendQuestionMessage = async (sock, jid, question, options = {}) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeQuestionMessage(question), { userJid: resolveUserJid(sock), quoted: options.quoted });
+    const additionalNodes = normalized.endsWith('@newsletter') ? [{ tag: 'meta', attrs: { questiontype: 'question' } }] : [];
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: options.messageId || generated.key.id, ...(additionalNodes.length ? { additionalNodes } : {}) });
+    return generated;
+};
+export const makeStatusQuestionAnswerMessage = (key, text) => {
+    if (!key?.id || !text?.trim())
+        throw new TypeError('status key and answer text are required');
+    return { statusQuestionAnswerMessage: { key, text: text.trim() } };
+};
+export const makeStatusQuotedMessage = (originalStatusId, text, thumbnail) => {
+    if (!originalStatusId?.id || !text?.trim())
+        throw new TypeError('original status key and quoted text are required');
+    return { statusQuotedMessage: { type: 1, originalStatusId, text: text.trim(), ...(thumbnail ? { thumbnail } : {}) } };
+};
+export const makeStatusStickerInteractionMessage = (key, stickerKey, type = 1) => {
+    if (!key?.id || !stickerKey)
+        throw new TypeError('status key and stickerKey are required');
+    return { statusStickerInteractionMessage: { key, stickerKey, type } };
+};
+export const makeStatusNotificationMessage = (responseMessageKey, originalMessageKey, type = 1) => {
+    if (!responseMessageKey?.id || !originalMessageKey?.id)
+        throw new TypeError('response and original message keys are required');
+    return { statusNotificationMessage: { responseMessageKey, originalMessageKey, type } };
+};
+export const makeStatusMentionMessage = (targetStatusKey, group = false) => {
+    if (!targetStatusKey?.id)
+        throw new TypeError('target status key is required');
+    const payload = { message: { protocolMessage: { key: targetStatusKey, type: 25 } } };
+    return group ? { groupStatusMentionMessage: payload } : { statusMentionMessage: payload };
+};
+export const makeCommentMessage = (targetMessageKey, text) => {
+    if (!targetMessageKey?.id || !text?.trim())
+        throw new TypeError('target message key and comment are required');
+    return { commentMessage: { targetMessageKey, message: { conversation: text.trim() } } };
+};
+export const sendQuestionResponse = async (sock, jid, questionKey, text) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeQuestionResponseMessage(questionKey, text), { userJid: resolveUserJid(sock) });
+    const additionalNodes = normalized.endsWith('@newsletter') ? [{ tag: 'meta', attrs: { questiontype: 'response' } }] : [];
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id, ...(additionalNodes.length ? { additionalNodes } : {}) });
+    return generated;
+};
+export const sendStatusQuestionAnswer = async (sock, jid, statusKey, text) => {
+    const normalized = normalizeUserJid(jid);
+    const message = makeStatusQuestionAnswerMessage(statusKey, text);
+    const generated = generateWAMessageFromContent(normalized, {
+        ...message,
+        messageContextInfo: { messageAssociation: { associationType: 16, parentMessageKey: statusKey }, messageSecret: randomBytes(32) }
+    }, { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendStatusQuoted = async (sock, jid, statusKey, text, thumbnail) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeStatusQuotedMessage(statusKey, text, thumbnail), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendStatusStickerInteraction = async (sock, jid, statusKey, stickerKey, type = 1) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeStatusStickerInteractionMessage(statusKey, stickerKey, type), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendStatusNotification = async (sock, jid, responseKey, originalKey, type = 1) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeStatusNotificationMessage(responseKey, originalKey, type), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const sendCommentMessage = async (sock, jid, targetMessageKey, text) => {
+    const normalized = normalizeUserJid(jid);
+    const generated = generateWAMessageFromContent(normalized, makeCommentMessage(targetMessageKey, text), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(generated.key.remoteJid, generated.message, { messageId: generated.key.id });
+    return generated;
+};
+export const makeAddYoursMessage = (parentStatusKey, content) => {
+    if (!parentStatusKey?.id)
+        throw new TypeError('parent status key with id is required');
+    if (!content || typeof content !== 'object' || !Object.keys(content).length)
+        throw new TypeError('Add Yours content is required');
+    return {
+        statusAddYours: { message: content },
+        messageContextInfo: { messageAssociation: { associationType: proto.MessageAssociation.AssociationType.STATUS_ADD_YOURS, parentMessageKey: parentStatusKey }, messageSecret: randomBytes(32) }
+    };
+};
+export const sendAddYours = async (sock, parentStatusKey, content, recipients, options = {}) => {
+    if (!Array.isArray(recipients) || recipients.length === 0)
+        throw new TypeError('explicit status recipients are required');
+    const generated = generateWAMessageFromContent('status@broadcast', makeAddYoursMessage(parentStatusKey, content), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage('status@broadcast', generated.message, { messageId: options.messageId || generated.key.id, statusJidList: recipients.map(normalizeUserJid) });
+    return generated;
+};
+export const makeGroupStatusReactionMessage = (statusKey, emoji) => {
+    if (!statusKey?.id)
+        throw new TypeError('group status message key is required');
+    if (!emoji?.trim())
+        throw new TypeError('reaction emoji is required');
+    return {
+        groupStatusMessageV2: { message: { reactionMessage: { key: statusKey, text: emoji.trim() }, messageContextInfo: { messageAssociation: { associationType: proto.MessageAssociation.AssociationType.STATUS_REACTION, parentMessageKey: statusKey } } } },
+        messageContextInfo: { isGroupStatus: true, messageSecret: randomBytes(32) }
+    };
+};
+export const sendGroupStatusReaction = async (sock, groupJid, statusKey, emoji) => {
+    const normalized = normalizeUserJid(groupJid);
+    if (!normalized.endsWith('@g.us'))
+        throw new TypeError('group status reaction target must be a @g.us JID');
+    const generated = generateWAMessageFromContent(normalized, makeGroupStatusReactionMessage(statusKey, emoji), { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(normalized, generated.message, { messageId: generated.key.id, additionalNodes: [{ tag: 'meta', attrs: { is_group_status: 'true' } }] });
+    return generated;
+};
+export const sendStatusWithAudience = async (sock, content, recipients, options = {}) => {
+    if (!Array.isArray(recipients) || recipients.length === 0)
+        throw new TypeError('explicit status recipients are required');
+    const { listName, listEmoji, audienceType = 1, ...sendOptions } = options;
+    return sock.sendMessage('status@broadcast', { ...content, contextInfo: { ...content?.contextInfo, statusAudienceMetadata: makeStatusAudienceMetadata({ audienceType, listName, listEmoji }) } }, { ...sendOptions, statusJidList: recipients.map(normalizeUserJid) });
+};
+export const sendGroupStatus = async (sock, groupJid, content, options = {}) => {
+    const jid = normalizeUserJid(groupJid);
+    if (!jid.endsWith('@g.us'))
+        throw new TypeError('group status target must be a @g.us JID');
+    const generated = generateWAMessageFromContent(jid, { groupStatusMessageV2: { message: content }, messageContextInfo: { isGroupStatus: true, messageSecret: randomBytes(32) } }, { userJid: resolveUserJid(sock) });
+    await sock.relayMessage(jid, generated.message, { messageId: generated.key.id, ...options, additionalNodes: [...(options.additionalNodes || []), { tag: 'meta', attrs: { is_group_status: 'true' } }] });
+    return generated;
+};
+export const sendStatusMention = async (sock, targetStatusKey, recipients, options = {}) => {
+    if (!Array.isArray(recipients) || recipients.length === 0)
+        throw new TypeError('status mention requires explicit recipients');
+    const generated = generateWAMessageFromContent('status@broadcast', { ...makeStatusMentionMessage(targetStatusKey), messageContextInfo: { messageSecret: randomBytes(32) } }, { userJid: resolveUserJid(sock) });
+    await sock.relayMessage('status@broadcast', generated.message, { messageId: generated.key.id, ...options, statusJidList: recipients.map(normalizeUserJid) });
+    return generated;
+};
+export const EXPERIMENTAL_FEATURES = Object.freeze({
+    inlineWebUI: true,
+    a2uiBloksWidget: true,
+    richMenu: true,
+    imagePoll: true,
+    modernStatusAndQuestion: true,
+    statusLinkPreview: true,
+    newsletterInvites: true,
+    scheduledCalls: true,
+    scheduledMessages: true,
+    scheduledMessageCancellation: false,
+    voipEngine: false
+});
+/**
+ * VoIP adapter contract for future engines. Qiro Baileys deliberately does not bundle WhatsApp's WASM engine,
+ * Web worker assets, or call/media pipeline. Pass a verified engine factory to use the adapter; without one it fails loudly.
+ */
+export const makeVoipClient = (sock, engineFactory) => {
+    if (!sock)
+        throw new TypeError('makeVoipClient requires a Baileys socket');
+    if (typeof engineFactory !== 'function')
+        throw new Error('VoIP engine is not bundled in this release. Supply a verified engineFactory together with the matching WhatsApp WASM/worker assets and media pipeline.');
+    const engine = engineFactory(sock);
+    if (!engine || typeof engine.call !== 'function')
+        throw new TypeError('engineFactory must return a VoIP engine exposing call()');
+    return engine;
+};
+export const attachExperimentalSocketMethods = (socket) => {
+    const sock = socket;
+    const extended = socket;
+    extended.sendInlineWebUI = (jid, html, title, options) => sendInlineWebUI(sock, jid, html, title, options);
+    extended.sendA2UI = (jid, options) => sendA2UIWidget(sock, jid, options);
+    extended.sendRichMenu = (jid, content, options) => sendRichMenu(sock, jid, content, options);
+    extended.sendImagePoll = (jid, options) => sendImagePoll(sock, jid, options);
+    extended.sendScheduledMessage = (jid, content, timestamp, options) => sendScheduledMessage(sock, jid, content, timestamp, options);
+    extended.sendStatusWithAudience = (content, recipients, options) => sendStatusWithAudience(sock, content, recipients, options);
+    extended.sendGroupStatus = (jid, content, options) => sendGroupStatus(sock, jid, content, options);
+    extended.sendStatusMention = (key, recipients, options) => sendStatusMention(sock, key, recipients, options);
+    extended.sendQuestionResponse = (jid, key, text) => sendQuestionResponse(sock, jid, key, text);
+    extended.sendQuestion = (jid, question, options) => sendQuestionMessage(sock, jid, question, options);
+    extended.sendPollAddOption = (jid, key, option) => sendPollAddOption(sock, jid, key, option);
+    extended.sendStatusQuestionAnswer = (jid, key, text) => sendStatusQuestionAnswer(sock, jid, key, text);
+    extended.sendStatusQuoted = (jid, key, text, thumbnail) => sendStatusQuoted(sock, jid, key, text, thumbnail);
+    extended.sendStatusStickerInteraction = (jid, key, stickerKey, type) => sendStatusStickerInteraction(sock, jid, key, stickerKey, type);
+    extended.sendStatusNotification = (jid, responseKey, originalKey, type) => sendStatusNotification(sock, jid, responseKey, originalKey, type);
+    extended.sendCommentMessage = (jid, key, text) => sendCommentMessage(sock, jid, key, text);
+    extended.sendAddYours = (key, content, recipients, options) => sendAddYours(sock, key, content, recipients, options);
+    extended.sendGroupStatusReaction = (jid, key, emoji) => sendGroupStatusReaction(sock, jid, key, emoji);
+    extended.sendStatusLinkPreview = (text, style, recipients, options) => sendStatusLinkPreview(sock, text, style, recipients, options);
+    extended.sendNewsletterAdminInvite = (jid, options) => sendNewsletterAdminInvite(sock, jid, options);
+    extended.sendNewsletterFollowerInvite = (jid, options) => sendNewsletterFollowerInvite(sock, jid, options);
+    extended.sendScheduledCallCreation = (jid, options) => sendScheduledCallCreation(sock, jid, options);
+    extended.sendScheduledCallEdit = (jid, key, editType) => sendScheduledCallEdit(sock, jid, key, editType);
+    return extended;
+};
+//# sourceMappingURL=experimental.js.map