@japofc/baileys 2.1.0

package/lib/Utils/history.js

@@ -0,0 +1,146 @@
+import { pipeline } from 'stream/promises';
+import { promisify } from 'util';
+import { createInflate, inflate } from 'zlib';
+import { proto } from '../../WAProto/index.js';
+import { WAMessageStubType } from '../Types/index.js';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
+import { toNumber } from './generics.js';
+import { normalizeMessageContent } from './messages.js';
+import { downloadContentFromMessage } from './messages-media.js';
+const inflatePromise = promisify(inflate);
+const extractPnFromMessages = (messages) => {
+    for (const msgItem of messages) {
+        const message = msgItem.message;
+        // Only extract from outgoing messages (fromMe: true) in 1:1 chats
+        // because userReceipt.userJid is the recipient's JID
+        if (!message?.key?.fromMe || !message.userReceipt?.length) {
+            continue;
+        }
+        const userJid = message.userReceipt[0]?.userJid;
+        if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
+            return userJid;
+        }
+    }
+    return undefined;
+};
+export const downloadHistory = async (msg, options) => {
+    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
+    // Pipe decrypted stream directly through zlib inflate
+    // This avoids allocating an intermediate buffer for the compressed data
+    const inflater = createInflate();
+    const chunks = [];
+    inflater.on('data', (chunk) => chunks.push(chunk));
+    await pipeline(stream, inflater);
+    const buffer = Buffer.concat(chunks);
+    const syncData = proto.HistorySync.decode(buffer);
+    return syncData;
+};
+export const processHistoryMessage = (item, logger) => {
+    const messages = [];
+    const contacts = [];
+    const chats = [];
+    const lidPnMappings = [];
+    
+    // JAP@Fix (bug 56): validate sync message before processing
+    // Ensure required fields are present and valid
+    if (!item || typeof item !== 'object') {
+        logger?.warn('invalid history sync message: null or not object');
+        return { messages, contacts, chats, lidPnMappings };
+    }
+    
+    if (!item.syncType) {
+        logger?.warn('invalid history sync message: missing syncType');
+        return { messages, contacts, chats, lidPnMappings };
+    }
+    
+    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
+    // Extract LID-PN mappings for all sync types
+    for (const m of item.phoneNumberToLidMappings || []) {
+        if (m.lidJid && m.pnJid) {
+            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
+        }
+    }
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                contacts.push({
+                    id: chat.id,
+                    name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
+                    lid: chat.lidJid || chat.accountLid || undefined,
+                    phoneNumber: chat.pnJid || undefined
+                });
+                const chatId = chat.id;
+                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+                if (isLid && chat.pnJid) {
+                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
+                }
+                else if (isPn && chat.lidJid) {
+                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
+                }
+                else if (isLid && !chat.pnJid) {
+                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
+                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+                    if (pnFromReceipt) {
+                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
+                    }
+                }
+                const msgs = chat.messages || [];
+                delete chat.messages;
+                for (const item of msgs) {
+                    const message = item.message;
+                    messages.push(message);
+                    if (!chat.messages?.length) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }];
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+                    }
+                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        });
+                    }
+                }
+                chats.push(chat);
+            }
+            break;
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname });
+            }
+            break;
+    }
+    return {
+        chats,
+        contacts,
+        messages,
+        lidPnMappings,
+        pastParticipants: item.pastParticipants,
+        syncType: item.syncType,
+        progress: item.progress
+    };
+};
+export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
+    let historyMsg;
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
+    }
+    else {
+        historyMsg = await downloadHistory(msg, options);
+    }
+    return processHistoryMessage(historyMsg, logger);
+};
+export const getHistoryMsg = (message) => {
+    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+    return anyHistoryMsg;
+};

package/lib/Utils/humanizer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * JAP@Add --- Type declarations for the humanized sender.
+ */
+export interface HumanizeOptions {
+    wpm?: number;
+    minDelayMs?: number;
+    maxDelayMs?: number;
+    jitter?: number;
+    typing?: boolean;
+    queue?: boolean;
+}
+export declare const sendHumanized: (sock: any, jid: any, content: any, humanOpts?: HumanizeOptions, sendOptions?: any) => Promise<any>;

package/lib/Utils/humanizer.js

