@kelvdra/baileys 1.0.4 → 1.0.5

package/lib/Utils/messages-media.js

@@ -196,55 +196,63 @@ export async function getAudioDuration(buffer) {
  */
 export async function getAudioWaveform(buffer, logger) {
     try {
-        const { PassThrough } = require('stream');
-        const ff = require('fluent-ffmpeg');
-        
-        let audioData;
-        if (Buffer.isBuffer(buffer)) {
-            audioData = buffer;
-        } else if (typeof buffer === 'string') {
-            const rStream = require('fs').createReadStream(buffer);
-            audioData = await toBuffer(rStream);
-        } else {
-            audioData = await toBuffer(buffer);
+        const ffmpegModule = await import('fluent-ffmpeg');
+        const ff = ffmpegModule.default || ffmpegModule;
+        let input;
+        if (Buffer.isBuffer(buffer) || typeof buffer === 'string') {
+            input = buffer;
+        }
+        else {
+            input = await toBuffer(buffer);
         }
-
         return await new Promise((resolve, reject) => {
-            const inputStream = new PassThrough();
-            inputStream.end(audioData);
             const chunks = [];
             const bars = 64;
-            
-            ff(inputStream)
+            ff(input)
                 .audioChannels(1)
                 .audioFrequency(16000)
                 .format('s16le')
                 .on('error', reject)
                 .on('end', () => {
-                    const rawData = Buffer.concat(chunks);
-                    const samples = rawData.length / 2;
-                    const amplitudes = [];
-                    
-                    for (let i = 0; i < samples; i++) {
-                        amplitudes.push(Math.abs(rawData.readInt16LE(i * 2)) / 32768);
+                    try {
+                        const rawData = Buffer.concat(chunks);
+                        const samples = Math.floor(rawData.length / 2);
+                        if (!samples) {
+                            return resolve(new Uint8Array(bars).fill(0));
+                        }
+                        const amplitudes = new Array(samples);
+                        for (let i = 0; i < samples; i++) {
+                            amplitudes[i] = Math.abs(rawData.readInt16LE(i * 2)) / 32768;
+                        }
+                        const blockSize = Math.max(1, Math.floor(amplitudes.length / bars));
+                        const avg = [];
+                        for (let i = 0; i < bars; i++) {
+                            const start = i * blockSize;
+                            const end = i === bars - 1 ? amplitudes.length : Math.min(start + blockSize, amplitudes.length);
+                            const block = amplitudes.slice(start, end);
+                            if (!block.length) {
+                                avg.push(0);
+                                continue;
+                            }
+                            avg.push(block.reduce((a, b) => a + b, 0) / block.length);
+                        }
+                        const max = Math.max(...avg, 0.0001);
+                        const normalized = avg.map(v => {
+                            const scaled = Math.round((v / max) * 100);
+                            return Math.max(0, Math.min(100, scaled));
+                        });
+                        resolve(new Uint8Array(normalized));
                     }
-                    
-                    const blockSize = Math.floor(amplitudes.length / bars);
-                    const avg = [];
-                    for (let i = 0; i < bars; i++) {
-                        const block = amplitudes.slice(i * blockSize, (i + 1) * blockSize);
-                        avg.push(block.reduce((a, b) => a + b, 0) / block.length);
+                    catch (error) {
+                        reject(error);
                     }
-                    
-                    const max = Math.max(...avg);
-                    const normalized = avg.map(v => Math.floor((v / max) * 100));
-                    resolve(new Uint8Array(normalized));
                 })
                 .pipe()
                 .on('data', chunk => chunks.push(chunk));
         });
-    } catch (e) {
-        logger?.debug(e);
+    }
+    catch (e) {
+        logger?.debug({ trace: e?.stack || e }, 'failed to generate waveform');
     }
 }
 export const toReadable = (buffer) => {
@@ -263,21 +271,21 @@ export const toBuffer = async (stream) => {
 };
 export const getStream = async (item, opts) => {
     if (Buffer.isBuffer(item)) {
-        return { stream: toReadable(item), type: 'buffer' };
+        return { stream: toReadable(item), type: 'buffer' }
     }
     if ('stream' in item) {
-        return { stream: item.stream, type: 'readable' };
-    }
-    const urlStr = item.url.toString();
+        return { stream: item.stream, type: 'readable' }
+    } 
+    const urlStr = item.url.toString() 
     if (urlStr.startsWith('data:')) {
-        const buffer = Buffer.from(urlStr.split(',')[1], 'base64');
-        return { stream: toReadable(buffer), type: 'buffer' };
+        const buffer = Buffer.from(urlStr.split(',')[1], 'base64') 
+        return { stream: await toReadable(buffer), type: 'buffer' }
     }
     if (urlStr.startsWith('http://') || urlStr.startsWith('https://')) {
-        return { stream: await getHttpStream(item.url, opts), type: 'remote' };
+        return { stream: await getHttpStream(item.url, opts), type: 'remote' }
     }
-    return { stream: createReadStream(item.url), type: 'file' };
-};
+    return { stream: createReadStream(item.url), type: 'file' }
+}
 /** generates a thumbnail for a given media, if required */
 export async function generateThumbnail(file, mediaType, options) {
     let thumbnail;
@@ -697,3 +705,114 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
 //# sourceMappingURL=messages-media.js.map
+
+// Added from Baileys v7.0.0-rc10
+export const DEF_MEDIA_HOST = 'mmg.whatsapp.net';
+
+// Added from Baileys v7.0.0-rc10
+export const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent }, redirectCount = 0) => {
+    if (redirectCount > 5) {
+        throw new Error('Too many redirects');
+    }
+    const parsedUrl = new URL(url);
+    const httpModule = parsedUrl.protocol === 'https:' ? await import('https') : await import('http');
+    // Get file size for Content-Length header (required for Node.js streaming)
+    const fileStats = await fs.stat(filePath);
+    const fileSize = fileStats.size;
+    return new Promise((resolve, reject) => {
+        const req = httpModule.request({
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+            path: parsedUrl.pathname + parsedUrl.search,
+            method: 'POST',
+            headers: {
+                ...headers,
+                'Content-Length': fileSize
+            },
+            agent,
+            timeout: timeoutMs
+        }, res => {
+            // Handle redirects (3xx)
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume(); // Consume response to free resources
+                const newUrl = new URL(res.headers.location, url).toString();
+                resolve(uploadWithNodeHttp({
+                    url: newUrl,
+                    filePath,
+                    headers,
+                    timeoutMs,
+                    agent
+                }, redirectCount + 1));
+                return;
+            }
+            let body = '';
+            res.on('data', chunk => (body += chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve(undefined);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Upload timeout'));
+        });
+        const stream = createReadStream(filePath);
+        stream.pipe(req);
+        stream.on('error', err => {
+            req.destroy();
+            reject(err);
+        });
+    });
+};
+const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) => {
+    // Convert Node.js Readable to Web ReadableStream
+    const nodeStream = createReadStream(filePath);
+    const webStream = Readable.toWeb(nodeStream);
+    const response = await fetch(url, {
+        dispatcher: agent,
+        method: 'POST',
+        body: webStream,
+        headers,
+        duplex: 'half',
+        signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
+    });
+    try {
+        return (await response.json());
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Uploads media to WhatsApp servers.
+ *
+ * ## Why we have two upload implementations:
+ *
+ * Node.js's native `fetch` (powered by undici) has a known bug where it buffers
+ * the entire request body in memory before sending, even when using streams.
+ * This causes memory issues with large files (e.g., 1GB file = 1GB+ memory usage).
+ * See: https://github.com/nodejs/undici/issues/4058
+ *
+ * Other runtimes (Bun, Deno, browsers) correctly stream the request body without
+ * buffering, so we can use the web-standard Fetch API there.
+ *
+ * ## Future considerations:
+ * Once the undici bug is fixed, we can simplify this to use only the Fetch API
+ * across all runtimes. Monitor the GitHub issue for updates.
+ */
+const uploadMedia = async (params, logger) => {
+    if (isNodeRuntime()) {
+        logger?.debug('Using Node.js https module for upload (avoids undici buffering bug)');
+        return uploadWithNodeHttp(params);
+    }
+    else {
+        logger?.debug('Using web-standard Fetch API for upload');
+        return uploadWithFetch(params);
+    }
+};
+

package/lib/Utils/messages.d.ts

@@ -86,4 +86,4 @@ export declare const downloadMediaMessage: <Type extends "buffer" | "stream">(me
 /** Checks whether the given message is a media message; if it is returns the inner content */
 export declare const assertMediaContent: (content: proto.IMessage | null | undefined) => proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
 export {};
-//# sourceMappingURL=messages.d.ts.map
+//# sourceMappingURL=messages.d.ts.map

package/lib/Utils/messages.js

@@ -8,7 +8,8 @@ import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
+import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -99,6 +100,25 @@ export const prepareWAMessageMedia = async (message, options) => {
     if (isNewsletter) {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
         const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
+        try {
+            if (mediaType === 'audio') {
+                if (typeof uploadData.seconds === 'undefined') {
+                    uploadData.seconds = await getAudioDuration(filePath);
+                    logger?.debug('computed newsletter audio duration');
+                }
+                if (uploadData.ptt === true && typeof uploadData.waveform === 'undefined') {
+                    uploadData.waveform = await getAudioWaveform(filePath, logger);
+                    logger?.debug('processed newsletter waveform');
+                }
+                if (options.backgroundColor && uploadData.ptt === true && typeof uploadData.backgroundArgb === 'undefined') {
+                    uploadData.backgroundArgb = await assertColor(options.backgroundColor);
+                    logger?.debug('computed newsletter backgroundColor audio status');
+                }
+            }
+        }
+        catch (error) {
+            logger?.warn({ trace: error.stack }, 'failed to obtain newsletter media extra info');
+        }
         const fileSha256B64 = fileSha256.toString('base64');
         const { mediaUrl, directPath } = await options.upload(filePath, {
             fileEncSha256B64: fileSha256B64,
@@ -131,7 +151,10 @@ export const prepareWAMessageMedia = async (message, options) => {
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
     const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
-    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
+    // waveform processing also needs the original media file.
+    // if the caller already provides `seconds`, the old logic skips saving the original file,
+    // so `getAudioWaveform(originalFilePath)` receives `undefined` and waveform generation fails.
+    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
@@ -523,6 +546,174 @@ export const generateWAMessageContent = async (message, options) => {
 
         m.requestPaymentMessage = requestPaymentMessage
     }
+    else if ('stickerPack' in message) {
+        const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+        const { zip } = await import('fflate');
+
+        if (!Array.isArray(stickers) || stickers.length === 0) {
+            throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+        }
+        if (stickers.length > 120) {
+            throw new Boom('Sticker pack exceeds the maximum limit of 120 stickers', { statusCode: 400 });
+        }
+
+        const stickerPackId = packId || generateMessageIDV2();
+        const [_sharp, _jimp] = await Promise.all([
+            import('sharp').catch(() => null),
+            import('jimp').catch(() => null)
+        ]);
+        const lib = _sharp ? { sharp: _sharp } : _jimp ? { jimp: _jimp } : null;
+        if (!lib) {
+            throw new Boom('No image processing library available (install sharp or jimp)', { statusCode: 500 });
+        }
+
+        const isWebPBuffer = (buf) => (
+            buf.length >= 12 &&
+            buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
+            buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50
+        );
+        const isAnimatedWebP = (buf) => {
+            if (!isWebPBuffer(buf)) return false;
+            let offset = 12;
+            while (offset < buf.length - 8) {
+                const fourCC = buf.toString('ascii', offset, offset + 4);
+                const chunkSize = buf.readUInt32LE(offset + 4);
+                if (fourCC === 'VP8X') {
+                    const flagsOffset = offset + 8;
+                    if (flagsOffset < buf.length && (buf[flagsOffset] & 0x02)) return true;
+                } else if (fourCC === 'ANIM' || fourCC === 'ANMF') {
+                    return true;
+                }
+                offset += 8 + chunkSize + (chunkSize % 2);
+            }
+            return false;
+        };
+        const imageToWebp = async (buffer) => {
+            if (isWebPBuffer(buffer)) {
+                if ('sharp' in lib && lib.sharp) {
+                    return await lib.sharp.default(buffer)
+                        .resize(512, 512, { fit: 'inside', withoutEnlargement: true })
+                        .webp({ quality: 75, effort: 6 })
+                        .toBuffer();
+                }
+                return buffer;
+            }
+            if ('sharp' in lib && lib.sharp) {
+                return await lib.sharp.default(buffer)
+                    .resize(512, 512, { fit: 'inside', withoutEnlargement: true })
+                    .webp({ quality: 75, effort: 6 })
+                    .toBuffer();
+            }
+            throw new Boom('No image processing library (sharp) available for converting sticker to WebP', { statusCode: 500 });
+        };
+
+        const stickerData = {};
+        const stickerMetadata = [];
+        for (let i = 0; i < stickers.length; i++) {
+            const s = stickers[i];
+            try {
+                const { stream } = await getStream(s.data || s.sticker);
+                const buffer = await toBuffer(stream);
+                if (!buffer || buffer.length === 0) continue;
+                const animated = isAnimatedWebP(buffer);
+                const webpBuffer = await imageToWebp(buffer);
+                if (webpBuffer.length > 1024 * 1024) continue;
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-').replace(/=/g, '');
+                const fileName = `${hash}.webp`;
+                stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 6 }];
+                stickerMetadata.push({
+                    fileName,
+                    mimetype: 'image/webp',
+                    isAnimated: s.isAnimated ?? animated,
+                    isLottie: s.isLottie || false,
+                    emojis: s.emojis || [],
+                    accessibilityLabel: s.accessibilityLabel || ''
+                });
+            } catch (err) {
+                options.logger?.warn?.({ err }, 'failed processing sticker pack item');
+            }
+        }
+        if (stickerMetadata.length === 0) {
+            throw new Boom('No valid stickers could be processed', { statusCode: 400 });
+        }
+
+        const trayIconFileName = `${stickerPackId}.webp`;
+        const coverBuffer = await toBuffer((await getStream(cover)).stream);
+        const coverWebpBuffer = await imageToWebp(coverBuffer);
+        stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 6 }];
+
+        const zipBuffer = await new Promise((resolve, reject) => {
+            zip(stickerData, { level: 6, memLevel: 9 }, (err, data) => {
+                if (err) reject(err);
+                else resolve(Buffer.from(data));
+            });
+        });
+        if (zipBuffer.length > 10 * 1024 * 1024) {
+            throw new Boom(`Sticker pack too large: ${(zipBuffer.length / 1024 / 1024).toFixed(2)}MB`, { statusCode: 400 });
+        }
+
+        const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
+            logger: options.logger,
+            opts: options.options
+        });
+        const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs || 300000
+        });
+
+        m.stickerPackMessage = {
+            name,
+            publisher,
+            stickerPackId,
+            packDescription: description,
+            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            stickerPackSize: zipBuffer.length,
+            stickers: stickerMetadata,
+            fileSha256: stickerPackUpload.fileSha256,
+            fileEncSha256: stickerPackUpload.fileEncSha256,
+            mediaKey: stickerPackUpload.mediaKey,
+            directPath: stickerPackUploadResult.directPath,
+            fileLength: stickerPackUpload.fileLength,
+            mediaKeyTimestamp: unixTimestampSeconds(),
+            trayIconFileName
+        };
+
+        try {
+            let thumbnailBuffer;
+            if ('sharp' in lib && lib.sharp) {
+                thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252, { fit: 'cover' }).jpeg({ quality: 80 }).toBuffer();
+            } else {
+                const jimpImage = await (lib.jimp.Jimp || lib.jimp.default).read(coverBuffer);
+                thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+            }
+            const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+                logger: options.logger,
+                opts: options.options,
+                mediaKey: stickerPackUpload.mediaKey
+            });
+            const thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs || 60000
+            });
+            Object.assign(m.stickerPackMessage, {
+                thumbnailDirectPath: thumbUploadResult.directPath,
+                thumbnailSha256: thumbUpload.fileSha256,
+                thumbnailEncSha256: thumbUpload.fileEncSha256,
+                thumbnailHeight: 252,
+                thumbnailWidth: 252,
+                imageDataHash: sha256(thumbnailBuffer).toString('base64')
+            });
+        } catch (err) {
+            options.logger?.warn?.({ err }, 'failed generating sticker pack thumbnail');
+        }
+
+        m.stickerPackMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
     else if ('sharePhoneNumber' in message) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
