@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

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,88 @@
+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 "./group-metadata-cache.js";
+export * from "./username.js";
+export * from "./disconnect-reason.js";
+export * from "./phone-utils.js";
+export * from "./text-tools.js";
+export * from "./pairing-utils.js";
+export * from "./jid-tools.js";
+export * from "./tag.js";
+export * from "./ffmpeg-path.js";
+export * from "./voice-note.js";
+export * from "./text-format.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 "./fetch-timeout.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 "./payment-utils.js";
+export * from "./native-flow.js";
+export * from "./payment-messages.js";
+export * from "./modern-messages.js";
+export * from "./status-stickers.js";
+export * from "./html-app.js";
+export * from "./newsletter-status.js";
+export * from "./rich-messages.js";
+export * from "./sticker-pack-maker.js";
+export * from "./html-multiplayer.js";
+export * from "./scheduled-message.js";
+export * from "./mini-app.js";
+export * from "./payment-detection.js";
+export * from "./payment-guard.js";
+export * from "./group-status-detection.js";
+export * from "./reconnect-backoff.js";
+export * from "./bad-mac-handler.js";
+export * from "./connection-watchdog.js";
+export * from "./auto-reconnect.js";
+export * from "./humanizer.js";
+export * from "./auth-secure.js";
+export * from "./mock-socket.js";
+export * from "./meta-ai.js";
+export * from "./meta-ai-msmsg.js";
+export * from "./qr-terminal.js";
+export * from "./lock-manager.js";
+export * from "./passkey.js";
+export * from "./migrate-auth-state.js";
+export * from "./android-stanza-id.js";
+export * from "./anchor-guard.js";
+export * from "./media-processor.js";
+export * from "./link-preview-metadata.js";
+export * from "./ttl-cache.js";

package/lib/Utils/index.js

@@ -0,0 +1,93 @@
+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 './group-metadata-cache.js';
+export * from './username.js';
+export * from './disconnect-reason.js';
+export * from './phone-utils.js';
+export * from './text-tools.js';
+export * from './pairing-utils.js';
+export * from './jid-tools.js';
+export * from './tag.js';
+export * from './ffmpeg-path.js';
+export * from './voice-note.js';
+export * from './text-format.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 './fetch-timeout.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 './payment-utils.js';
+// Vanz@Port (v2.1.6) --- ports from reference forks (elaina/vinzsocket/blurose/japofc/lpzeravk)
+export * from './native-flow.js';
+export * from './payment-messages.js';
+export * from './modern-messages.js';
+export * from './status-stickers.js';
+export * from './html-app.js';
+export * from './newsletter-status.js';
+export * from './rich-messages.js';
+export * from './sticker-pack-maker.js';
+export * from './html-multiplayer.js';
+export * from './scheduled-message.js';
+export * from './mini-app.js';
+export * from './payment-detection.js';
+export * from './payment-guard.js';
+export * from './group-status-detection.js';
+// Vanz@Port (v2.1.14) --- stability helpers from lpzeravk/systemzero
+export * from './reconnect-backoff.js';
+export * from './bad-mac-handler.js';
+export * from './connection-watchdog.js';
+// Vanz@Port (v2.0.3) --- japofc: auto-reconnect manager, humanized sender, encrypted auth state + security pack, offline mock socket
+export * from './auto-reconnect.js';
+export * from './humanizer.js';
+export * from './auth-secure.js';
+export * from './mock-socket.js';
+export * from './meta-ai.js';
+export * from './meta-ai-msmsg.js';
+export * from './qr-terminal.js';
+export * from './lock-manager.js';
+export * from './passkey.js';
+export * from './migrate-auth-state.js';
+export * from './android-stanza-id.js';
+
+// Vanz@Port (0.0.1) --- from rennzsync/elaina references
+export * from './anchor-guard.js';
+export * from './media-processor.js';
+export * from './link-preview-metadata.js';
+export * from './ttl-cache.js';

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

@@ -0,0 +1,3 @@
+export function getPhoneNumber(sock: any, jid: any): Promise<any>;
+export function resolveSenderPn(sock: any, webMessage: any): Promise<any>;
+export function getLidForPhone(sock: any, phone: any): Promise<any>;