@@ -0,0 +1,73 @@
+/**
+ * JAP@Add --- Humanized sender (anti-ban friendly).
+ *
+ * Sends like a human: shows `typing...` presence, waits proportionally to the
+ * message length (words-per-minute + jitter), and serializes sends per chat so
+ * bursts never fire at once. Presence failures never break the send.
+ *
+ * ```js
+ * await sendHumanized(sock, jid, { text: 'Halo, apa kabar?' })
+ * // or: await sock.sendHumanized(jid, { text: '...' })
+ * ```
+ */
+import { Boom } from '@hapi/boom';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Per-chat promise chains (no dependency on makeKeyedMutex API shape).
+const chains = new Map();
+const enqueue = (jid, fn) => {
+    const prev = chains.get(jid) || Promise.resolve();
+    const next = prev.catch(() => { }).then(fn);
+    chains.set(jid, next);
+    next.finally(() => {
+        if (chains.get(jid) === next) {
+            chains.delete(jid);
+        }
+    });
+    return next;
+};
+const extractText = (content) => {
+    if (!content || typeof content !== 'object') {
+        return '';
+    }
+    return content.text || content.caption || '';
+};
+const computeDelayMs = (text, { wpm, minDelayMs, maxDelayMs, jitter }) => {
+    const words = text.trim().split(/\s+/).filter(Boolean).length;
+    const natural = words <= 0 ? minDelayMs : (words / Math.max(1, wpm)) * 60000;
+    const clamped = Math.min(Math.max(natural, minDelayMs), maxDelayMs);
+    const wobble = 1 + (Math.random() * 2 - 1) * Math.max(0, Math.min(1, jitter));
+    return Math.round(clamped * wobble);
+};
+/**
+ * Humanized send. `humanOpts`: wpm (default 200), minDelayMs (900),
+ * maxDelayMs (12000), jitter (0.25), typing (true), queue (true).
+ */
+export const sendHumanized = async (sock, jid, content, { wpm = 200, minDelayMs = 900, maxDelayMs = 12000, jitter = 0.25, typing = true, queue = true } = {}, sendOptions = {}) => {
+    if (!sock || typeof sock.sendMessage !== 'function') {
+        throw new Boom('sendHumanized(sock, ...) requires an active Baileys socket', { statusCode: 400 });
+    }
+    const run = async () => {
+        if (typing && typeof sock.sendPresenceUpdate === 'function') {
+            try {
+                if (typeof sock.presenceSubscribe === 'function') {
+                    await sock.presenceSubscribe(jid).catch(() => { });
+                }
+                await sock.sendPresenceUpdate('composing', jid);
+            }
+            catch { }
+        }
+        await sleep(computeDelayMs(extractText(content), { wpm, minDelayMs, maxDelayMs, jitter }));
+        try {
+            return await sock.sendMessage(jid, content, sendOptions);
+        }
+        finally {
+            if (typing && typeof sock.sendPresenceUpdate === 'function') {
+                try {
+                    await sock.sendPresenceUpdate('paused', jid);
+                }
+                catch { }
+            }
+        }
+    };
+    return queue ? enqueue(jid, run) : run();
+};

package/lib/Utils/identity-change-handler.d.ts

@@ -0,0 +1,13 @@
+export function handleIdentityChange(node: any, ctx: any): Promise<{
+    action: string;
+    device?: undefined;
+    error?: undefined;
+} | {
+    action: string;
+    device: number;
+    error?: undefined;
+} | {
+    action: string;
+    error: unknown;
+    device?: undefined;
+}>;

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,49 @@
+import NodeCache from '@cacheable/node-cache';
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}

package/lib/Utils/index.d.ts

@@ -0,0 +1,57 @@
+export * from "./generics.js";
+export * from "./decode-wa-message.js";
+export * from "./messages.js";
+export * from "./messages-media.js";
+export * from "./validate-connection.js";
+export * from "./crypto.js";
+export * from "./signal.js";
+export * from "./noise-handler.js";
+export * from "./history.js";
+export * from "./chat-utils.js";
+export * from "./lt-hash.js";
+export * from "./auth-utils.js";
+export * from "./use-multi-file-auth-state.js";
+export * from "./use-single-file-auth-state.js";
+export * from "./use-sqlite-auth-state.js";
+export * from "./link-preview.js";
+export * from "./event-buffer.js";
+export * from "./process-message.js";
+export * from "./rich-message-utils.js";
+export * from "./PersistentStore.js";
+export * from "./message-kind.js";
+export * from "./message-retry-manager.js";
+export * from "./browser-utils.js";
+export * from "./companion-reg-client-utils.js";
+export * from "./identity-change-handler.js";
+export * from "./stanza-ack.js";
+export * from "./button-helper-utils.js";
+export * from "./button-sender.js";
+export * from "./anti-delete.js";
+export * from "./message-search.js";
+export * from "./chat-history-helpers.js";
+export * from "./scheduling.js";
+export * from "./auto-reply.js";
+export * from "./templates.js";
+export * from "./vcard.js";
+export * from "./media-messages.js";
+export * from "./stickerpack.js";
+export * from "./media-set.js";
+export * from "./status.js";
+export * from "./use-cache-manager-auth-state.js";
+export * from "./baileys-event-stream.js";
+export * from "./past-participants.js";
+export * from "./chat-control.js";
+export * from "./mini-app.js";
+export * from "./voice-note.js";
+export * from "./tag.js";
+export * from "./jid-tools.js";
+export * from "./meta-ai.js";
+export * from "./humanizer.js";
+export * from "./router.js";
+export * from "./scheduled-posts.js";
+export * from "./history-share.js";
+export * from "./transcribe.js";
+export * from "./auth-secure.js";
+export * from "./qr-render.js";
+
+export * from "./MessageBuilder.js";

