@xbibzlibrary/whatsbibz 1.3.0

package/lib/BibzWhats/pairing.js

@@ -0,0 +1,186 @@
+// BibzWhats — PairingController
+// Meminta pairing code (custom 8 karakter atau acak bawaan) dengan disiplin:
+//  • satu request in-flight pada satu waktu
+//  • refresh berjeda panjang (default 150 dtk) agar kode yang sedang diketik
+//    di HP tidak hangus di tengah percobaan
+//  • custom code ditolak server → fallback SEKALI ke kode acak
+//  • rate-limit (428/429) → backoff eksponensial sampai PAIRING_BACKOFF_MAX_MS
+//  • berhenti otomatis begitu creds.registered = true
+
+export const PAIRING_REFRESH_MS = 150000;
+export const PAIRING_BACKOFF_MAX_MS = 600000;
+
+export function normalizePairingCode(value) {
+    const normalized = String(value ?? '').trim().toUpperCase();
+    return /^[A-Z0-9]{8}$/.test(normalized) ? normalized : '';
+}
+
+/**
+ * Kode error dari server. Boom hasil assertNodeErrorFree menyimpan kode stanza
+ * WA di `error.data` (mis. 400 bad-request, 429 rate-overlimit), sedangkan
+ * statusCode Boom-nya 500 generik — jadi keduanya harus dicek.
+ */
+export function pairingErrorCode(error) {
+    const fromData = typeof error?.data === 'number' ? error.data : undefined;
+    const status = error?.output?.statusCode ?? error?.statusCode ?? error?.status;
+    return fromData ?? (status && status !== 500 ? status : undefined);
+}
+
+export function isRateLimitError(error) {
+    const code = pairingErrorCode(error);
+    return code === 428 || code === 429 || /rate[- ]?overlimit|rate.?limit|too many|428|429/i.test(String(error?.message || error));
+}
+
+export function isCustomPairingError(error) {
+    const code = pairingErrorCode(error);
+    return code === 422 || /custom pairing code|pairing code.*(invalid|reject|unsupported)|invalid.*pairing/i.test(String(error?.message || error));
+}
+
+/** 400 bad-request pada companion_hello = server tidak mengenali companion_platform_display (bukan soal kode custom) */
+export function isRegistrationRejected(error) {
+    return pairingErrorCode(error) === 400 || /bad-request/i.test(String(error?.message || error));
+}
+
+export function isTimeoutError(error) {
+    return pairingErrorCode(error) === 408 || /timed out|timeout/i.test(String(error?.message || error));
+}
+
+function emitLog(logger, level, message) {
+    if (typeof logger?.[level] === 'function') logger[level](message);
+    else if (typeof logger?.warn === 'function') logger.warn(message);
+}
+
+/**
+ * @param {object} opts
+ * @param {import('../Socket/index.js').WASocket} opts.sock
+ * @param {string} opts.phone            nomor bot, digit saja (E.164 tanpa +)
+ * @param {string} [opts.pairingCode]    kode custom 8 karakter A-Z0-9 (opsional)
+ * @param {(code: string, meta: {custom: boolean, fallback: boolean}) => void} [opts.onCode]
+ * @param {object} [opts.logger]
+ * @param {number} [opts.refreshMs]
+ * @param {number} [opts.backoffMaxMs]
+ */
+export function createPairingController({
+    sock,
+    phone,
+    pairingCode = '',
+    onCode = () => {},
+    logger = console,
+    refreshMs = PAIRING_REFRESH_MS,
+    backoffMaxMs = PAIRING_BACKOFF_MAX_MS,
+    setTimeoutFn = setTimeout,
+    clearTimeoutFn = clearTimeout,
+    /**
+     * dipanggil saat server MENOLAK registrasi (400 bad-request / kode lain yang
+     * bukan rate-limit & bukan timeout). Kembalikan true bila pemanggil mengambil
+     * alih (mis. mengganti identitas & menyambung ulang) → controller berhenti,
+     * tidak menjadwalkan ulang. Argumen: (error, { code, phone }).
+     */
+    onRejected = () => false,
+} = {}) {
+    let timer = null;
+    let inFlight = false;
+    let stopped = false;
+    let fallbackUsed = false;
+    let rateLimitDelay = refreshMs;
+
+    const registered = () => !!sock?.authState?.creds?.registered;
+    const stop = () => {
+        stopped = true;
+        if (timer) clearTimeoutFn(timer);
+        timer = null;
+    };
+    const schedule = (delay) => {
+        if (stopped || registered()) return;
+        if (timer) clearTimeoutFn(timer);
+        timer = setTimeoutFn(() => {
+            timer = null;
+            void request();
+        }, delay);
+    };
+    const handleFailure = (error) => {
+        if (isRateLimitError(error)) {
+            const delay = rateLimitDelay;
+            rateLimitDelay = Math.min(rateLimitDelay * 2, backoffMaxMs);
+            emitLog(logger, 'warn', `pairing terkena rate-limit/428 — menunggu ${Math.round(delay / 1000)}s sebelum mencoba lagi`);
+            schedule(delay);
+            return;
+        }
+        if (isRegistrationRejected(error)) {
+            let handled = false;
+            try { handled = !!onRejected(error, { code: pairingErrorCode(error) ?? 400, phone }); } catch {}
+            if (handled) {
+                stop();
+                return;
+            }
+            emitLog(logger, 'error',
+                `registrasi pairing DITOLAK server (400 bad-request): companion_platform_display tidak ada di allow-list WhatsApp. ` +
+                `Biarkan companionPlatformDisplay kosong (library menurunkannya otomatis, mis. 'Chrome (Mac OS)' / 'Chrome (Linux)') ` +
+                `atau pakai nilai yang diterima: browser Chrome/Firefox/Safari/Edge + OS Mac OS/Windows/Linux/Ubuntu/Debian/Fedora. ` +
+                `Coba lagi dalam ${refreshMs / 1000}s.`);
+        } else if (isTimeoutError(error)) {
+            emitLog(logger, 'error',
+                `server tidak menjawab registrasi pairing (timeout) — cek nomor (${phone || '-'}) terdaftar di WhatsApp & jaringan ` +
+                `server tidak diblokir. Coba lagi dalam ${refreshMs / 1000}s.`);
+        } else {
+            emitLog(logger, 'error', `pairing gagal (${error?.message || error}) — percobaan berikutnya paling cepat ${refreshMs / 1000}s lagi`);
+        }
+        schedule(refreshMs);
+    };
+
+    async function request() {
+        if (stopped || inFlight) return null;
+        if (registered()) {
+            stop();
+            return null;
+        }
+        inFlight = true;
+        const custom = normalizePairingCode(pairingCode);
+        const useCustom = !!custom && !fallbackUsed;
+        try {
+            const code = useCustom
+                ? await sock.requestPairingCode(phone, custom)
+                : await sock.requestPairingCode(phone);
+            if (registered()) {
+                stop();
+                return code;
+            }
+            rateLimitDelay = refreshMs;
+            onCode(code, { custom: useCustom, fallback: fallbackUsed });
+            schedule(refreshMs);
+            return code;
+        } catch (error) {
+            if (useCustom && !isRateLimitError(error) && isCustomPairingError(error) && !fallbackUsed) {
+                fallbackUsed = true;
+                emitLog(logger, 'warn', `custom pairing code ditolak (${error?.message || error}) — mencoba sekali dengan kode acak bawaan`);
+                try {
+                    const code = await sock.requestPairingCode(phone);
+                    if (registered()) {
+                        stop();
+                        return code;
+                    }
+                    rateLimitDelay = refreshMs;
+                    onCode(code, { custom: false, fallback: true });
+                    schedule(refreshMs);
+                    return code;
+                } catch (fallbackError) {
+                    handleFailure(fallbackError);
+                    return null;
+                }
+            }
+            handleFailure(error);
+            return null;
+        } finally {
+            inFlight = false;
+        }
+    }
+
+    return {
+        start: request,
+        trigger: request,
+        stop,
+        isInFlight: () => inFlight,
+        isStopped: () => stopped,
+        getState: () => ({ fallbackUsed, timerActive: !!timer, rateLimitDelay }),
+    };
+}

