@xbibzlibrary/whatsbibz 1.3.0

package/lib/BibzWhats/device-identity.d.ts

@@ -0,0 +1,60 @@
+import type { WABrowserDescription } from '../Types/index.js';
+
+export interface IdentityProfile { id: string; browser: WABrowserDescription; score: number; note: string }
+export declare const IDENTITY_PROFILES: readonly IdentityProfile[];
+export declare const IDENTITY_STATE_FILE: string;
+export declare function defaultVersionForOs(os: string | undefined): string;
+
+/** 'Mac OS/Chrome/15.6.1' | 'archLinux:Firefox' | 'linux-chrome' | tuple → tuple, atau null */
+export declare function parseBrowserSpec(spec: string | readonly string[] | null | undefined): WABrowserDescription | null;
+/** BIBZ_BROWSER / BIBZ_IDENTITY / BIBZ_DEVICE_OS / BIBZ_DEVICE_BROWSER / BIBZ_DEVICE_VERSION */
+export declare function identityFromEnv(env?: NodeJS.ProcessEnv): WABrowserDescription | 'auto' | null;
+
+export interface ResolvedIdentity {
+    mode: 'custom' | 'auto';
+    browser: WABrowserDescription;
+    source: string;
+    profileId?: string;
+    candidates: Array<{ id: string; browser: WABrowserDescription }>;
+    notes: Array<{ level: 'warn' | 'info'; message: string }>;
+}
+export declare function resolveDeviceIdentity(opts?: {
+    identity?: 'auto' | string | readonly string[] | null;
+    browser?: readonly string[] | null;
+    authDir?: string;
+    env?: NodeJS.ProcessEnv;
+    prefer?: string;
+}): ResolvedIdentity;
+
+export declare function identityStatePath(authDir: string): string;
+export declare function loadIdentityState(authDir: string): { browser: WABrowserDescription; profileId?: string; mode?: string; reason?: string; at?: string } | null;
+export declare function saveIdentityState(authDir: string, state: { browser: readonly string[]; profileId?: string; mode?: string; reason?: string }): boolean;
+export declare function clearIdentityState(authDir: string): void;
+
+export declare function isIdentityRejection(info?: { status?: number; sawQr?: boolean; phase?: 'connect' | 'pairing'; errorData?: unknown }): boolean;
+
+export interface IdentityRotator {
+    readonly current: { id: string; browser: WABrowserDescription };
+    readonly index: number;
+    readonly tried: Array<{ id: string; reason: string }>;
+    readonly exhausted: boolean;
+    markStable(reason?: string): void;
+    next(reason: string): boolean;
+}
+export declare function createIdentityRotator(opts: {
+    candidates: Array<{ id: string; browser: WABrowserDescription }>;
+    authDir?: string;
+    mode: 'custom' | 'auto';
+    logger?: { warn?: (msg: string) => void };
+    onChange?: (candidate: { id: string; browser: WABrowserDescription }, reason: string) => void;
+}): IdentityRotator;
+
+export interface IdentityDescription {
+    browser: WABrowserDescription;
+    /** teks yang muncul di daftar Perangkat tertaut, mis. "Chrome (Arch Linux)" */
+    linkedDeviceName: string;
+    /** companion_platform_display yang dipakai saat pairing kode */
+    pairingDisplay: string;
+    pairingDisplayAccepted: boolean;
+}
+export declare function describeIdentity(browser: readonly string[], opts?: { companionPlatformDisplay?: string | null }): IdentityDescription;

package/lib/BibzWhats/device-identity.js