@@ -857,7 +1048,7 @@ export const normalizeMessageContent = (content) => {
     if (!content) {
         return undefined;
     }
-    // set max iterations to prevent an infinite loop
+    
     for (let i = 0; i < 5; i++) {
         const inner = getFutureProofMessage(content);
         if (!inner) {
@@ -867,12 +1058,29 @@ export const normalizeMessageContent = (content) => {
     }
     return content;
     function getFutureProofMessage(message) {
-        return (message?.ephemeralMessage ||
-            message?.viewOnceMessage ||
-            message?.documentWithCaptionMessage ||
-            message?.viewOnceMessageV2 ||
-            message?.viewOnceMessageV2Extension ||
-            message?.editedMessage);
+        return ((message === null || message === void 0 ? void 0 : message.ephemeralMessage)
+            || (message === null || message === void 0 ? void 0 : message.viewOnceMessage)
+            || (message === null || message === void 0 ? void 0 : message.documentWithCaptionMessage)
+            || (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2)
+            || (message === null || message === void 0 ? void 0 : message.viewOnceMessageV2Extension)
+            || (message === null || message === void 0 ? void 0 : message.editedMessage)
+            || (message === null || message === void 0 ? void 0 : message.groupMentionedMessage)
+            || (message === null || message === void 0 ? void 0 : message.botInvokeMessage)
+            || (message === null || message === void 0 ? void 0 : message.lottieStickerMessage)
+            || (message === null || message === void 0 ? void 0 : message.eventCoverImage)
+            || (message === null || message === void 0 ? void 0 : message.statusMentionMessage)
+            || (message === null || message === void 0 ? void 0 : message.pollCreationOptionImageMessage)
+            || (message === null || message === void 0 ? void 0 : message.associatedChildMessage)
+            || (message === null || message === void 0 ? void 0 : message.groupStatusMentionMessage)
+            || (message === null || message === void 0 ? void 0 : message.pollCreationMessageV4)
+            || (message === null || message === void 0 ? void 0 : message.pollCreationMessageV5)
+            || (message === null || message === void 0 ? void 0 : message.statusAddYours)
+            || (message === null || message === void 0 ? void 0 : message.groupStatusMessage)
+            || (message === null || message === void 0 ? void 0 : message.limitSharingMessage)
+            || (message === null || message === void 0 ? void 0 : message.botTaskMessage)
+            || (message === null || message === void 0 ? void 0 : message.questionMessage)
+            || (message === null || message === void 0 ? void 0 : message.groupStatusMessageV2)
+            || (message === null || message === void 0 ? void 0 : message.botForwardedMessage));
     }
 };
 /**
@@ -1140,3 +1348,16 @@ export const patchMessageForMdIfRequired = (message) => {
     }
     return message
 }
+
+// Added from Baileys v7.0.0-rc10
+export const hasNonNullishProperty = (message, key) => {
+    return (typeof message === 'object' &&
+        message !== null &&
+        key in message &&
+        message[key] !== null &&
+        message[key] !== undefined);
+};
+function hasOptionalProperty(obj, key) {
+    return typeof obj === 'object' && obj !== null && key in obj && obj[key] !== null;
+}
+

package/lib/Utils/offline-node-processor.d.ts

@@ -0,0 +1,17 @@
+import type { BinaryNode } from '../WABinary/index.js';
+export type MessageType = 'message' | 'call' | 'receipt' | 'notification';
+export type OfflineNodeProcessorDeps = {
+    isWsOpen: () => boolean;
+    onUnexpectedError: (error: Error, msg: string) => void;
+    yieldToEventLoop: () => Promise<void>;
+};
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export declare function makeOfflineNodeProcessor(nodeProcessorMap: Map<MessageType, (node: BinaryNode) => Promise<void>>, deps: OfflineNodeProcessorDeps, batchSize?: number): {
+    enqueue: (type: MessageType, node: BinaryNode) => void;
+};
+//# sourceMappingURL=offline-node-processor.d.ts.map

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
+    const nodes = [];
+    let isProcessing = false;
+    const enqueue = (type, node) => {
+        nodes.push({ type, node });
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const promise = async () => {
+            let processedInBatch = 0;
+            while (nodes.length && deps.isWsOpen()) {
+                const { type, node } = nodes.shift();
+                const nodeProcessor = nodeProcessorMap.get(type);
+                if (!nodeProcessor) {
+                    deps.onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                    continue;
+                }
+                await nodeProcessor(node).catch(err => deps.onUnexpectedError(err, `processing offline ${type}`));
+                processedInBatch++;
+                // Yield to event loop after processing a batch
+                // This prevents blocking the event loop for too long when there are many offline nodes
+                if (processedInBatch >= batchSize) {
+                    processedInBatch = 0;
+                    await deps.yieldToEventLoop();
+                }
+            }
+            isProcessing = false;
+        };
+        promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'));
+    };
+    return { enqueue };
+}
+//# sourceMappingURL=offline-node-processor.js.map

package/lib/Utils/reporting-utils.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto/index.js';
+import type { WAMessageContent, WAMessageKey } from '../Types/index.js';
+import type { BinaryNode } from '../WABinary/index.js';
+export type ReportingField = {
+    f: number;
+    m?: boolean;
+    s?: ReportingField[];
+};
+export declare const shouldIncludeReportingToken: (message: proto.IMessage) => boolean;
+export declare const getMessageReportingToken: (msgProtobuf: Buffer, message: WAMessageContent, key: WAMessageKey) => Promise<BinaryNode | null>;
+//# sourceMappingURL=reporting-utils.d.ts.map