package/lib/Utils/jid-tools.js

@@ -0,0 +1,78 @@
+// Vanz@Port (2.0.3) --- from @japofc/baileys 2.4.1 (MIT, author JAPofc / J.AP), lib/Utils/jid-tools.js. See NOTICE.md.
+/**
+ * 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-metadata.d.ts

@@ -0,0 +1,47 @@
+import type { proto } from '../../WAProto/index.js';
+
+export declare const SocialMediaPostType: Readonly<{
+    NONE: 0;
+    REEL: 1;
+    LIVE_VIDEO: 2;
+    LONG_VIDEO: 3;
+    SINGLE_IMAGE: 4;
+    CAROUSEL: 5;
+}>;
+
+export declare function videoEndCard(options?: {
+    username?: string;
+    caption?: string;
+    thumbnailUrl?: string;
+    profilePictureUrl?: string;
+}): proto.Message.IVideoEndCard;
+
+export interface SocialPreviewOptions {
+    postType?: number;
+    videoUrl?: string;
+    videoCaption?: string;
+    muted?: boolean;
+    /** Seconds, not milliseconds — the client stores link_media_duration_seconds. */
+    durationSeconds?: number;
+    experimentId?: number;
+    music?: proto.IEmbeddedMusic;
+    endCards?: proto.Message.IVideoEndCard[];
+}
+
+export declare function buildSocialPreview(options?: SocialPreviewOptions): {
+    linkPreviewMetadata?: proto.Message.ILinkPreviewMetadata;
+    videoContentUrl?: string;
+    musicMetadata?: proto.IEmbeddedMusic;
+    endCardTiles?: proto.Message.IVideoEndCard[];
+};
+
+export declare function readSocialPreview(msg: any): {
+    postType?: number;
+    durationSeconds?: number;
+    muted?: boolean;
+    videoUrl?: string;
+    videoCaption?: string;
+    music?: proto.IEmbeddedMusic;
+    experimentId?: number;
+    endCards?: proto.Message.IVideoEndCard[];
+} | null;

package/lib/Utils/link-preview-metadata.js

@@ -0,0 +1,90 @@
+// Ported into @vanzxysenpai/baileys 0.0.1 from @rexxhayanasi/elaina-baileys 1.4.7, MIT. See NOTICE.md.
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+
+export const SocialMediaPostType = Object.freeze({
+    NONE: 0,
+    REEL: 1,
+    LIVE_VIDEO: 2,
+    LONG_VIDEO: 3,
+    SINGLE_IMAGE: 4,
+    CAROUSEL: 5
+})
+
+const drop = (object) => {
+    for (const key of Object.keys(object)) {
+        if (object[key] === undefined || object[key] === null) {
+            delete object[key]
+        }
+    }
+    return object
+}
+
+export const videoEndCard = ({ username, caption, thumbnailUrl, profilePictureUrl } = {}) =>
+    drop({
+        username,
+        caption,
+        thumbnailImageUrl: thumbnailUrl,
+        profilePictureUrl
+    })
+
+/**
+ * The same video url and music node exist twice, once nested in
+ * LinkPreviewMetadata and once directly on ExtendedTextMessage. Which one the
+ * client reads is not visible from the client, so both carry the same value.
+ */
+export const buildSocialPreview = ({
+    postType,
+    videoUrl,
+    videoCaption,
+    muted,
+    durationSeconds,
+    experimentId,
+    music,
+    endCards
+} = {}) => {
+    if (postType !== undefined && !Object.values(SocialMediaPostType).includes(postType)) {
+        throw new TypeError(`postType ${postType} is not one of ${Object.keys(SocialMediaPostType).join(', ')}`)
+    }
+    if (durationSeconds !== undefined && (!Number.isFinite(Number(durationSeconds)) || Number(durationSeconds) < 0)) {
+        throw new TypeError('durationSeconds must be a non-negative number of seconds, not milliseconds')
+    }
+
+    const metadata = drop({
+        socialMediaPostType: postType,
+        linkMediaDuration: durationSeconds === undefined ? undefined : Math.round(Number(durationSeconds)),
+        linkInlineVideoMuted: muted === undefined ? undefined : !!muted,
+        videoContentUrl: videoUrl,
+        videoContentCaption: videoCaption,
+        musicMetadata: music,
+        fbExperimentId: experimentId
+    })
+
+    return drop({
+        linkPreviewMetadata: Object.keys(metadata).length ? metadata : undefined,
+        videoContentUrl: videoUrl,
+        musicMetadata: music,
+        endCardTiles: endCards?.length ? endCards : undefined
+    })
+}
+
+export const readSocialPreview = (msg) => {
+    const message = msg?.message ?? msg
+    const text = message?.extendedTextMessage
+    if (!text) {
+        return null
+    }
+    const metadata = text.linkPreviewMetadata
+    if (!metadata && !text.endCardTiles?.length && !text.videoContentUrl) {
+        return null
+    }
+    return drop({
+        postType: metadata?.socialMediaPostType,
+        durationSeconds: metadata?.linkMediaDuration,
+        muted: metadata?.linkInlineVideoMuted,
+        videoUrl: metadata?.videoContentUrl ?? text.videoContentUrl,
+        videoCaption: metadata?.videoContentCaption,
+        music: metadata?.musicMetadata ?? text.musicMetadata,
+        experimentId: metadata?.fbExperimentId,
+        endCards: text.endCardTiles?.length ? text.endCardTiles : undefined
+    })
+}

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;
+}>;

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/lock-manager.d.ts