@@ -0,0 +1,234 @@
+// BibzWhats — identitas perangkat tertaut: KUSTOM atau OTOMATIS (paling stabil).
+//
+// Prinsip:
+//  • Kalau pemakai MENENTUKAN identitas (opsi `browser`/`identity`, atau env
+//    BIBZ_BROWSER / BIBZ_DEVICE_OS / BIBZ_DEVICE_BROWSER / BIBZ_DEVICE_VERSION),
+//    itu yang dipakai — apa adanya, tanpa "dibetulkan" diam-diam. Library hanya
+//    memberi peringatan bila kombinasi itu diketahui bermasalah.
+//  • Kalau TIDAK ditentukan (`identity: 'auto'`), library memilih profil dengan
+//    skor stabilitas tertinggi dari tabel di bawah (hasil pengukuran ke server
+//    WA 2026-09-03), dan bila server menolaknya di tengah jalan (428 sebelum QR,
+//    400 saat pairing kode, 405 versi/klien ditolak), otomatis berpindah ke
+//    profil stabil berikutnya. Profil yang berhasil dipakai disimpan di
+//    <authDir>/identity.json agar konsisten antar restart — identitas harus
+//    tetap sama selama sesi hidup, kalau tidak WhatsApp menampilkan perangkat
+//    dengan nama berbeda dan bisa memutus sesi.
+
+import fs from 'fs';
+import path from 'path';
+import { Browsers } from '../Utils/browser-utils.js';
+import { derivePairingDisplay, isPairingDisplayAccepted, resolvePairingOs, hostOsLabel, hostOsVersion } from '../Utils/platform-identity.js';
+
+/**
+ * Profil identitas, diurutkan dari yang PALING stabil.
+ * skor = gabungan: QR/handshake OK, pairing kode diterima tanpa penyesuaian
+ * display, tanpa webSubPlatform khusus, umum dipakai klien nyata (kecil
+ * kemungkinan dianggap anomali).
+ */
+export const IDENTITY_PROFILES = Object.freeze([
+    { id: 'macos-chrome',   browser: Browsers.macOS('Chrome'),      score: 100, note: 'default; display "Chrome (Mac OS)" diterima apa adanya' },
+    { id: 'macos-safari',   browser: Browsers.macOS('Safari'),      score: 95,  note: 'display "Safari (Mac OS)" diterima' },
+    { id: 'windows-chrome', browser: Browsers.windows('Chrome'),    score: 92,  note: 'display "Chrome (Windows)" diterima' },
+    { id: 'linux-chrome',   browser: Browsers.linux('Chrome'),      score: 90,  note: 'display "Chrome (Linux)" diterima' },
+    { id: 'ubuntu-chrome',  browser: Browsers.ubuntu('Chrome'),     score: 88,  note: 'display "Chrome (Ubuntu)" diterima' },
+    { id: 'macos-firefox',  browser: Browsers.macOS('Firefox'),     score: 85,  note: 'display "Firefox (Mac OS)" diterima' },
+    { id: 'windows-edge',   browser: Browsers.windows('Edge'),      score: 84,  note: 'display "Edge (Windows)" diterima' },
+    { id: 'archlinux-chrome', browser: Browsers.archLinux('Chrome'), score: 80, note: 'nama "Arch Linux" di HP; display diturunkan ke "Chrome (Linux)"' },
+    { id: 'macos-desktop',  browser: Browsers.macOS('Desktop'),     score: 60,  note: 'riwayat penuh; webSubPlatform WEB_BROWSER (DARWIN ditutup server)' },
+    { id: 'windows-desktop', browser: Browsers.windows('Desktop'),  score: 58,  note: 'riwayat penuh; WIN_HYBRID' },
+]);
+
+export const IDENTITY_STATE_FILE = 'identity.json';
+
+const isTuple = (b) => Array.isArray(b) && b.length >= 2 && b.slice(0, 2).every((x) => typeof x === 'string' && x.trim());
+
+/** versi default yang wajar bila pemakai tidak mengisi browser[2] */
+export function defaultVersionForOs(os) {
+    const l = String(os || '').toLowerCase();
+    const preset = Object.values(Browsers).map((fn) => { try { return fn('Chrome'); } catch { return null; } })
+        .find((t) => t && t[0].toLowerCase() === l && t[2]);
+    if (preset) return preset[2];
+    if (/mac|darwin/.test(l)) return '15.6.1';
+    if (/windows/.test(l)) return '10.0.22631';
+    if (/linux|ubuntu|debian|arch|fedora/.test(l)) return '6.12.44';
+    return '1.0.0';
+}
+const withVersion = (t) => [t[0], t[1], t[2] && String(t[2]).trim() ? String(t[2]).trim() : defaultVersionForOs(t[0])];
+
+/** 'Mac OS/Chrome/15.6.1' | 'archLinux:Firefox' | 'Arch Linux, Chrome' | 'macos-safari' → tuple */
+export function parseBrowserSpec(spec) {
+    if (isTuple(spec)) return withVersion([spec[0], spec[1], spec[2]]);
+    if (typeof spec !== 'string' || !spec.trim()) return null;
+    const s = spec.trim();
+    const profile = IDENTITY_PROFILES.find((p) => p.id === s.toLowerCase());
+    if (profile) return [...profile.browser];
+    // preset:Browser  (macOS:Chrome, archLinux:Firefox, windows:Edge, appropriate:Chrome)
+    const m = /^([A-Za-z]+)\s*[:]\s*([A-Za-z][\w ]*)$/.exec(s);
+    if (m) {
+        const key = Object.keys(Browsers).find((k) => k.toLowerCase() === m[1].toLowerCase());
+        if (key) return withVersion([...Browsers[key](m[2].trim())]);
+    }
+    const parts = s.split(/\s*[\/|,]\s*/);
+    if (parts.length >= 2) return withVersion([parts[0], parts[1], parts[2]]);
+    return null;
+}
+
+/** Baca identitas dari environment (semua opsional). BIBZ_BROWSER menang atas trio OS/BROWSER/VERSION. */
+export function identityFromEnv(env = process.env) {
+    const raw = env.BIBZ_BROWSER || env.BIBZ_IDENTITY;
+    if (raw) {
+        if (/^auto$/i.test(raw.trim())) return 'auto';
+        const t = parseBrowserSpec(raw);
+        if (t) return t;
+    }
+    if (env.BIBZ_DEVICE_OS || env.BIBZ_DEVICE_BROWSER) {
+        const os = env.BIBZ_DEVICE_OS || hostOsLabel();
+        const browser = env.BIBZ_DEVICE_BROWSER || 'Chrome';
+        const version = env.BIBZ_DEVICE_VERSION || (env.BIBZ_DEVICE_OS ? '' : hostOsVersion());
+        return withVersion([os, browser, version]);
+    }
+    return null;
+}
+
+/**
+ * Tentukan identitas efektif.
+ * Prioritas: opsi `identity`/`browser` eksplisit → env → 'auto'.
+ * @returns {{ mode:'custom'|'auto', browser:[string,string,string], source:string, profileId?:string,
+ *             candidates:Array<{id:string,browser:[string,string,string]}>, notes:Array<{level:string,message:string}> }}
+ */
+export function resolveDeviceIdentity({ identity, browser, authDir, env = process.env, prefer } = {}) {
+    const notes = [];
+    const explicit = identity ?? browser;
+    // 1) eksplisit dari kode
+    if (explicit && explicit !== 'auto') {
+        const t = parseBrowserSpec(explicit);
+        if (t) {
+            notes.push(...customIdentityNotes(t));
+            return { mode: 'custom', browser: t, source: 'options', candidates: [{ id: 'custom', browser: t }], notes };
+        }
+        notes.push({ level: 'warn', message: `identitas '${String(explicit)}' tidak bisa dibaca — pakai mode otomatis` });
+    }
+    // 2) env
+    const fromEnv = identityFromEnv(env);
+    if (fromEnv && fromEnv !== 'auto') {
+        notes.push(...customIdentityNotes(fromEnv));
+        return { mode: 'custom', browser: fromEnv, source: 'env', candidates: [{ id: 'custom', browser: fromEnv }], notes };
+    }
+    // 3) otomatis: kandidat terurut; profil yang pernah sukses di sesi ini didahulukan
+    let candidates = [...IDENTITY_PROFILES]
+        .filter((p) => !/desktop$/.test(p.id)) // Desktop hanya bila diminta eksplisit (butuh syncFullHistory)
+        .sort((a, b) => b.score - a.score)
+        .map((p) => ({ id: p.id, browser: [...p.browser] }));
+    if (typeof prefer === 'string') {
+        const i = candidates.findIndex((c) => c.id === prefer);
+        if (i > 0) candidates = [candidates[i], ...candidates.slice(0, i), ...candidates.slice(i + 1)];
+    }
+    const saved = authDir ? loadIdentityState(authDir) : null;
+    if (saved?.browser && isTuple(saved.browser)) {
+        const i = candidates.findIndex((c) => c.id === saved.profileId);
+        if (i > 0) candidates = [candidates[i], ...candidates.slice(0, i), ...candidates.slice(i + 1)];
+        else if (i < 0) candidates = [{ id: saved.profileId || 'saved', browser: saved.browser }, ...candidates];
+        notes.push({ level: 'info', message: `identitas otomatis dilanjutkan dari sesi: ${saved.browser[1]} (${saved.browser[0]})` });
+    }
+    const first = candidates[0];
+    return { mode: 'auto', browser: first.browser, source: saved ? 'auto+saved' : 'auto', profileId: first.id, candidates, notes };
+}
+
+function customIdentityNotes(t) {
+    const notes = [];
+    if (!resolvePairingOs(t[0])) {
+        notes.push({ level: 'info', message: `OS '${t[0]}' tidak ada di allow-list pairing kode WhatsApp → display pairing otomatis '${derivePairingDisplay(t)}' (nama di daftar perangkat tetap '${t[0]}')` });
+    }
+    if (t[1] === 'Desktop') {
+        notes.push({ level: 'info', message: `identitas Desktop: riwayat penuh hanya diminta bila socketConfig.syncFullHistory=true; pairing kode memakai '${derivePairingDisplay(t)}'` });
+    }
+    return notes;
+}
+
+export function identityStatePath(authDir) {
+    return path.join(authDir, IDENTITY_STATE_FILE);
+}
+
+export function loadIdentityState(authDir) {
+    try {
+        const raw = fs.readFileSync(identityStatePath(authDir), 'utf8');
+        const j = JSON.parse(raw);
+        return j && isTuple(j.browser) ? j : null;
+    } catch {
+        return null;
+    }
+}
+
+export function saveIdentityState(authDir, { browser, profileId, mode, reason }) {
+    try {
+        fs.mkdirSync(authDir, { recursive: true });
+        fs.writeFileSync(identityStatePath(authDir), JSON.stringify({ browser, profileId, mode, reason, at: new Date().toISOString() }, null, 2));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function clearIdentityState(authDir) {
+    try { fs.rmSync(identityStatePath(authDir), { force: true }); } catch {}
+}
+
+/**
+ * Apakah kegagalan ini menandakan server MENOLAK IDENTITAS (bukan jaringan/nomor)?
+ * - 428 sebelum QR pernah muncul: handshake/ClientPayload ditolak (mis. webSubPlatform ditutup)
+ * - 400 bad-request pada pairing kode: companion_platform_display tidak dikenal
+ * - 405 (Method Not Allowed) pada connect: klien/versi ditolak
+ * 401/408/429/515 BUKAN alasan ganti identitas.
+ */
+export function isIdentityRejection({ status, sawQr = false, phase = 'connect', errorData } = {}) {
+    if (phase === 'pairing') return status === 400 || errorData === 400;
+    if (status === 405) return true;
+    if (status === 428 && !sawQr) return true;
+    return false;
+}
+
+/**
+ * Pengelola rotasi identitas untuk mode otomatis.
+ * next(reason) → kandidat berikutnya (atau null bila habis); current → kandidat aktif.
+ */
+export function createIdentityRotator({ candidates, authDir, mode, logger, onChange = () => {} }) {
+    let index = 0;
+    const tried = [];
+    const current = () => candidates[index];
+    const commit = (reason) => {
+        if (authDir) saveIdentityState(authDir, { browser: current().browser, profileId: current().id, mode, reason });
+    };
+    return {
+        get current() { return current(); },
+        get index() { return index; },
+        get tried() { return [...tried]; },
+        get exhausted() { return index >= candidates.length - 1; },
+        /** panggil saat identitas terbukti bekerja (QR diterima / pairing diakui / open) */
+        markStable(reason = 'ok') {
+            commit(reason);
+        },
+        /** ganti ke kandidat berikutnya; false bila mode custom atau kandidat habis */
+        next(reason) {
+            if (mode !== 'auto') return false;
+            if (index >= candidates.length - 1) return false;
+            tried.push({ id: current().id, reason });
+            index += 1;
+            const c = current();
+            logger?.warn?.(`BibzWhats: identitas '${tried[tried.length - 1].id}' ditolak server (${reason}) → mencoba '${c.id}' = ${c.browser[1]} (${c.browser[0]})`);
+            if (authDir) saveIdentityState(authDir, { browser: c.browser, profileId: c.id, mode, reason: `rotated: ${reason}` });
+            onChange(c, reason);
+            return true;
+        },
+    };
+}
+
+/** Ringkasan identitas untuk log/`client.identity` */
+export function describeIdentity(browser, { companionPlatformDisplay } = {}) {
+    const display = companionPlatformDisplay || derivePairingDisplay(browser);
+    return {
+        browser: [...browser],
+        linkedDeviceName: `${browser[1]} (${browser[0]})`,
+        pairingDisplay: display,
+        pairingDisplayAccepted: isPairingDisplayAccepted(display),
+    };
+}

package/lib/BibzWhats/extract.d.ts

@@ -0,0 +1,29 @@
+import type { WAMessage, proto } from '../index.js';
+export type ExtractedType = 'text' | 'image' | 'video' | 'audio' | 'sticker' | 'document' | 'reaction' | 'button' | 'poll' | 'other';
+export interface ExtractedMessage {
+    type: ExtractedType;
+    text: string;
+    participant: string;
+    mentions?: string[];
+    quoted?: string;
+    quotedParticipant?: string;
+    quotedStanzaId?: string;
+    quotedMessage?: proto.IMessage | null;
+    imageMsg?: proto.Message.IImageMessage;
+    videoMsg?: proto.Message.IVideoMessage;
+    audioMsg?: proto.Message.IAudioMessage;
+    stickerMsg?: proto.Message.IStickerMessage;
+    documentMsg?: proto.Message.IDocumentMessage;
+    reactionMsg?: proto.Message.IReactionMessage;
+    fileName?: string;
+    mimetype?: string;
+    fileLength?: number;
+    buttonId?: string;
+    buttonText?: string;
+    pollName?: string;
+    pollOptions?: string[];
+    otherKind?: string;
+}
+export declare function unwrapMessage(message: proto.IMessage | null | undefined): proto.IMessage | null;
+export declare function extractMessage(m: WAMessage): ExtractedMessage | null;
+export declare function messageTimestampMs(m: WAMessage): number;

package/lib/BibzWhats/extract.js

@@ -0,0 +1,115 @@
+// BibzWhats — ekstraksi isi pesan masuk (WAMessage → objek sederhana).
+// Unwrap otomatis: ephemeral, view-once (v1/v2/ext), document-with-caption, edited.
+
+function quotedText(quotedMessage) {
+    if (!quotedMessage) return '';
+    const q = quotedMessage;
+    if (typeof q.conversation === 'string') return q.conversation;
+    if (q.extendedTextMessage) return q.extendedTextMessage.text || '';
+    if (q.imageMessage) return q.imageMessage.caption || '[gambar]';
+    if (q.videoMessage) return q.videoMessage.caption || '[video]';
+    if (q.audioMessage) return '[voice note]';
+    if (q.documentMessage) return q.documentMessage.caption || '[dokumen]';
+    return '';
+}
+
+/** Buka lapisan pembungkus pesan sampai konten sebenarnya. */
+export function unwrapMessage(message) {
+    let msg = message;
+    if (msg?.editedMessage?.message) msg = msg.editedMessage.message;
+    else if (msg?.protocolMessage?.editedMessage?.message) msg = msg.protocolMessage.editedMessage.message;
+    for (let i = 0; i < 8 && msg; i++) {
+        const inner =
+            msg.ephemeralMessage?.message ||
+            msg.viewOnceMessage?.message ||
+            msg.viewOnceMessageV2?.message ||
+            msg.viewOnceMessageV2Extension?.message ||
+            msg.documentWithCaptionMessage?.message;
+        if (!inner) break;
+        msg = inner;
+    }
+    return msg || null;
+}
+
+const toNumber = (v) => (typeof v?.toNumber === 'function' ? v.toNumber() : Number(v || 0));
+
+/**
+ * @typedef {object} ExtractedMessage
+ * @property {'text'|'image'|'video'|'audio'|'sticker'|'document'|'reaction'|'button'|'poll'|'other'} type
+ * @property {string} text
+ * @property {string} participant
+ * @property {string[]} [mentions]
+ * @property {string} [quoted]
+ */
+
+/**
+ * @param {import('../Types/index.js').WAMessage} m
+ * @returns {ExtractedMessage|null}
+ */
+export function extractMessage(m) {
+    const msg = unwrapMessage(m?.message);
+    if (!msg) return null;
+    const participant = m?.key?.participant || m?.participant || '';
+    const contextOf = (ci) => ({
+        mentions: ci?.mentionedJid || ci?.mentionedJids || [],
+        quoted: ci?.quotedMessage ? quotedText(ci.quotedMessage) : '',
+        quotedParticipant: ci?.participant || '',
+        quotedStanzaId: ci?.stanzaId || '',
+        quotedMessage: ci?.quotedMessage || null,
+    });
+
+    if (msg.reactionMessage) return { type: 'reaction', reactionMsg: msg.reactionMessage, text: '', participant };
+    if (msg.buttonsResponseMessage) {
+        return { type: 'button', buttonId: msg.buttonsResponseMessage.selectedButtonId || '', buttonText: msg.buttonsResponseMessage.selectedDisplayText || '', text: '', participant };
+    }
+    if (msg.templateButtonReplyMessage) {
+        return { type: 'button', buttonId: msg.templateButtonReplyMessage.selectedId || '', buttonText: msg.templateButtonReplyMessage.selectedDisplayText || '', text: '', participant };
+    }
+    if (msg.listResponseMessage) {
+        return { type: 'button', buttonId: msg.listResponseMessage?.singleSelectReply?.selectedRowId || '', buttonText: '', text: '', participant };
+    }
+    if (msg.interactiveResponseMessage) {
+        let buttonId = '';
+        try {
+            const raw = msg.interactiveResponseMessage.nativeFlowResponseMessage?.paramsJson;
+            buttonId = raw ? JSON.parse(raw)?.id || '' : '';
+        } catch {}
+        return { type: 'button', buttonId, buttonText: msg.interactiveResponseMessage.body?.text || '', text: '', participant };
+    }
+    if (msg.pollUpdateMessage) {
+        return { type: 'poll', pollName: msg.pollUpdateMessage.name || '', pollOptions: (msg.pollUpdateMessage.selectedOptions || []).map((o) => o.optionName), text: '', participant };
+    }
+    if (typeof msg.conversation === 'string') return { type: 'text', text: msg.conversation, participant };
+    if (msg.extendedTextMessage) {
+        return { type: 'text', text: msg.extendedTextMessage.text || '', ...contextOf(msg.extendedTextMessage.contextInfo), participant };
+    }
+    if (msg.imageMessage) {
+        return { type: 'image', text: msg.imageMessage.caption || '', imageMsg: msg.imageMessage, ...contextOf(msg.imageMessage.contextInfo), participant };
+    }
+    if (msg.videoMessage) {
+        return { type: 'video', text: msg.videoMessage.caption || '', videoMsg: msg.videoMessage, ...contextOf(msg.videoMessage.contextInfo), participant };
+    }
+    if (msg.audioMessage) return { type: 'audio', audioMsg: msg.audioMessage, text: '', participant };
+    if (msg.stickerMessage) return { type: 'sticker', stickerMsg: msg.stickerMessage, text: '', participant };
+    if (msg.documentMessage) {
+        const d = msg.documentMessage;
+        return {
+            type: 'document', text: d.caption || '', documentMsg: d, fileName: d.fileName || '', mimetype: d.mimetype || '',
+            fileLength: toNumber(d.fileLength), ...contextOf(d.contextInfo), participant,
+        };
+    }
+    if (msg.buttonsMessage) return { type: 'text', text: msg.buttonsMessage.text || '', participant };
+    if (msg.listMessage) return { type: 'text', text: msg.listMessage.description || '', participant };
+    return { type: 'other', otherKind: Object.keys(msg)[0] || 'unknown', participant };
+}
+
+/** Timestamp pesan dalam ms (0 bila tidak ada). */
+export function messageTimestampMs(m) {
+    let value = m?.messageTimestamp ?? m?.key?.messageTimestamp;
+    if (value && typeof value === 'object') {
+        if (typeof value.toNumber === 'function') value = value.toNumber();
+        else if (Number.isFinite(value.low)) value = value.low + (Number(value.high) || 0) * 0x100000000;
+    }
+    const seconds = Number(value);
+    return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 0;
+}

package/lib/BibzWhats/index.d.ts

@@ -0,0 +1,7 @@
+export * from './pairing.js';
+export * from './client.js';
+export * from './device-identity.js';
+export * from './send.js';
+export * from './extract.js';
+export * from './jid.js';
+export { BIBZWHATS_VERSION, BIBZWHATS_NAME, BIBZWHATS_PACKAGE, BIBZWHATS_UPSTREAM, BIBZWHATS_WA_WEB_VERSION } from './version.js';

package/lib/BibzWhats/index.js

@@ -0,0 +1,8 @@
+// BibzWhats — lapisan API tingkat tinggi.
+export * from './pairing.js';
+export * from './client.js';
+export * from './device-identity.js';
+export * from './send.js';
+export * from './extract.js';
+export * from './jid.js';
+export { BIBZWHATS_VERSION, BIBZWHATS_NAME, BIBZWHATS_PACKAGE, BIBZWHATS_UPSTREAM, BIBZWHATS_WA_WEB_VERSION } from './version.js';

package/lib/BibzWhats/jid.d.ts

@@ -0,0 +1,22 @@
+export declare function digitsOf(jid: unknown): string;
+export declare const isGroupJid: (jid: unknown) => boolean;
+export declare const isLidJid: (jid: unknown) => boolean;
+export declare const isPnJid: (jid: unknown) => boolean;
+export declare const isNewsletterJid: (jid: unknown) => boolean;
+export declare const isStatusJid: (jid: unknown) => boolean;
+export declare function pnJid(digits: unknown): string;
+export declare function lidJid(digits: unknown): string;
+export declare function sameUser(a: unknown, b: unknown): boolean;
+export declare function normalizeJid(jid: unknown): string;
+export declare class LidMap {
+    lidToPn: Map<string, string>;
+    pnToLid: Map<string, string>;
+    set(lid: string, pn: string): void;
+    phoneOf(lid: string): string | null;
+    lidOf(pn: string): string | null;
+    canonical(jid: string): string;
+    variants(jid: string): string[];
+    learnFromMessage(m: { key?: { remoteJid?: string | null; remoteJidAlt?: string | null; participant?: string | null; participantAlt?: string | null } }): void;
+    toJSON(): Record<string, string>;
+    static fromJSON(obj?: Record<string, string>): LidMap;
+}

package/lib/BibzWhats/jid.js

@@ -0,0 +1,98 @@
+// BibzWhats — utilitas JID (PN / LID / grup) tanpa dependensi luar.
+
+const S_WHATSAPP_NET = '@s.whatsapp.net'; // (diekspor oleh WABinary)
+
+export function digitsOf(jid) {
+    return String(jid || '').split('@')[0].split(':')[0].replace(/\D/g, '');
+}
+export const isGroupJid = (jid) => String(jid || '').endsWith('@g.us');
+export const isLidJid = (jid) => String(jid || '').endsWith('@lid');
+export const isPnJid = (jid) => String(jid || '').endsWith(S_WHATSAPP_NET);
+export const isNewsletterJid = (jid) => String(jid || '').endsWith('@newsletter');
+export const isStatusJid = (jid) => String(jid || '') === 'status@broadcast';
+
+export function pnJid(digits) {
+    const value = digitsOf(digits);
+    return value ? `${value}${S_WHATSAPP_NET}` : '';
+}
+export function lidJid(digits) {
+    const value = digitsOf(digits);
+    return value ? `${value}@lid` : '';
+}
+export function sameUser(a, b) {
+    const left = digitsOf(a);
+    const right = digitsOf(b);
+    return !!left && !!right && left === right;
+}
+
+/** Buang suffix device (":12") dari JID user. */
+export function normalizeJid(jid) {
+    const raw = String(jid || '');
+    if (!raw || isGroupJid(raw)) return raw;
+    const domain = raw.includes('@') ? raw.slice(raw.indexOf('@')) : '';
+    const digits = digitsOf(raw);
+    return digits ? `${digits}${domain}` : raw;
+}
+
+/**
+ * Peta LID ↔ nomor telepon sederhana (in-memory). Isi dari
+ * key.remoteJidAlt / participantAlt dan event contacts.upsert.
+ */
+export class LidMap {
+    constructor() {
+        this.lidToPn = new Map();
+        this.pnToLid = new Map();
+    }
+    set(lid, pn) {
+        if (!lid || !pn) return;
+        if (isPnJid(String(lid)) && isLidJid(String(pn))) [lid, pn] = [pn, lid];
+        const l = digitsOf(lid);
+        const p = digitsOf(pn);
+        if (!l || !p || l === p) return;
+        this.lidToPn.set(l, p);
+        this.pnToLid.set(p, l);
+    }
+    phoneOf(lid) {
+        return this.lidToPn.get(digitsOf(lid)) || null;
+    }
+    lidOf(pn) {
+        return this.pnToLid.get(digitsOf(pn)) || null;
+    }
+    /** JID kanonik: LID → PN bila mapping diketahui. */
+    canonical(jid) {
+        const normalized = normalizeJid(jid);
+        if (!normalized || isGroupJid(normalized)) return normalized;
+        if (isLidJid(normalized)) {
+            const mapped = this.phoneOf(normalized);
+            if (mapped) return pnJid(mapped);
+        }
+        return normalized;
+    }
+    /** Semua bentuk JID yang merujuk user yang sama. */
+    variants(jid) {
+        const normalized = normalizeJid(jid);
+        if (!normalized || isGroupJid(normalized)) return normalized ? [normalized] : [];
+        const out = new Set([normalized]);
+        if (isLidJid(normalized)) {
+            const pn = this.phoneOf(normalized);
+            if (pn) out.add(pnJid(pn));
+        } else {
+            const lid = this.lidOf(normalized);
+            if (lid) out.add(lidJid(lid));
+        }
+        return [...out];
+    }
+    /** Serap mapping dari pesan masuk (remoteJidAlt/participantAlt). */
+    learnFromMessage(m) {
+        if (m?.key?.remoteJid && m.key.remoteJidAlt) this.set(m.key.remoteJid, m.key.remoteJidAlt);
+        if (m?.key?.participant && m.key.participantAlt) this.set(m.key.participant, m.key.participantAlt);
+    }
+    toJSON() {
+        return Object.fromEntries(this.lidToPn);
+    }
+    static fromJSON(obj = {}) {
+        const map = new LidMap();
+        for (const [lid, pn] of Object.entries(obj || {})) map.set(lid, pn);
+        return map;
+    }
+}

package/lib/BibzWhats/pairing.d.ts

@@ -0,0 +1,35 @@
+export declare const PAIRING_REFRESH_MS: number;
+export declare const PAIRING_BACKOFF_MAX_MS: number;
+export declare function normalizePairingCode(value: unknown): string;
+/** kode error server (error.data dari stanza <error code=...>) atau statusCode Boom non-500 */
+export declare function pairingErrorCode(error: unknown): number | undefined;
+export declare function isRateLimitError(error: unknown): boolean;
+export declare function isRegistrationRejected(error: unknown): boolean;
+export declare function isTimeoutError(error: unknown): boolean;
+export declare function isCustomPairingError(error: unknown): boolean;
+export interface PairingCodeMeta {
+    custom: boolean;
+    fallback: boolean;
+}
+export interface PairingController {
+    start(): Promise<string | null>;
+    trigger(): Promise<string | null>;
+    stop(): void;
+    isInFlight(): boolean;
+    isStopped(): boolean;
+    getState(): { fallbackUsed: boolean; timerActive: boolean; rateLimitDelay: number };
+}
+export interface PairingControllerOptions {
+    sock: { requestPairingCode(phone: string, code?: string): Promise<string>; authState?: { creds?: { registered?: boolean } } };
+    phone: string;
+    pairingCode?: string;
+    onCode?: (code: string, meta: PairingCodeMeta) => void;
+    logger?: { warn?: (...a: any[]) => void; error?: (...a: any[]) => void; info?: (...a: any[]) => void };
+    refreshMs?: number;
+    backoffMaxMs?: number;
+    setTimeoutFn?: typeof setTimeout;
+    clearTimeoutFn?: typeof clearTimeout;
+    /** 400 bad-request dsb.: kembalikan true bila diambil alih (controller berhenti) */
+    onRejected?: (error: unknown, info: { code: number; phone?: string }) => boolean;
+}
+export declare function createPairingController(options: PairingControllerOptions): PairingController;