@blckrose/baileys 1.1.5 → 1.2.8

package/README.md

@@ -54,21 +54,36 @@ To run the example script, download or clone the repo and then type the followin
 
 ## Install
 
-Use the stable version:
+Install dari file `.tgz` lokal (versi modified blckrose):
 ```
-yarn add @blckrose/baileys
+npm install ./blckrose-baileys-1.1.5-apoc.tgz
 ```
 
-Use the edge version (no guarantee of stability, but latest fixes + features)
+Atau tambahkan ke `package.json`:
+```json
+{
+  "dependencies": {
+    "@blckrose/baileys": "file:./blckrose-baileys-1.1.5-apoc.tgz"
+  }
+}
+```
+
+Kemudian jalankan:
 ```
-yarn add github:WhiskeySockets/Baileys
+npm install
 ```
 
-Then import your code using:
+**ESM:**
 ```ts
 import makeWASocket from '@blckrose/baileys'
 ```
 
+**CJS (destructure langsung, tanpa top-level await):**
+```js
+const { makeWASocket, useMultiFileAuthState, Browsers, DisconnectReason } = require('@blckrose/baileys')
+// global apocalypse otomatis tersedia setelah baris di atas
+```
+
 # Links
 
 - [Discord](https://discord.gg/WeJM5FP9GG)
@@ -93,6 +108,15 @@ import makeWASocket from '@blckrose/baileys'
 - [Implementing a Data Store](#implementing-a-data-store)
 - [Whatsapp IDs Explain](#whatsapp-ids-explain)
 - [Utility Functions](#utility-functions)
+- [Apocalypse API](#apocalypse-api)
+    - [Cara Pakai Tanpa API Key](#cara-pakai-tanpa-api-key)
+    - [Cara Pakai Dengan API Key](#cara-pakai-dengan-api-key)
+    - [Contoh Penggunaan](#contoh-penggunaan-apocalypse)
+- [Newsletter / Channel](#newsletter--channel)
+    - [Kirim Media ke Channel](#kirim-media-ke-channel)
+    - [Button di Channel](#button-di-channel)
+    - [Edit & Hapus Pesan Channel](#edit--hapus-pesan-channel)
+- [Resolve JID (LID → Phone)](#resolve-jid)
 - [Sending Messages](#sending-messages)
     - [Non-Media Messages](#non-media-messages)
         - [Text Message](#text-message)
@@ -532,13 +556,391 @@ const resized = await sock.resize('https://example.com/image.jpg', 320, 320)
 const resized = await sock.resize(buffer, 320, 320)
 ```
 
-
 - `getContentType`, returns the content type for any message
 - `getDevice`, returns the device from message
 - `makeCacheableSignalKeyStore`, make auth store more fast
 - `downloadContentFromMessage`, download content from any message
+- `makeNewsletterUtils`, helper lengkap untuk kirim ke newsletter/channel
+- `resolveJid`, resolve LID / participant ID ke JID @s.whatsapp.net
+- `resolveJids`, resolve banyak JID sekaligus
+
+---
+
+## Apocalypse API
+
+> **Base URL:** `https://api.apocalypse.web.id`
+> **Docs:** `https://api.apocalypse.web.id/docs`
+
+`apocalypse` adalah global HTTP client yang otomatis tersedia setelah `require('@blckrose/baileys')`. Tidak perlu import apapun lagi.
+
+### Cara Pakai Tanpa API Key
+
+```js
+// Cukup require baileys seperti biasa, apocalypse langsung ada
+const { makeWASocket, useMultiFileAuthState } = require('@blckrose/baileys')
+
+// Di handler / file manapun — langsung pakai:
+const res = await apocalypse.get('/search/spotify?q=swim')
+console.log(res.result)
+
+// Atau gunakan params object (auto-encode):
+const res = await apocalypse.get('/search/spotify', { q: 'swim' })
+
+// Sub-path dengan params:
+const res = await apocalypse.get('/manga/jagoanmanga/search', { q: 'killer+peter' })
+
+// POST:
+const res = await apocalypse.post('/ai/chatgpt', { text: 'halo' })
+```
+
+### Cara Pakai Dengan API Key
+
+`createApocalypse` tersedia **global** tanpa import, otomatis setelah `require('@blckrose/baileys')`.
+
+**Cara 1 — API key langsung di kode:**
+```js
+const api = createApocalypse({ apiKey: 'NEMOPHILA' })
+await api.get('/search/spotify', { q: 'swim' })
+```
+
+**Cara 2 — API key dari `config.js` / `setting.js`:**
+```js
+// config.js / setting.js
+global.apikey = 'NEMOPHILA'
+
+// handler / file manapun — tidak perlu import apapun
+const api = createApocalypse({ apiKey: global.apikey })
+await api.get('/search/spotify', { q: 'swim' })
+```
+
+**Cara 3 — Set ke global `apocalypse` instance (berlaku semua request):**
+```js
+// bot.js — set sekali
+apocalypse.setKey(global.apikey)
+
+// handler manapun — langsung pakai, key terbawa otomatis
+await apocalypse.get('/premium/endpoint', { q: 'test' })
+```
+
+**Config lengkap yang tersedia:**
+```js
+const api = createApocalypse({
+    apiKey: 'NEMOPHILA',     // API key → dikirim sebagai header x-api-key
+    timeout: 15000,          // timeout ms (default: 30000)
+    baseUrl: 'https://...',  // override base URL (opsional)
+    headers: {               // header tambahan (opsional)
+        'x-custom': 'value'
+    }
+})
+```
+
+> [!NOTE]
+> `createApocalypse` dan `apocalypse` keduanya tersedia global — tidak perlu tulis `import` atau `require` apapun selain `require('@blckrose/baileys')` yang sudah ada di bot.js.
+
+### Contoh Penggunaan Apocalypse
+
+#### Respon Object
+
+Setiap response memiliki struktur yang sama:
+
+| Property | Tipe | Keterangan |
+|---|---|---|
+| `.result` | `any` | Data utama (`data.result` / `data.data` / root) |
+| `.status` | `boolean` | `true` jika API sukses |
+| `.message` | `string` | Pesan dari API |
+| `.raw` | `object` | Full JSON response mentah |
+| `.url` | `string` | URL yang dipanggil |
+| `.get(key)` | `any` | Ambil field tertentu dari result |
+
+#### Search Spotify
+
+```js
+const res = await apocalypse.get('/search/spotify', { q: 'swim' })
+// atau
+const res = await apocalypse.get('/search/spotify?q=swim')
+
+console.log(res.result)  // data hasil pencarian
+console.log(res.status)  // true / false
+```
+
+#### Search YouTube
+
+```js
+const res = await apocalypse.get('/search/youtube', { q: 'lagu baru' })
+console.log(res.result)
+```
+
+#### Search dengan URL
+
+```js
+const res = await apocalypse.get('/search/tiktok', { url: 'https://vm.tiktok.com/xxx' })
+console.log(res.result)
+```
+
+#### Manga Search
+
+```js
+// Sub-path: /manga/{sumber}/search
+const res = await apocalypse.get('/manga/jagoanmanga/search', { q: 'killer+peter' })
+console.log(res.result)
+```
+
+#### AI / Chatbot
+
+```js
+const res = await apocalypse.post('/ai/chatgpt', { text: 'halo, siapa kamu?' })
+console.log(res.result)
+```
+
+#### Category Helper (shortcut)
+
+```js
+// Buat caller untuk satu kategori
+const search = apocalypse.category('search')
+await search.get('spotify', { q: 'swim' })
+await search.get('youtube', { q: 'lagu' })
+await search.get('tiktok', { q: 'viral' })
+
+// Sub-path
+const manga = apocalypse.category('manga/jagoanmanga')
+await manga.get('search', { q: 'naruto' })
+await manga.get('chapter', { id: '123' })
+```
+
+#### Pakai di Handler Bot
+
+```js
+// handler/search.js
+let handler = async (m, { conn }) => {
+    const query = m.text.slice(8).trim() // contoh: !search <query>
+    if (!query) return conn.sendMessage(m.chat, { text: 'Masukkan kata kunci!' }, { quoted: m })
+
+    try {
+        const res = await apocalypse.get('/search/spotify', { q: query })
+        if (!res.status) return conn.sendMessage(m.chat, { text: 'Tidak ditemukan.' }, { quoted: m })
+
+        const data = res.result
+        await conn.sendMessage(m.chat, {
+            text: `🎵 *${data.title}*\n👤 ${data.artist}\n🔗 ${data.url}`
+        }, { quoted: m })
+    } catch (e) {
+        await conn.sendMessage(m.chat, { text: `Error: ${e.message}` }, { quoted: m })
+    }
+}
+
+handler.command = /^search$/i
+module.exports = handler
+```
+
+#### Pakai Dengan API Key
+
+```js
+// Cara 1 — langsung di kode
+const api = createApocalypse({ apiKey: 'NEMOPHILA' })
+await api.get('/search/spotify', { q: 'swim' })
+
+// Cara 2 — dari config/setting global
+const api = createApocalypse({ apiKey: global.apikey })
+await api.get('/search/spotify', { q: 'swim' })
+
+// Cara 3 — set ke global instance (berlaku semua request berikutnya)
+apocalypse.setKey(global.apikey)
+await apocalypse.get('/premium/endpoint', { q: 'test' })
+```
+
+---
+
+## Newsletter / Channel
+
+> [!NOTE]
+> Newsletter menggunakan format JID `@newsletter`, contoh: `120363xxxxxxxxx@newsletter`
+
+### Kirim Media ke Channel
+
+Gunakan helper `makeNewsletterUtils(conn)` yang menggabungkan semua fungsi kirim ke channel:
+
+```js
+const { makeNewsletterUtils } = require('@blckrose/baileys')
+const nl = makeNewsletterUtils(conn)
+
+const JID = '120363xxxxxxxxx@newsletter'
+
+// Teks
+await nl.sendNewsletterText(JID, 'Halo dari bot!')
+
+// Gambar
+await nl.sendNewsletterImage(JID, { url: 'https://example.com/img.jpg' }, { caption: 'Gambar keren' })
+
+// Video
+await nl.sendNewsletterVideo(JID, { url: 'https://example.com/vid.mp4' }, { caption: 'Video nih' })
+
+// PTV (video note / lingkaran)
+await nl.sendNewsletterPtv(JID, { url: 'https://example.com/vid.mp4' })
+
+// Audio
+await nl.sendNewsletterAudio(JID, { url: 'https://example.com/audio.mp3' })
+
+// Dokumen
+await nl.sendNewsletterDocument(JID, { url: 'https://example.com/file.pdf' }, {
+    mimetype: 'application/pdf',
+    fileName: 'dokumen.pdf'
+})
+
+// Sticker
+await nl.sendNewsletterSticker(JID, fs.readFileSync('./sticker.webp'))
+```
+
+Atau langsung pakai `conn.sendMessage` seperti biasa — semua tipe media sudah support:
+```js
+await conn.sendMessage(JID, { image: { url: 'https://...' }, caption: 'test' })
+await conn.sendMessage(JID, { video: { url: 'https://...' }, ptv: true })
+```
+
+### Button di Channel
+
+> [!IMPORTANT]
+> Fitur ini **hanya ada di blckrose-baileys 1.1.5-apoc**. Fork lain tidak support button di newsletter.
+
+```js
+const nl = makeNewsletterUtils(conn)
+const JID = '120363xxxxxxxxx@newsletter'
+
+// Quick Reply Buttons
+await nl.sendNewsletterButtons(JID, {
+    body: 'Pilih salah satu:',
+    buttons: [
+        { id: 'btn_yes', text: '✅ Setuju' },
+        { id: 'btn_no',  text: '❌ Tidak' },
+        { id: 'btn_skip', text: '⏭ Skip' }
+    ],
+    footer: 'Powered by bot'
+})
+
+// Single Select List
+await nl.sendNewsletterList(JID, {
+    body: 'Pilih menu yang kamu mau:',
+    buttonText: 'Buka Menu',
+    sections: [
+        {
+            title: 'Fitur Utama',
+            rows: [
+                { id: 'info',  title: 'Info Bot',   description: 'Lihat info bot' },
+                { id: 'help',  title: 'Bantuan',    description: 'Cara pakai bot' },
+                { id: 'stats', title: 'Statistik',  description: 'Lihat statistik' }
+            ]
+        },
+        {
+            title: 'Lainnya',
+            rows: [
+                { id: 'about', title: 'Tentang',    description: 'Info developer' }
+            ]
+        }
+    ],
+    title: 'Menu Bot',
+    footer: 'Versi 1.0'
+})
+
+// CTA URL Button
+await nl.sendNewsletterCtaUrl(JID, {
+    body: 'Kunjungi website kami untuk info lebih lanjut!',
+    buttonText: '🌐 Buka Website',
+    url: 'https://example.com',
+    title: 'Info Lengkap',
+    footer: 'Klik tombol di bawah'
+})
+```
+
+Atau langsung via `conn.sendMessage` dengan `interactiveMessage`:
+```js
+await conn.sendMessage(JID, {
+    interactiveMessage: {
+        nativeFlowMessage: {
+            buttons: [
+                {
+                    name: 'quick_reply',
+                    buttonParamsJson: JSON.stringify({ display_text: '✅ Ya', id: 'yes' })
+                },
+                {
+                    name: 'cta_url',
+                    buttonParamsJson: JSON.stringify({ display_text: 'Buka Link', url: 'https://example.com', merchant_url: 'https://example.com' })
+                }
+            ],
+            messageParamsJson: '',
+            messageVersion: 1
+        },
+        body: { text: 'Pilih aksi:' },
+        footer: { text: 'Footer text' }
+    }
+})
+```
+
+### Edit & Hapus Pesan Channel
+
+```js
+const nl = makeNewsletterUtils(conn)
+const JID = '120363xxxxxxxxx@newsletter'
+
+// Edit pesan (gunakan key.id dari pesan yang dikirim)
+const sent = await nl.sendNewsletterText(JID, 'Teks lama')
+await nl.editNewsletterMessage(JID, sent.key.id, 'Teks baru yang sudah diedit')
+
+// Hapus pesan
+await nl.deleteNewsletterMessage(JID, sent.key.id)
+
+// React ke pesan channel (gunakan server message ID dari event)
+await nl.sendNewsletterReact(JID, serverMessageId, '👍')
+// Unreact (kosongkan emoji)
+await nl.sendNewsletterReact(JID, serverMessageId, '')
+```
+
+Atau langsung via `conn.sendMessage`:
+```js
+// Edit
+await conn.sendMessage(JID, { text: 'Teks baru', edit: { remoteJid: JID, fromMe: true, id: messageId } })
+
+// Hapus
+await conn.sendMessage(JID, { delete: { remoteJid: JID, fromMe: true, id: messageId } })
+```
+
+---
+
+## Resolve JID
+
+Berguna untuk mengubah `@lid` format (format baru WA) menjadi JID `@s.whatsapp.net` yang bisa dipakai mengirim pesan.
+
+```js
+const { resolveJid, resolveJids } = require('@blckrose/baileys')
+
+// Resolve dari sender pesan (otomatis ambil dari m.sender / m.quoted / m.mentionedJid)
+const jid = await resolveJid(conn, m)
+if (!jid) return conn.sendMessage(m.chat, { text: 'Tidak bisa resolve JID.' }, { quoted: m })
+
+console.log(jid) // → '628xxxxxxxxxx@s.whatsapp.net'
+
+// Resolve target eksplisit (misal dari mention)
+const jid = await resolveJid(conn, m, m.mentionedJid?.[0])
+
+// Resolve banyak JID sekaligus
+const jids = await resolveJids(conn, m, m.mentionedJid)
+// → ['628xxx@s.whatsapp.net', '628yyy@s.whatsapp.net', null, ...]
+
+// Contoh pakai di handler
+let handler = async (m, { conn }) => {
+    const target = await resolveJid(conn, m, m.mentionedJid?.[0] || m.quoted?.sender)
+    if (!target) return conn.sendMessage(m.chat, { text: 'Tag atau reply seseorang.' }, { quoted: m })
+
+    await conn.sendMessage(m.chat, {
+        text: `JID target: ${target}`
+    }, { quoted: m })
+}
+```
+
+> [!NOTE]
+> `resolveJid` otomatis melakukan lookup ke `groupMetadata` jika JID berbentuk `@lid` di dalam grup. Butuh akses ke `conn` yang terkoneksi.
+
+---
+
 
-## Sending Messages
 
 - Send all types of messages with a single function
     - **[Here](https://baileys.whiskeysockets.io/types/AnyMessageContent.html) you can see all message contents supported, like text message**

package/index.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+/**
+ * @blckrose/baileys — CJS wrapper
+ *
+ * Destructure dan langsung pakai tanpa await ready:
+ *
+ *   const { makeWASocket, useMultiFileAuthState, Browsers } = require('@blckrose/baileys');
+ *
+ *   async function start() {
+ *     const { state, saveCreds } = await useMultiFileAuthState('./auth');
+ *     const conn = makeWASocket({ auth: state });
+ *   }
+ *   start();
+ *
+ * Cara kerja:
+ *   - ESM di-load di background saat require() dipanggil
+ *   - Semua fungsi auto-await load selesai sebelum dieksekusi
+ *   - Semua nilai non-fungsi (konstanta, enum) tersedia via getter setelah load
+ *   - Tidak perlu await ready, tidak perlu top-level await
+ */
+
+let _mod = null;
+let _loadPromise = null;
+let _loadError = null;
+
+function _load() {
+  if (_loadPromise) return _loadPromise;
+  _loadPromise = import('./lib/index.js').then(mod => {
+    _mod = mod;
+    // Populate semua exports setelah load
+    for (const key of Object.keys(mod)) {
+      if (key === 'default') continue;
+      const val = mod[key];
+      // Fungsi: sudah di-wrap jadi async-safe di bawah, skip overwrite
+      if (typeof val === 'function') continue;
+      // Nilai statis (konstanta, enum, object): langsung assign
+      Object.defineProperty(module.exports, key, {
+        value: val,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+    Object.defineProperty(module.exports, 'default', {
+      value: mod.default,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
+    module.exports.ready = Promise.resolve(mod);
+    return mod;
+  }).catch(err => {
+    _loadError = err;
+    throw err;
+  });
+  return _loadPromise;
+}
+
+// Kick off immediately on require()
+_load();
+
+module.exports.ready = _loadPromise;
+module.exports.load = _load;
+
+// ── Async-safe function wrapper ───────────────────────────────────────────────
+// Semua fungsi di-wrap: otomatis tunggu ESM load selesai lalu eksekusi.
+// Hasilnya: bisa dipanggil langsung tanpa await ready.
+
+function _wrapFn(name) {
+  return async function(...args) {
+    if (_loadError) throw new Error('[blckrose-baileys] Load failed: ' + _loadError.message);
+    if (!_mod) await _load();
+    const fn = name === 'makeWASocket' ? _mod.default : _mod[name];
+    if (typeof fn !== 'function') throw new Error('[blckrose-baileys] "' + name + '" bukan fungsi');
+    return fn(...args);
+  };
+}
+
+// makeWASocket khusus: return value-nya sync (WASocket object), bukan Promise
+// Jadi kita wrap tapi return langsung hasil pemanggilan fn
+function _wrapMakeWASocket() {
+  return function makeWASocket(...args) {
+    if (_mod) return _mod.default(...args);
+    // Kalau belum load, throw — karena makeWASocket tidak async
+    if (_loadError) throw new Error('[blckrose-baileys] Load failed: ' + _loadError.message);
+    throw new Error(
+      '[blckrose-baileys] makeWASocket dipanggil sebelum Baileys selesai load.\n' +
+      'Pastikan await useMultiFileAuthState() dulu (itu sudah cukup untuk menunggu load).'
+    );
+  };
+}
+
+// ── Lazy getter untuk nilai non-fungsi ────────────────────────────────────────
+function _makeLazyGetter(name) {
+  return function() {
+    if (_loadError) throw new Error('[blckrose-baileys] Load failed: ' + _loadError.message);
+    if (_mod) return _mod[name];
+    throw new Error(
+      '[blckrose-baileys] "' + name + '" belum siap. ' +
+      'Gunakan await useMultiFileAuthState() sebelum akses konstanta ini.'
+    );
+  };
+}
+
+// ── Daftar semua exports ──────────────────────────────────────────────────────
+
+const _functions = [
+  'addTransactionCapability','aesDecrypt','aesDecryptCTR','aesDecryptGCM',
+  'aesDecryptWithIV','aesEncrypWithIV','aesEncrypt','aesEncryptCTR','aesEncryptGCM',
+  'aggregateMessageKeysNotFromMe','areJidsSameUser','assertMediaContent',
+  'assertNodeErrorFree','bindWaitForConnectionUpdate','bindWaitForEvent',
+  'bytesToCrockford','chatModificationToAppPatch','debouncedTimeout',
+  'decodeMediaRetryNode','decodePatches','decodeSyncdMutations','decodeSyncdPatch',
+  'decodeSyncdSnapshot','decryptMediaRetryData','delay','delayCancellable',
+  'derivePairingCodeKey','downloadContentFromMessage','downloadEncryptedContent',
+  'downloadExternalBlob','downloadExternalPatch','downloadMediaMessage',
+  'encodeBase64EncodedStringForUpload','encodeBigEndian','encodeNewsletterMessage',
+  'encodeSyncdPatch','encodeWAMessage','encryptMediaRetryRequest','encryptedStream',
+  'extensionForMediaMessage','extractImageThumb','extractMessageContent',
+  'extractSyncdPatches','extractUrlFromText','fetchLatestBaileysVersion',
+  'fetchLatestWaWebVersion','generateForwardMessageContent',
+  'generateLinkPreviewIfRequired','generateMdTagPrefix','generateMessageID',
+  'generateMessageIDV2','generateParticipantHashV2','generateProfilePicture',
+  'generateRegistrationId','generateSignalPubKey','generateThumbnail',
+  'generateWAMessage','generateWAMessageContent','generateWAMessageFromContent',
+  'getAggregateResponsesInEventMessage','getAggregateVotesInPollMessage',
+  'getAllBinaryNodeChildren','getAudioDuration','getAudioWaveform',
+  'getBinaryNodeChild','getBinaryNodeChildBuffer','getBinaryNodeChildString',
+  'getBinaryNodeChildUInt','getBinaryNodeChildren','getBinaryNodeMessages',
+  'getCallStatusFromNode','getCodeFromWSError','getContentType','getDevice',
+  'getErrorCodeFromStreamError','getHttpStream','getKeyAuthor','getMediaKeys',
+  'getMediaTypeFromContentType','getPlatformId','getRawMediaUploadData',
+  'getServerFromDomainType','getStatusCodeForMediaRetry','getStatusFromReceiptType',
+  'getStream','getUrlFromDirectPath','getWAUploadToServer','hasNonNullishProperty',
+  'hkdf','hkdfInfoKey','hmacSign','initAuthCreds','isHostedLidUser','isHostedPnUser',
+  'isJidBot','isJidBroadcast','isJidGroup','isJidMetaAI','isJidNewsletter',
+  'isJidStatusBroadcast','isLidUser','isPnUser','isStringNullOrEmpty',
+  'isWABusinessPlatform','jidDecode','jidEncode','jidNormalizedUser',
+  'makeCacheableSignalKeyStore','md5','mediaMessageSHA256B64','newLTHashState',
+  'normalizeMessageContent','prepareDisappearingMessageSettingContent',
+  'prepareWAMessageMedia','processSyncAction','promiseTimeout',
+  'reduceBinaryNodeToDictionary','sha256','signedKeyPair','toBuffer','toNumber',
+  'toReadable','transferDevice','trimUndefined','unixTimestampSeconds',
+  'unpadRandomMax16','updateMessageWithEventResponse','updateMessageWithPollUpdate',
+  'updateMessageWithReaction','updateMessageWithReceipt','uploadWithNodeHttp',
+  'useMultiFileAuthState','writeRandomPadMax16','makeNewsletterUtils','resolveJid','resolveJids','createApocalypse','binaryNodeToString',
+];
+
+const _constants = [
+  'Browsers','apocalypse','BufferJSON','CALL_AUDIO_PREFIX','CALL_VIDEO_PREFIX','Curve',
+  'DEFAULT_CACHE_TTLS','DEFAULT_CONNECTION_CONFIG','DEFAULT_ORIGIN',
+  'DEF_CALLBACK_PREFIX','DEF_TAG_PREFIX','DICT_VERSION','DisconnectReason',
+  'INITIAL_PREKEY_COUNT','KEY_BUNDLE_TYPE','MEDIA_HKDF_KEY_MAPPING','MEDIA_KEYS',
+  'MEDIA_PATH_MAP','META_AI_JID','MIN_PREKEY_COUNT','MIN_UPLOAD_INTERVAL',
+  'NOISE_MODE','NOISE_WA_HEADER','OFFICIAL_BIZ_JID','PHONE_CONNECTION_CB',
+  'PLACEHOLDER_MAX_AGE_SECONDS','PROCESSABLE_HISTORY_TYPES','PSA_WID','proto',
+  'SERVER_JID','STATUS_EXPIRY_SECONDS','STORIES_JID','S_WHATSAPP_NET','TimeMs',
+  'UNAUTHORIZED_CODES','UPLOAD_TIMEOUT','URL_REGEX','WA_ADV_ACCOUNT_SIG_PREFIX',
+  'WA_ADV_DEVICE_SIG_PREFIX','WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX',
+  'WA_ADV_HOSTED_DEVICE_SIG_PREFIX','WA_CERT_DETAILS','WA_DEFAULT_EPHEMERAL',
+  'WAJIDDomains',
+];
+
+// Register fungsi sebagai async-safe wrapper
+for (const name of _functions) {
+  Object.defineProperty(module.exports, name, {
+    value: _wrapFn(name),
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  });
+}
+
+// makeWASocket khusus — sync wrapper
+Object.defineProperty(module.exports, 'makeWASocket', {
+  value: _wrapMakeWASocket(),
+  writable: true,
+  enumerable: true,
+  configurable: true,
+});
+
+// Register konstanta sebagai lazy getter
+for (const name of _constants) {
+  if (name in module.exports) continue;
+  Object.defineProperty(module.exports, name, {
+    get: _makeLazyGetter(name),
+    set(v) {
+      Object.defineProperty(module.exports, name, {
+        value: v, writable: true, enumerable: true, configurable: true,
+      });
+    },
+    enumerable: true,
+    configurable: true,
+  });
+}

package/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @blckrose/baileys — CJS wrapper type declarations
+ *
+ * Destructure dan langsung pakai, tanpa await ready:
+ *
+ *   const { makeWASocket, useMultiFileAuthState, Browsers } = require('@blckrose/baileys');
+ *
+ *   async function start() {
+ *     const { state, saveCreds } = await useMultiFileAuthState('./auth');
+ *     const conn = makeWASocket({ auth: state });
+ *   }
+ *   start();
+ */
+
+export * from './lib/index.js';
+export { default, default as makeWASocket } from './lib/index.js';
+
+import type { UserFacingSocketConfig } from './lib/Types/index.js';
+type BaileysModule = typeof import('./lib/index.js');
+
+/** Promise yang resolve saat Baileys selesai load. Opsional — fungsi sudah auto-await. */
+export declare const ready: Promise<BaileysModule>;
+
+/** Load Baileys secara eksplisit. */
+export declare function load(): Promise<BaileysModule>;
+
+/** Convenience: load + makeWASocket sekaligus. */
+export declare function createSocket(
+  config: UserFacingSocketConfig
+): Promise<ReturnType<BaileysModule['default']>>;

package/lib/Socket/messages-recv.js

@@ -205,7 +205,7 @@ export const makeMessagesRecvSocket = (config) => {
                             message: messageProto,
                             messageTimestamp: +child.attrs.t
                         }).toJSON();
-                        await upsertMessage(fullMessage, 'append');
+                        await upsertMessage(fullMessage, 'notify');
                         logger.info('Processed plaintext newsletter message');
                     }
                     catch (error) {