@@ -0,0 +1,5 @@
+export function makeLockManager(): {
+    withLock: (ref: any, work: any) => Promise<any>;
+    withLocks(refs: any, work: any): Promise<any>;
+    isLocked(ref: any): boolean;
+};

package/lib/Utils/lock-manager.js

@@ -0,0 +1,50 @@
+import { makeKeyedMutex } from './make-mutex.js';
+
+/**
+ * Deterministic multi-key locking built on the existing keyed mutex.
+ * Locks are sorted before acquisition so overlapping multi-lock operations
+ * cannot deadlock because callers supplied keys in different orders.
+ */
+const refKey = ({ namespace, id }) => `${String(namespace)}\0${String(id)}`;
+const compareRefs = (a, b) => refKey(a).localeCompare(refKey(b));
+
+export const makeLockManager = () => {
+    const keyed = makeKeyedMutex();
+    const held = new Map();
+    const mark = (key, delta) => {
+        const next = (held.get(key) || 0) + delta;
+        if (next > 0) held.set(key, next);
+        else held.delete(key);
+    };
+    const withOne = async (ref, work) => {
+        if (!ref || ref.namespace == null || ref.id == null) throw new TypeError('lock ref requires namespace and id');
+        if (typeof work !== 'function') throw new TypeError('lock work must be a function');
+        const key = refKey(ref);
+        return keyed.mutex(key, async () => {
+            mark(key, 1);
+            try { return await work(); }
+            finally { mark(key, -1); }
+        });
+    };
+    return {
+        withLock: withOne,
+        withLocks(refs, work) {
+            if (!Array.isArray(refs)) throw new TypeError('refs must be an array');
+            if (typeof work !== 'function') throw new TypeError('lock work must be a function');
+            const unique = new Map();
+            for (const ref of refs) {
+                if (!ref || ref.namespace == null || ref.id == null) throw new TypeError('lock ref requires namespace and id');
+                unique.set(refKey(ref), ref);
+            }
+            const sorted = [...unique.values()].sort(compareRefs);
+            const acquire = (i) => i >= sorted.length
+                ? Promise.resolve().then(work)
+                : withOne(sorted[i], () => acquire(i + 1));
+            return acquire(0);
+        },
+        isLocked(ref) {
+            if (!ref || ref.namespace == null || ref.id == null) return false;
+            return held.has(refKey(ref));
+        }
+    };
+};

package/lib/Utils/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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.
+ *
+ * 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.
+ *
+ * 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>;
+};