package/lib/BibzWhats/send.d.ts

@@ -0,0 +1,9 @@
+import type { WASocket } from '../index.js';
+import type { AnyMessageContent, WAMessage, WAMessageKey, WAPresence } from '../Types/index.js';
+export declare function splitText(text: string, maxLen?: number): string[];
+export declare function whatsappify(text: string): string;
+export declare function sendWithRetry(sock: WASocket, jid: string, content: AnyMessageContent, options?: any, opts?: { attempts?: number }): Promise<{ result: WAMessage | null; error: Error | null }>;
+export declare function sendText(sock: WASocket, jid: string, text: string, opts?: { quoted?: WAMessage; format?: boolean; maxLen?: number }): Promise<{ ok: boolean; ids: string[]; error?: Error }>;
+export declare function react(sock: WASocket, jid: string, key: WAMessageKey, emoji: string): Promise<WAMessage | undefined>;
+export declare function presence(sock: WASocket, jid: string, state?: WAPresence): Promise<boolean>;
+export declare function sendMedia(sock: WASocket, jid: string, content: AnyMessageContent & Record<string, any>, opts?: { quoted?: WAMessage; fallbackToDocument?: boolean }): Promise<{ result: WAMessage | null; error: Error | null }>;

package/lib/BibzWhats/send.js