package/lib/Utils/index.js

@@ -0,0 +1,56 @@
+export * from './generics.js';
+export * from './decode-wa-message.js';
+export * from './messages.js';
+export * from './messages-media.js';
+export * from './validate-connection.js';
+export * from './crypto.js';
+export * from './signal.js';
+export * from './noise-handler.js';
+export * from './history.js';
+export * from './chat-utils.js';
+export * from './lt-hash.js';
+export * from './auth-utils.js';
+export * from './use-multi-file-auth-state.js';
+export * from './use-single-file-auth-state.js';
+export * from './use-sqlite-auth-state.js';
+export * from './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.js';
+export * from './rich-message-utils.js';
+export * from './MessageBuilder.js';
+export * from './PersistentStore.js';
+export * from './message-kind.js';
+export * from './message-retry-manager.js';
+export * from './browser-utils.js';
+export * from './companion-reg-client-utils.js';
+export * from './identity-change-handler.js';
+export * from './stanza-ack.js';
+export * from './button-helper-utils.js';
+export * from './button-sender.js';
+export * from './anti-delete.js';
+export * from './message-search.js';
+export * from './chat-history-helpers.js';
+export * from './scheduling.js';
+export * from './auto-reply.js';
+export * from './templates.js';
+export * from './vcard.js';
+export * from './media-messages.js';
+export * from './stickerpack.js';
+export * from './media-set.js';
+export * from './status.js';
+export * from './use-cache-manager-auth-state.js';
+export * from './baileys-event-stream.js';
+export * from './past-participants.js';
+export * from './chat-control.js';
+export * from './mini-app.js';
+export * from './voice-note.js';
+export * from './tag.js';
+export * from './jid-tools.js';
+export * from './meta-ai.js';
+export * from './humanizer.js';
+export * from './router.js';
+export * from './scheduled-posts.js';
+export * from './history-share.js';
+export * from './auth-secure.js';
+export * from './transcribe.js';
+export * from './qr-render.js';

package/lib/Utils/jid-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * JAP@Add --- Type declarations for JID helpers.
+ */
+export declare const getPhoneNumber: (sock: any, jid: string) => Promise<string | null>;
+export declare const resolveSenderPn: (sock: any, webMessage: any) => Promise<string | null>;
+export declare const getLidForPhone: (sock: any, phone: string) => Promise<string | null>;

package/lib/Utils/jid-tools.js

@@ -0,0 +1,77 @@
+/**
+ * JAP@Add --- JID helpers: LID ↔ phone-number resolution.
+ *
+ * Since WhatsApp's LID migration, events (call offers, group updates, ...) often
+ * carry only an opaque `@lid` JID. These helpers resolve it to a phone number
+ * through the socket's signal-repository mapping (cached + USYNC-backed).
+ *
+ * ```js
+ * await getPhoneNumber(sock, '123456@lid') // → '62812xxxx' | null
+ * await getLidForPhone(sock, '62812xxxx')  // → '123456@lid' | null
+ * // or: sock.getPhoneNumber(jid), sock.getLidForPhone(phone)
+ * ```
+ */
+import { Boom } from '@hapi/boom';
+import { jidDecode } from '../WABinary/index.js';
+/** Resolve any JID to a phone-number string. Returns `null` when unresolvable (never throws for that). */
+export const getPhoneNumber = async (sock, jid) => {
+    if (typeof jid !== 'string' || !jid.includes('@')) {
+        throw new Boom('getPhoneNumber(jid) requires a JID string', { statusCode: 400 });
+    }
+    let decoded;
+    try {
+        decoded = jidDecode(jid);
+    }
+    catch {
+        throw new Boom(`getPhoneNumber: invalid JID ${jid}`, { statusCode: 400 });
+    }
+    const { user, server } = decoded;
+    if (server === 's.whatsapp.net') {
+        return user;
+    }
+    if (server === 'lid') {
+        const store = sock?.signalRepository?.lidMapping;
+        if (!store || typeof store.getPNForLID !== 'function') {
+            throw new Boom('getPhoneNumber: LID resolution needs an active socket', { statusCode: 400 });
+        }
+        try {
+            const pn = await store.getPNForLID(`${user}@lid`);
+            return typeof pn === 'string' && pn.includes('@') ? pn.split('@')[0] : null;
+        }
+        catch {
+            return null; // best-effort: offline/USYNC failure → unknown, not fatal
+        }
+    }
+    return null; // groups, channels, status, bots have no phone number
+};
+/**
+ * Resolve an incoming message's sender to a phone number.
+ * One-liner fix for LID-only events (e.g. call offers without `caller_pn`):
+ * `await sock.resolveSenderPn(msg)` → `'62812…'` | `null`.
+ */
+export const resolveSenderPn = async (sock, webMessage) => {
+    const sender = webMessage?.key?.participant || webMessage?.key?.remoteJid;
+    if (!sender || typeof sender !== 'string') {
+        throw new Boom('resolveSenderPn(msg) needs a message with key.participant/remoteJid', { statusCode: 400 });
+    }
+    return getPhoneNumber(sock, sender);
+};
+/** Reverse lookup: phone number (or PN JID) → `@lid` JID. Returns `null` when unknown. */
+export const getLidForPhone = async (sock, phone) => {
+    const store = sock?.signalRepository?.lidMapping;
+    if (!store || typeof store.getLIDForPN !== 'function') {
+        throw new Boom('getLidForPhone(sock, ...) requires an active socket', { statusCode: 400 });
+    }
+    const pn = typeof phone === 'string' && phone.includes('@')
+        ? phone
+        : `${String(phone || '').replace(/\D/g, '')}@s.whatsapp.net`;
+    if (!pn.split('@')[0]) {
+        throw new Boom('getLidForPhone(phone) requires a phone number', { statusCode: 400 });
+    }
+    try {
+        return (await store.getLIDForPN(pn)) || null;
+    }
+    catch {
+        return null;
+    }
+};

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,12 @@
+export function getUrlInfo(text: any, opts?: {
+    thumbnailWidth: number;
+    fetchOpts: {
+        timeout: number;
+    };
+}): Promise<{
+    'canonical-url': any;
+    'matched-text': any;
+    title: any;
+    description: any;
+    originalThumbnailUrl: any;
+} | undefined>;

package/lib/Utils/link-preview.js

@@ -0,0 +1,84 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+        // retries
+        let retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries += 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
+        });
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};

package/lib/Utils/logger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: any;
+export default _default;
+/** Pino-compatible logger surface (typed loosely). */
+export type ILogger = any;

package/lib/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ *
+ * JAP@Fix (bug 36 follow-up): whatsapp-rust-bridge is a native module and was previously
+ * statically imported here, which crashed the *entire* library at import time on platforms
+ * without a prebuilt binary (ARM musl/Alpine/Termux/some Pterodactyl nodes) — even for bots
+ * that never touch app-state sync. Same top-level-await try/catch pattern as crypto.js:
+ * only throws (with a clear message) if app-state sync (LT hash) is actually used.
+ */
+export let LT_HASH_ANTI_TAMPERING: any;

package/lib/Utils/lt-hash.js

@@ -0,0 +1,26 @@
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ *
+ * JAP@Fix (bug 36 follow-up): whatsapp-rust-bridge is a native module and was previously
+ * statically imported here, which crashed the *entire* library at import time on platforms
+ * without a prebuilt binary (ARM musl/Alpine/Termux/some Pterodactyl nodes) — even for bots
+ * that never touch app-state sync. Same top-level-await try/catch pattern as crypto.js:
+ * only throws (with a clear message) if app-state sync (LT hash) is actually used.
+ */
+let LT_HASH_ANTI_TAMPERING;
+try {
+    const { LTHashAntiTampering } = await import('whatsapp-rust-bridge');
+    LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+}
+catch (err) {
+    const message = '`whatsapp-rust-bridge` failed to load (no prebuilt binary for this platform/arch). ' +
+        'App-state sync (LT hash) is unavailable here. Original error: ' + (err?.message || err);
+    LT_HASH_ANTI_TAMPERING = new Proxy({}, {
+        get() {
+            throw new Error(message);
+        }
+    });
+}
+export { LT_HASH_ANTI_TAMPERING };

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,6 @@
+export function makeMutex(): {
+    mutex(code: any): any;
+};
+export function makeKeyedMutex(): {
+    mutex(key: any, task: any): Promise<any>;
+};