@@ -0,0 +1,107 @@
+// BibzWhats — helper kirim pesan yang sering dipakai bot.
+// Semua fungsi menerima `sock` (WASocket) agar bisa dipakai dengan
+// makeWASocket biasa maupun client.sock dari createBibzWhats().
+
+const MAX_TEXT_LEN = 4000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Pecah teks panjang jadi beberapa bagian <= maxLen, utamakan potong di baris/spasi. */
+export function splitText(text, maxLen = MAX_TEXT_LEN) {
+    const out = [];
+    let rest = String(text || '');
+    while (rest.length > maxLen) {
+        let cut = rest.lastIndexOf('\n', maxLen);
+        if (cut < maxLen * 0.5) cut = rest.lastIndexOf(' ', maxLen);
+        if (cut < maxLen * 0.5) cut = maxLen;
+        out.push(rest.slice(0, cut).trim());
+        rest = rest.slice(cut).trim();
+    }
+    if (rest) out.push(rest);
+    return out.filter(Boolean);
+}
+
+/**
+ * Normalisasi markdown gaya ChatGPT → format WhatsApp
+ * (**bold** → *bold*, __x__ → *x*, ~~x~~ → ~x~, heading & link markdown dirapikan).
+ */
+export function whatsappify(text) {
+    if (typeof text !== 'string' || !text) return text;
+    let t = text;
+    for (let i = 0; i < 3; i++) {
+        t = t.replace(/\*\*\*([^*\n]+)\*\*\*/g, '*$1*');
+        t = t.replace(/\*\*([^*\n]+)\*\*/g, '*$1*');
+        t = t.replace(/__([^_\n]+)__/g, '*$1*');
+    }
+    t = t.replace(/_{2,}([^_\n]+)_{2,}/g, '_$1_');
+    t = t.replace(/~~([^~\n]+)~~/g, '~$1~');
+    t = t.replace(/^\s{0,3}#{1,6}\s+/gm, '');
+    t = t.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, '$1 ($2)');
+    t = t.replace(/\*{3,}/g, '*').replace(/_{3,}/g, '_');
+    return t.replace(/^\s+/, '').replace(/\s+$/, '');
+}
+
+/** Kirim dengan retry ringan (3x: 0 / 500 / 1500 ms). */
+export async function sendWithRetry(sock, jid, content, options, { attempts = 3 } = {}) {
+    let lastError = null;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const result = options ? await sock.sendMessage(jid, content, options) : await sock.sendMessage(jid, content);
+            return { result, error: null };
+        } catch (error) {
+            lastError = error;
+            if (attempt < attempts - 1) await sleep(attempt === 0 ? 500 : 1500);
+        }
+    }
+    return { result: null, error: lastError };
+}
+
+/**
+ * Kirim teks panjang: otomatis dipecah ≤4000 karakter, jeda 250 ms antar bagian.
+ * @returns {Promise<{ok: boolean, ids: string[], error?: Error}>}
+ */
+export async function sendText(sock, jid, text, { quoted, format = true, maxLen = MAX_TEXT_LEN } = {}) {
+    const body = format ? whatsappify(String(text ?? '')) : String(text ?? '');
+    const parts = splitText(body, maxLen);
+    const ids = [];
+    for (let i = 0; i < parts.length; i++) {
+        const { result, error } = await sendWithRetry(sock, jid, { text: parts[i] }, quoted ? { quoted } : undefined);
+        if (!result) return { ok: false, ids, error };
+        if (result?.key?.id) ids.push(result.key.id);
+        if (i < parts.length - 1) await sleep(250);
+    }
+    return { ok: true, ids };
+}
+
+/** Reaksi emoji ke sebuah pesan (key = m.key dari pesan masuk). */
+export async function react(sock, jid, key, emoji) {
+    return sock.sendMessage(jid, { react: { text: emoji, key } });
+}
+
+/** Presence 'composing' | 'recording' | 'paused' | 'available' | 'unavailable'. */
+export async function presence(sock, jid, state = 'composing') {
+    try {
+        await sock.sendPresenceUpdate(state, jid);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Kirim media dengan fallback ke dokumen bila pengiriman media gagal.
+ * content: { image|video|audio|sticker|document: Buffer|{url}, mimetype?, caption?, fileName?, ptt? }
+ */
+export async function sendMedia(sock, jid, content, { quoted, fallbackToDocument = true } = {}) {
+    const options = quoted ? { quoted } : undefined;
+    let outcome = await sendWithRetry(sock, jid, content, options);
+    if (outcome.result || !fallbackToDocument || content.document) return outcome;
+    const buffer = content.image || content.video || content.audio || content.sticker;
+    if (!Buffer.isBuffer(buffer)) return outcome;
+    outcome = await sendWithRetry(sock, jid, {
+        document: buffer,
+        mimetype: content.mimetype || 'application/octet-stream',
+        fileName: content.fileName || `media-${Date.now()}.bin`,
+        caption: content.caption || '',
+    }, options);
+    return outcome;
+}

package/lib/BibzWhats/version.d.ts

@@ -0,0 +1,6 @@
+export declare const BIBZWHATS_NAME: 'WhatsBibz';
+/** nama paket di npm */
+export declare const BIBZWHATS_PACKAGE: '@xbibzlibrary/whatsbibz';
+export declare const BIBZWHATS_VERSION: string;
+export declare const BIBZWHATS_UPSTREAM: string;
+export declare const BIBZWHATS_WA_WEB_VERSION: [number, number, number];

package/lib/BibzWhats/version.js

@@ -0,0 +1,7 @@
+export const BIBZWHATS_NAME = 'WhatsBibz';
+/** nama paket di npm */
+export const BIBZWHATS_PACKAGE = '@xbibzlibrary/whatsbibz';
+export const BIBZWHATS_VERSION = '1.3.0';
+export const BIBZWHATS_UPSTREAM = 'ourin-baileys@9.0.21 (fork WhiskeySockets/Baileys v7) + patch upstream s/d rc14/master 2026-08 & PR #2769/#2776/#2778/#2789; identitas platform diukur ke server 2026-09-03';
+/** versi WA Web bawaan (fallback) — diperbarui 2026-09-03 dari web.whatsapp.com */
+export const BIBZWHATS_WA_WEB_VERSION = [2, 3000, 1046721733];

package/lib/Defaults/index.d.ts

@@ -0,0 +1,73 @@
+import { proto } from '../../WAProto/index.js';
+import type { SocketConfig } from '../Types/index.js';
+export declare const UNAUTHORIZED_CODES: number[];
+export declare const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+export declare const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";
+export declare const CALL_AUDIO_PREFIX = "https://call.whatsapp.com/voice/";
+export declare const DEF_CALLBACK_PREFIX = "CB:";
+export declare const DEF_TAG_PREFIX = "TAG:";
+export declare const PHONE_CONNECTION_CB = "CB:Pong";
+export declare const WA_ADV_ACCOUNT_SIG_PREFIX: Buffer;
+export declare const WA_ADV_DEVICE_SIG_PREFIX: Buffer;
+export declare const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: Buffer;
+export declare const WA_ADV_HOSTED_DEVICE_SIG_PREFIX: Buffer;
+export declare const WA_DEFAULT_EPHEMERAL: number;
+/** Status messages older than 24 hours are considered expired */
+export declare const STATUS_EXPIRY_SECONDS: number;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export declare const PLACEHOLDER_MAX_AGE_SECONDS: number;
+export declare const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export declare const DICT_VERSION = 3;
+export declare const KEY_BUNDLE_TYPE: Buffer;
+export declare const NOISE_WA_HEADER: Buffer;
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export declare const URL_REGEX: RegExp;
+export declare const WA_CERT_DETAILS: {
+    SERIAL: number;
+    ISSUER: string;
+    PUBLIC_KEY: Buffer;
+};
+export declare const PROCESSABLE_HISTORY_TYPES: proto.HistorySync.HistorySyncType[];
+export declare const DEFAULT_CONNECTION_CONFIG: SocketConfig;
+export declare const MEDIA_PATH_MAP: {
+    [T in MediaType]?: string;
+};
+export declare const MEDIA_HKDF_KEY_MAPPING: {
+    audio: string;
+    document: string;
+    gif: string;
+    image: string;
+    ppic: string;
+    product: string;
+    ptt: string;
+    sticker: string;
+    video: string;
+    'thumbnail-document': string;
+    'thumbnail-image': string;
+    'thumbnail-video': string;
+    'thumbnail-link': string;
+    'md-msg-hist': string;
+    'md-app-state': string;
+    'product-catalog-image': string;
+    'payment-bg-image': string;
+    ptv: string;
+    'biz-cover-photo': string;
+};
+export type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING;
+export declare const MEDIA_KEYS: MediaType[];
+export declare const MIN_PREKEY_COUNT = 5;
+export declare const INITIAL_PREKEY_COUNT = 812;
+export declare const UPLOAD_TIMEOUT = 30000;
+export declare const MIN_UPLOAD_INTERVAL = 5000;
+export declare const DEFAULT_CACHE_TTLS: {
+    SIGNAL_STORE: number;
+    MSG_RETRY: number;
+    CALL_OFFER: number;
+    USER_DEVICES: number;
+};
+export declare const TimeMs: {
+    Minute: number;
+    Hour: number;
+    Day: number;
+    Week: number;
+};

package/lib/Defaults/index.js

@@ -0,0 +1,141 @@
+import { proto } from "../../WAProto/index.js";
+import { makeLibSignalRepository } from "../Signal/libsignal.js";
+import { Browsers } from "../Utils/browser-utils.js";
+import logger from "../Utils/logger.js";
+const version = [2, 3000, 1046721733];
+export const UNAUTHORIZED_CODES = [401, 403, 419];
+export const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+export const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";
+export const CALL_AUDIO_PREFIX = "https://call.whatsapp.com/voice/";
+export const DEF_CALLBACK_PREFIX = "CB:";
+export const DEF_TAG_PREFIX = "TAG:";
+export const PHONE_CONNECTION_CB = "CB:Pong";
+export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+/** Status messages older than 24 hours are considered expired */
+export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
+export const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export const DICT_VERSION = 3;
+export const KEY_BUNDLE_TYPE = Buffer.from([5]);
+export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export const URL_REGEX =
+  /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+export const WA_CERT_DETAILS = {
+  SERIAL: 0,
+  ISSUER: "WhatsAppLongTerm1",
+  PUBLIC_KEY: Buffer.from(
+    "142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b",
+    "hex",
+  ),
+};
+export const PROCESSABLE_HISTORY_TYPES = [
+  proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
+  proto.HistorySync.HistorySyncType.PUSH_NAME,
+  proto.HistorySync.HistorySyncType.RECENT,
+  proto.HistorySync.HistorySyncType.FULL,
+  proto.HistorySync.HistorySyncType.ON_DEMAND,
+  proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+  proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3,
+];
+export const DEFAULT_CONNECTION_CONFIG = {
+  version: version,
+  browser: Browsers.macOS("Chrome"),
+  waWebSocketUrl: "wss://web.whatsapp.com/ws/chat",
+  connectTimeoutMs: 20000,
+  keepAliveIntervalMs: 30000,
+  logger: logger.child({ class: "bibzwhats" }),
+  emitOwnEvents: true,
+  defaultQueryTimeoutMs: 60000,
+  customUploadHosts: [],
+  retryRequestDelayMs: 250,
+  maxMsgRetryCount: 5,
+  fireInitQueries: true,
+  auth: undefined,
+  markOnlineOnConnect: true,
+  syncFullHistory: true,
+  patchMessageBeforeSending: (msg) => msg,
+  shouldSyncHistoryMessage: ({ syncType }) => {
+    return syncType !== proto.HistorySync.HistorySyncType.FULL;
+  },
+  shouldIgnoreJid: () => false,
+  linkPreviewImageThumbnailWidth: 192,
+  transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+  generateHighQualityLinkPreview: false,
+  enableAutoSessionRecreation: true,
+  enableRecentMessageCache: true,
+  options: {},
+  appStateMacVerification: {
+    patch: false,
+    snapshot: false,
+  },
+  countryCode: "US",
+  // BibzWhats: tidak ada auto-follow channel diam-diam. Set true + isi
+  // autoFollowNewsletterJid bila memang ingin memakainya.
+  autoFollowNewsletterOnConnect: false,
+  autoFollowNewsletterDelayMs: 90000,
+  autoFollowNewsletterJid: "",
+  getMessage: async () => undefined,
+  cachedGroupMetadata: async () => undefined,
+  makeSignalRepository: makeLibSignalRepository,
+};
+export const MEDIA_PATH_MAP = {
+  image: "/mms/image",
+  video: "/mms/video",
+  document: "/mms/document",
+  audio: "/mms/audio",
+  sticker: "/mms/image",
+  "thumbnail-link": "/mms/image",
+  "product-catalog-image": "/product/image",
+  "md-app-state": "",
+  "md-msg-hist": "/mms/md-app-state",
+  "biz-cover-photo": "/pps/biz-cover-photo",
+  "sticker-pack": "/mms/document",
+  "thumbnail-image": "/mms/document",
+  "thumbnail-sticker-pack": "/mms/document",
+};
+export const MEDIA_HKDF_KEY_MAPPING = {
+  audio: "Audio",
+  document: "Document",
+  gif: "Video",
+  image: "Image",
+  ppic: "",
+  product: "Image",
+  ptt: "Audio",
+  sticker: "Image",
+  video: "Video",
+  "thumbnail-document": "Document Thumbnail",
+  "thumbnail-image": "Image Thumbnail",
+  "thumbnail-video": "Video Thumbnail",
+  "thumbnail-link": "Link Thumbnail",
+  "thumbnail-sticker-pack": "Image Thumbnail",
+  "md-msg-hist": "History",
+  "md-app-state": "App State",
+  "product-catalog-image": "",
+  "payment-bg-image": "Payment Background",
+  ptv: "Video",
+  "biz-cover-photo": "Image",
+  "sticker-pack": "Sticker Pack",
+};
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+export const MIN_PREKEY_COUNT = 5;
+export const INITIAL_PREKEY_COUNT = 812;
+export const UPLOAD_TIMEOUT = 30000; // 30 seconds
+export const MIN_UPLOAD_INTERVAL = 5000; // 5 seconds minimum between uploads
+export const DEFAULT_CACHE_TTLS = {
+  SIGNAL_STORE: 5 * 60, // 5 minutes
+  MSG_RETRY: 60 * 60, // 1 hour
+  CALL_OFFER: 5 * 60, // 5 minutes
+  USER_DEVICES: 5 * 60, // 5 minutes
+};
+export const TimeMs = {
+  Minute: 60 * 1000,
+  Hour: 60 * 60 * 1000,
+  Day: 24 * 60 * 60 * 1000,
+  Week: 7 * 24 * 60 * 60 * 1000,
+};

package/lib/Modded/message_builder.d.ts

@@ -0,0 +1,15 @@
+// Deklarasi minimal (upstream tidak menyertakan tipe untuk modul ini).
+export declare const VERSION: string;
+export declare class Toolkit {
+    [key: string]: any;
+}
+declare class BaseBuilder {
+    constructor(...args: any[]);
+    [key: string]: any;
+}
+export declare class Button extends BaseBuilder {}
+export declare class ButtonV2 extends BaseBuilder {}
+export declare class Carousel extends BaseBuilder {}
+export declare class AIRich extends BaseBuilder {}
+export declare class ORich extends AIRich {}
+export {};