@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Store/make-ordered-dictionary.js

@@ -0,0 +1,82 @@
+function makeOrderedDictionary(idGetter) {
+  const array = [];
+  const dict = {};
+
+  const get = (id) => dict[id];
+
+  const update = (item) => {
+    const id = idGetter(item);
+    const idx = array.findIndex((i) => idGetter(i) === id);
+    if (idx >= 0) {
+      array[idx] = item;
+      dict[id] = item;
+    }
+    return false;
+  };
+
+  const upsert = (item, mode) => {
+    const id = idGetter(item);
+    if (get(id)) {
+      update(item);
+    } else {
+      if (mode === 'append') {
+        array.push(item);
+      } else {
+        array.splice(0, 0, item);
+      }
+      dict[id] = item;
+    }
+  };
+
+  const remove = (item) => {
+    const id = idGetter(item);
+    const idx = array.findIndex((i) => idGetter(i) === id);
+    if (idx >= 0) {
+      array.splice(idx, 1);
+      delete dict[id];
+      return true;
+    }
+    return false;
+  };
+
+  return {
+    array,
+    get,
+    upsert,
+    update,
+    remove,
+    updateAssign: (id, update) => {
+      const item = get(id);
+      if (item) {
+        Object.assign(item, update);
+        delete dict[id];
+        dict[idGetter(item)] = item;
+        return true;
+      }
+      return false;
+    },
+    clear: () => {
+      array.splice(0, array.length);
+      for (const key of Object.keys(dict)) {
+        delete dict[key];
+      }
+    },
+    filter: (contain) => {
+      let i = 0;
+      while (i < array.length) {
+        if (!contain(array[i])) {
+          delete dict[idGetter(array[i])];
+          array.splice(i, 1);
+        } else {
+          i += 1;
+        }
+      }
+    },
+    toJSON: () => array,
+    fromJSON: (newItems) => {
+      array.splice(0, array.length, ...newItems);
+    },
+  };
+}
+
+export { makeOrderedDictionary };

package/lib/Store/object-repository.js

@@ -0,0 +1,31 @@
+class ObjectRepository {
+  constructor(entities = {}) {
+    this.entityMap = new Map(Object.entries(entities));
+  }
+
+  findById(id) {
+    return this.entityMap.get(id);
+  }
+
+  findAll() {
+    return Array.from(this.entityMap.values());
+  }
+
+  upsertById(id, entity) {
+    return this.entityMap.set(id, { ...entity });
+  }
+
+  deleteById(id) {
+    return this.entityMap.delete(id);
+  }
+
+  count() {
+    return this.entityMap.size;
+  }
+
+  toJSON() {
+    return this.findAll();
+  }
+}
+
+export { ObjectRepository };

package/lib/Store/reporting-info-store.js

@@ -0,0 +1,38 @@
+const createReportingInfoStore = () => {
+    const byJid = new Map()
+
+    const normalizeKey = jid => (jid || '').toLowerCase()
+
+    return {
+        add(jid, entry) {
+            const key = normalizeKey(jid)
+            if (!key || !entry?.stanzaId || !entry?.reportingTag?.length) return
+            const list = byJid.get(key) || []
+            const idx = list.findIndex(e => e.stanzaId === entry.stanzaId)
+            if (idx >= 0) list[idx] = entry
+            else list.push(entry)
+            list.sort((a, b) => b.timestamp - a.timestamp)
+            byJid.set(key, list)
+        },
+
+        getForJid(jid, max = 5) {
+            return (byJid.get(normalizeKey(jid)) || []).slice(0, max)
+        },
+
+        clear(jid) {
+            byJid.delete(normalizeKey(jid))
+        },
+
+        listJids() {
+            return [...byJid.keys()]
+        },
+
+        size() {
+            let n = 0
+            for (const list of byJid.values()) n += list.length
+            return n
+        }
+    }
+}
+
+export { createReportingInfoStore }

package/lib/Types/Auth.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Auth.js.map

package/lib/Types/Bussines.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Bussines.js.map

package/lib/Types/Call.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Call.js.map

package/lib/Types/Chat.js

@@ -0,0 +1,8 @@
+import { proto } from '../../WAProto/index.js'
+
+// Derived from proto.CollectionName — sorted by enum value, lowercased, UNKNOWN (0) excluded.
+// Automatically picks up new collection names when the proto updates.
+export const ALL_WA_PATCH_NAMES = Object.entries(proto.CollectionName ?? {})
+    .filter(([k, v]) => typeof v === 'number' && v !== 0)
+    .sort((a, b) => a[1] - b[1])
+    .map(([k]) => k.toLowerCase())

package/lib/Types/Contact.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Contact.js.map

package/lib/Types/Events.js

@@ -0,0 +1,2 @@
+import { proto } from '../../WAProto/index.js';
+//# sourceMappingURL=Events.js.map

package/lib/Types/GroupMetadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=GroupMetadata.js.map

package/lib/Types/Label.js

@@ -0,0 +1,25 @@
+/** WhatsApp has 20 predefined colors */
+export var LabelColor;
+(function (LabelColor) {
+    LabelColor[LabelColor["Color1"] = 0] = "Color1";
+    LabelColor[LabelColor["Color2"] = 1] = "Color2";
+    LabelColor[LabelColor["Color3"] = 2] = "Color3";
+    LabelColor[LabelColor["Color4"] = 3] = "Color4";
+    LabelColor[LabelColor["Color5"] = 4] = "Color5";
+    LabelColor[LabelColor["Color6"] = 5] = "Color6";
+    LabelColor[LabelColor["Color7"] = 6] = "Color7";
+    LabelColor[LabelColor["Color8"] = 7] = "Color8";
+    LabelColor[LabelColor["Color9"] = 8] = "Color9";
+    LabelColor[LabelColor["Color10"] = 9] = "Color10";
+    LabelColor[LabelColor["Color11"] = 10] = "Color11";
+    LabelColor[LabelColor["Color12"] = 11] = "Color12";
+    LabelColor[LabelColor["Color13"] = 12] = "Color13";
+    LabelColor[LabelColor["Color14"] = 13] = "Color14";
+    LabelColor[LabelColor["Color15"] = 14] = "Color15";
+    LabelColor[LabelColor["Color16"] = 15] = "Color16";
+    LabelColor[LabelColor["Color17"] = 16] = "Color17";
+    LabelColor[LabelColor["Color18"] = 17] = "Color18";
+    LabelColor[LabelColor["Color19"] = 18] = "Color19";
+    LabelColor[LabelColor["Color20"] = 19] = "Color20";
+})(LabelColor || (LabelColor = {}));
+//# sourceMappingURL=Label.js.map

package/lib/Types/LabelAssociation.js

@@ -0,0 +1,7 @@
+/** Association type */
+export var LabelAssociationType;
+(function (LabelAssociationType) {
+    LabelAssociationType["Chat"] = "label_jid";
+    LabelAssociationType["Message"] = "label_message";
+})(LabelAssociationType || (LabelAssociationType = {}));
+//# sourceMappingURL=LabelAssociation.js.map

package/lib/Types/Message.js

@@ -0,0 +1,15 @@
+import { proto } from '../../WAProto/index.js'
+
+export { proto as WAProto }
+
+// Proto is the authoritative source. These Proxies let callers use
+// WAMessageStubType.GROUP_CREATE or WAMessageStatus.READ exactly as before.
+export const WAMessageStubType = new Proxy({}, { get: (_, k) => proto.WebMessageInfo?.StubType?.[k] })
+export const WAMessageStatus = new Proxy({}, { get: (_, k) => proto.WebMessageInfo?.Status?.[k] })
+
+export const WAMessageAddressingMode = Object.freeze({ PN: 'pn', LID: 'lid' })
+
+// Resolve a numeric stub type to its string name.
+// Proto is the true source — only falls back to UNKNOWN_STUB_N for values not yet in the compiled proto.
+export const resolveStubType = (stubType) =>
+    proto.WebMessageInfo?.StubType?.[stubType] ?? `UNKNOWN_STUB_${stubType}`

package/lib/Types/Newsletter.js

@@ -0,0 +1,100 @@
+export var XWAPaths;
+(function (XWAPaths) {
+  XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+  XWAPaths["xwa2_newsletter_subscribed"] = "xwa2_newsletter_subscribed";
+  XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
+  XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_newsletter_admin_info"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_newsletter_admin_capabilities"] = "xwa2_newsletter_admin";
+  XWAPaths["admin_profile"] = "xwa2_newsletter_admin";
+  XWAPaths["pending_admin_invites"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_channel_enforcements"] = "xwa2_channel_enforcements";
+  XWAPaths["xwa2_channels_reports"] = "xwa2_channels_reports";
+  XWAPaths["xwa2_create_channel_report_appeal_v2"] = "xwa2_create_channel_report_appeal_v2";
+  XWAPaths["xwa2_newsletter_update_user_setting"] = "xwa2_newsletter_update_user_setting";
+  XWAPaths["xwa2_newsletter_join_v2"] = "xwa2_newsletter_join_v2";
+  XWAPaths["xwa2_newsletter_leave_v2"] = "xwa2_newsletter_leave_v2";
+  XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
+  XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_admin_demote";
+  XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+  XWAPaths["xwa2_newsletter_followers"] = "xwa2_newsletter_followers";
+  XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
+  XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
+  XWAPaths["xwa2_newsletter_admin_insights"] = "xwa2_newsletter_admin_insights";
+  XWAPaths["xwa2_newsletter_pin_messages"] = "xwa2_newsletter_pin_messages";
+  XWAPaths["xwa2_newsletter_unpin_messages"] = "xwa2_newsletter_unpin_messages";
+  XWAPaths["xwa2_newsletter_label_ai_content"] = "xwa2_newsletter_label_ai_content";
+  XWAPaths["xwa2_newsletter_label_paid_partnership"] = "xwa2_newsletter_label_paid_partnership";
+  XWAPaths["xwa2_newsletter_admin_invite_create"] = "xwa2_newsletter_admin_invite_create";
+  XWAPaths["xwa2_newsletter_admin_invite_revoke"] = "xwa2_newsletter_admin_invite_revoke";
+  XWAPaths["xwa2_newsletter_admin_invite_accept"] = "xwa2_newsletter_admin_invite_accept";
+  XWAPaths["xwa2_newsletter_link_preview"] = "xwa2_newsletter_link_preview";
+  XWAPaths["xwa2_newsletter_question_response_state_update"] = "xwa2_newsletter_question_response_state_update";
+  XWAPaths["voter_list"] = "voter_list";
+  XWAPaths["xwa2_newsletters_reaction_sender_list"] = "xwa2_newsletters_reaction_sender_list";
+  XWAPaths["xwa2_newsletters_recommended"] = "xwa2_newsletters_recommended";
+  XWAPaths["xwa2_newsletters_similar"] = "xwa2_newsletters_similar";
+  XWAPaths["xwa2_newsletters_directory_list"] = "xwa2_newsletters_directory_list";
+  XWAPaths["xwa2_newsletters_directory_search"] = "xwa2_newsletters_directory_search";
+  XWAPaths["xwa2_newsletters_directory_category_preview"] = "xwa2_newsletters_directory_category_preview";
+  XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+  XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
+  XWAPaths["xwa2_username_get"] = "xwa2_username_get";
+  XWAPaths["xwa2_username_set"] = "xwa2_username_set";
+  XWAPaths["xwa2_username_pin_set"] = "xwa2_username_pin_set";
+  XWAPaths["xwa2_username_check"] = "xwa2_username_check";
+  XWAPaths["xwa2_update_text_status"] = "xwa2_update_text_status";
+  XWAPaths["xwa2_text_status_list"] = "xwa2_text_status_list";
+  XWAPaths["xwa2_users_updates_since"] = "xwa2_users_updates_since";
+})(XWAPaths || (XWAPaths = {}));
+
+export var QueryIds;
+(function (QueryIds) {
+  QueryIds["CREATE"] = "25149874324715067";
+  QueryIds["UPDATE_METADATA"] = "24250201037901610";
+  QueryIds["METADATA"] = "27456920720571478";
+  QueryIds["SUBSCRIBERS"] = "9783111038412085";
+  QueryIds["SUBSCRIBED"] = "25399611239711790";
+  QueryIds["FOLLOW"] = "24404358912487870";
+  QueryIds["UNFOLLOW"] = "9767147403369991";
+  QueryIds["ENFORCEMENTS"] = "27835373536068060";
+  QueryIds["CHANNEL_REPORTS"] = "35936238352686172";
+  QueryIds["CREATE_REPORT_APPEAL"] = "27103316329328467";
+  QueryIds["UPDATE_USER_SETTING"] = "31938993655691868";
+  QueryIds["ADMIN_COUNT"] = "26278439461859188";
+  QueryIds["ADMIN_INFO"] = "26278439461859188";
+  QueryIds["ADMIN_CAPABILITIES"] = "9801384413216421";
+  QueryIds["CHANGE_OWNER"] = "9546742745432473";
+  QueryIds["DEMOTE"] = "9880997548630971";
+  QueryIds["DELETE"] = "30062808666639665";
+  QueryIds["FOLLOWERS"] = "27472091235714801";
+  QueryIds["MUTE"] = "29766401636284406";
+  QueryIds["UNMUTE"] = "9864994326891137";
+  QueryIds["INSIGHTS"] = "9853618868050977";
+  QueryIds["PIN_MESSAGES"] = "27165709459706559";
+  QueryIds["UNPIN_MESSAGES"] = "28007176042216937";
+  QueryIds["LABEL_AI_CONTENT"] = "27909718265289596";
+  QueryIds["PAID_PARTNERSHIP_LABEL"] = "26102375079404865";
+  QueryIds["CREATE_ADMIN_INVITE"] = "9387141988078609";
+  QueryIds["REVOKE_ADMIN_INVITE"] = "9656078347839416";
+  QueryIds["ACCEPT_ADMIN_INVITE"] = "9580828702035549";
+  QueryIds["POLL_VOTERS"] = "9407762219322536";
+  QueryIds["REACTION_SENDER_LIST"] = "29575462448733991";
+  QueryIds["RECOMMENDED"] = "25806748772361516";
+  QueryIds["SIMILAR"] = "26217043484590756";
+  QueryIds["DIRECTORY_LIST"] = "26125047313831973";
+  QueryIds["DIRECTORY_SEARCH"] = "26301059626252132";
+  QueryIds["DIRECTORY_CATEGORIES"] = "35266481849605779";
+  QueryIds["PENDING_ADMIN_INVITES"] = "9783111038412085";
+  QueryIds["QUESTION_RESPONSE_STATE"] = "24636260219323456";
+  QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+  QueryIds["MESSAGE_CAPPING_INFO"] = "27910975521856601";
+  QueryIds["PLAINTEXT_LINK_PREVIEW"] = "9101130456653613";
+  QueryIds["USERNAME_GET"] = "25347099718279209";
+  QueryIds["USERNAME_SET"] = "25757341163897635";
+  QueryIds["USERNAME_PIN_SET"] = "9749436995157074";
+  QueryIds["USERNAME_CHECK"] = "26122779627399568";
+  QueryIds["UPDATE_TEXT_STATUS"] = "9152604461510864";
+  QueryIds["TEXT_STATUS_LIST"] = "24072923595647473";
+  QueryIds["ABOUT_STATUS"] = "24535500086059408";
+})(QueryIds || (QueryIds = {}));

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Product.js.map

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+import { proto } from '../../WAProto/index.js';
+//# sourceMappingURL=Signal.js.map

package/lib/Types/Socket.js

@@ -0,0 +1,14 @@
+import { proto } from '../../WAProto/index.js';
+import {} from './Message.js';
+//# sourceMappingURL=Socket.js.map
+export const AIProvenanceType = Object.freeze({
+    NONE: 0,
+    CREATED_WITH_GEN_AI: 1,
+    EDITED_WITH_GEN_AI: 2,
+})
+
+export const DeviceCapabilityLevel = Object.freeze({
+    NONE: 0,
+    INFRA: 1,
+    FULL: 2,
+})

package/lib/Types/State.js

@@ -0,0 +1,26 @@
+export const SyncState = Object.freeze({ Connecting: 0, AwaitingInitialSync: 1, Syncing: 2, Online: 3 })
+
+export const ReachoutTimelockEnforcementType = Object.freeze({
+    BIZ_COMMERCE_VIOLATION_ALCOHOL: 'BIZ_COMMERCE_VIOLATION_ALCOHOL',
+    BIZ_COMMERCE_VIOLATION_ADULT: 'BIZ_COMMERCE_VIOLATION_ADULT',
+    BIZ_COMMERCE_VIOLATION_ANIMALS: 'BIZ_COMMERCE_VIOLATION_ANIMALS',
+    BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS: 'BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS',
+    BIZ_COMMERCE_VIOLATION_DATING: 'BIZ_COMMERCE_VIOLATION_DATING',
+    BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS: 'BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS',
+    BIZ_COMMERCE_VIOLATION_DRUGS: 'BIZ_COMMERCE_VIOLATION_DRUGS',
+    BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC: 'BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC',
+    BIZ_COMMERCE_VIOLATION_GAMBLING: 'BIZ_COMMERCE_VIOLATION_GAMBLING',
+    BIZ_COMMERCE_VIOLATION_HEALTHCARE: 'BIZ_COMMERCE_VIOLATION_HEALTHCARE',
+    BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY: 'BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY',
+    BIZ_COMMERCE_VIOLATION_SUPPLEMENTS: 'BIZ_COMMERCE_VIOLATION_SUPPLEMENTS',
+    BIZ_COMMERCE_VIOLATION_TOBACCO: 'BIZ_COMMERCE_VIOLATION_TOBACCO',
+    BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT: 'BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT',
+    BIZ_COMMERCE_VIOLATION_WEAPONS: 'BIZ_COMMERCE_VIOLATION_WEAPONS',
+    BIZ_QUALITY: 'BIZ_QUALITY',
+    DEFAULT: 'DEFAULT',
+    WEB_COMPANION_ONLY: 'WEB_COMPANION_ONLY',
+})
+
+export const NewChatMessageCappingStatusType = Object.freeze({ NONE:'NONE', FIRST_WARNING:'FIRST_WARNING', SECOND_WARNING:'SECOND_WARNING', CAPPED:'CAPPED' })
+export const NewChatMessageCappingMVStatusType = Object.freeze({ NOT_ELIGIBLE:'NOT_ELIGIBLE', NOT_ACTIVE:'NOT_ACTIVE', ACTIVE:'ACTIVE', ACTIVE_UPGRADE_AVAILABLE:'ACTIVE_UPGRADE_AVAILABLE' })
+export const NewChatMessageCappingOTEStatusType = Object.freeze({ NOT_ELIGIBLE:'NOT_ELIGIBLE', ELIGIBLE:'ELIGIBLE', ACTIVE_IN_CURRENT_CYCLE:'ACTIVE_IN_CURRENT_CYCLE', EXHAUSTED:'EXHAUSTED' })

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+import { USyncUser } from '../WAUSync/index.js';
+//# sourceMappingURL=USync.js.map

package/lib/Types/index.js

@@ -0,0 +1,30 @@
+export * from './Auth.js'
+export * from './GroupMetadata.js'
+export * from './Chat.js'
+export * from './Contact.js'
+export * from './State.js'
+export * from './Message.js'
+export * from './Socket.js'
+export * from './Events.js'
+export * from './Product.js'
+export * from './Call.js'
+export * from './Signal.js'
+export * from './Newsletter.js'
+export * from './Label.js'
+export * from './LabelAssociation.js'
+export * from './USync.js'
+
+export const DisconnectReason = Object.freeze({
+    connectionClosed: 428,
+    connectionLost: 408,
+    connectionReplaced: 440,
+    timedOut: 408,
+    loggedOut: 401,
+    badSession: 500,
+    restartRequired: 515,
+    multideviceMismatch: 411,
+    forbidden: 403,
+    unavailableService: 503,
+})
+
+

package/lib/Utils/auth-utils.js

@@ -0,0 +1,142 @@
+import NodeCache from '@cacheable/node-cache'
+import { AsyncLocalStorage } from 'async_hooks'
+import { Mutex } from 'async-mutex'
+import { randomBytes } from 'crypto'
+import PQueue from 'p-queue'
+import { v4 } from 'uuid'
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js'
+import { Curve, signedKeyPair } from './crypto.js'
+import { delay, generateRegistrationId } from './generics.js'
+import { PreKeyManager } from './pre-key-manager.js'
+
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, useClones: false, deleteOnExpire: true })
+    const cacheMutex = new Mutex()
+    const uid = (type, id) => `${type}.${id}`
+    return {
+        async get(type, ids) {
+            return cacheMutex.runExclusive(async () => {
+                const data = {}, missing = []
+                for (const id of ids) { const item = await cache.get(uid(type, id)); if (typeof item !== 'undefined') data[id] = item; else missing.push(id) }
+                if (missing.length) { logger?.trace({ items: missing.length }, 'loading from store'); const fetched = await store.get(type, missing); for (const id of missing) { if (fetched[id]) { data[id] = fetched[id]; cache.set(uid(type, id), fetched[id]) } } }
+                return data
+            })
+        },
+        async set(data) {
+            return cacheMutex.runExclusive(async () => {
+                let keys = 0
+                for (const type in data) { for (const id in data[type]) { await cache.set(uid(type, id), data[type][id]); keys++ } }
+                logger?.trace({ keys }, 'updated cache')
+                await store.set(data)
+            })
+        },
+        async clear() { await cache.flushAll(); await store.clear?.() }
+    }
+}
+
+export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new AsyncLocalStorage()
+    const keyQueues = new Map()
+    const txMutexes = new Map()
+    const preKeyManager = new PreKeyManager(state, logger)
+
+    const getQueue = key => { if (!keyQueues.has(key)) keyQueues.set(key, new PQueue({ concurrency: 1 })); return keyQueues.get(key) }
+    const getTxMutex = key => { if (!txMutexes.has(key)) txMutexes.set(key, new Mutex()); return txMutexes.get(key) }
+    const isInTransaction = () => !!txStorage.getStore()
+
+    const EXPECTED_ERRORS = ['InvalidPreKeyId', 'SessionNotFound', 'InvalidMessage', 'no sender key state', 'memory access out of bounds', 'old counter', 'DuplicatedMessage', 'BadMac', 'Connection Closed']
+    const isExpectedError = msg => EXPECTED_ERRORS.some(e => msg.includes(e))
+
+    async function commitWithRetry(mutations) {
+        if (Object.keys(mutations).length === 0) { logger.trace('no mutations in transaction'); return }
+        logger.trace('committing transaction')
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+            try {
+                await state.set(mutations)
+                logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction')
+                return
+            } catch (error) {
+                const msg = error?.message || (typeof error === 'string' ? error : '') || ''
+                if (isExpectedError(msg)) { logger?.debug?.({ error: msg }, 'transaction skipped — expected decrypt error'); return }
+                if (attempt < maxCommitRetries - 1) { await delay(delayBetweenTriesMs); continue }
+                logger?.error?.({ error: msg || error }, 'transaction failed after retries')
+                throw error
+            }
+        }
+    }
+
+    return {
+        get: async (type, ids) => {
+            const ctx = txStorage.getStore()
+            if (!ctx) return state.get(type, ids)
+            const cached = ctx.cache[type] || {}
+            const missing = ids.filter(id => !(id in cached))
+            if (missing.length) { ctx.dbQueries++; logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction'); const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing)); ctx.cache[type] = ctx.cache[type] || {}; Object.assign(ctx.cache[type], fetched) }
+            const result = {}
+            for (const id of ids) { const value = ctx.cache[type]?.[id]; if (value !== undefined && value !== null) result[id] = value }
+            return result
+        },
+        set: async (data) => {
+            const ctx = txStorage.getStore()
+            if (!ctx) {
+                const types = Object.keys(data)
+                for (const type of types) { if (type === 'pre-key') await preKeyManager.validateDeletions(data, type) }
+                await Promise.all(types.map(type => getQueue(type).add(async () => state.set({ [type]: data[type] }))))
+                return
+            }
+            logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+            for (const key in data) {
+                ctx.cache[key] = ctx.cache[key] || {}
+                ctx.mutations[key] = ctx.mutations[key] || {}
+                if (key === 'pre-key') await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true)
+                else { Object.assign(ctx.cache[key], data[key]); Object.assign(ctx.mutations[key], data[key]) }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore()
+            if (existing) { logger.trace('reusing existing transaction context'); return work() }
+            return getTxMutex(key).runExclusive(async () => {
+                const ctx = { cache: {}, mutations: {}, dbQueries: 0 }
+                logger.trace('entering transaction')
+                try {
+                    const result = await txStorage.run(ctx, work)
+                    await commitWithRetry(ctx.mutations)
+                    logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed')
+                    return result
+                } catch (error) {
+                    const msg = error?.message || (typeof error === 'string' ? error : '') || ''
+                        ; (isExpectedError(msg) ? logger?.debug?.bind(logger) : logger?.error?.bind(logger))?.({ error: msg || error }, 'transaction failed, rolling back')
+                    throw error
+                }
+            })
+        }
+    }
+}
+
+export const initAuthCreds = () => {
+    const identityKey = Curve.generateKeyPair()
+    return {
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: { unarchiveChats: false },
+        deviceId: Buffer.from(v4().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: v4(),
+        identityId: randomBytes(20),
+        registered: false,
+        backupToken: randomBytes(20),
+        registration: {},
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    }
+}

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,33 @@
+import EventEmitter from 'events'
+import { createReadStream } from 'fs'
+import { writeFile } from 'fs/promises'
+import { createInterface } from 'readline'
+import { delay } from './generics.js'
+import { makeMutex } from './make-mutex.js'
+
+export const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit.bind(ev)
+    const writeMutex = makeMutex()
+    ev.emit = (...args) => {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n'
+        const result = oldEmit(...args)
+        writeMutex.mutex(() => writeFile(filename, content, { flag: 'a' }))
+        return result
+    }
+}
+
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new EventEmitter()
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename)
+        const rl = createInterface({ input: fileStream, crlfDelay: Infinity })
+        for await (const line of rl) {
+            if (!line) continue
+            const { event, data } = JSON.parse(line)
+            ev.emit(event, data)
+            if (delayIntervalMs) await delay(delayIntervalMs)
+        }
+        fileStream.destroy()
+    }
+    return { ev, task: fireEvents() }
+}

package/lib/Utils/bot-capabilities.js

@@ -0,0 +1,40 @@
+import { proto } from '../../WAProto/index.js'
+import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js'
+
+export const BotCapabilityType = proto.BotCapabilityMetadata.BotCapabilityType
+
+const capabilityNames = new Set(Object.keys(BotCapabilityType).filter(n => Number.isNaN(Number(n))))
+
+export const normalizeBotCapabilities = (capabilities = []) => {
+    if (!Array.isArray(capabilities)) throw new TypeError('capabilities must be an array')
+    const values = capabilities.map(c => {
+        if (typeof c === 'string') { if (!capabilityNames.has(c)) throw new TypeError(`Unknown bot capability: ${c}`); return BotCapabilityType[c] }
+        if (Number.isInteger(c) && BotCapabilityType[c] !== undefined) return c
+        throw new TypeError(`Invalid bot capability: ${String(c)}`)
+    })
+    return [...new Set(values)]
+}
+
+export const buildBotCapabilityMetadata = (capabilities = []) => ({ capabilities: normalizeBotCapabilities(capabilities) })
+
+// Use AIRich builder for complex multi-section responses
+export const buildBotRichResponse = ({ text, submessages, capabilities = [], botMetadata = {}, botJid = '867051314767696@bot', richResponse = {} } = {}) => {
+    const resolved = submessages || (text == null ? [] : [{ messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT, messageText: String(text) }])
+    return {
+        messageContextInfo: {
+            botMetadata: { ...botMetadata, capabilityMetadata: buildBotCapabilityMetadata(capabilities), botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+                    submessages: resolved,
+                    ...richResponse,
+                    contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4, ...(richResponse.contextInfo || {}) }
+                }
+            }
+        }
+    }
+}
+
+export const capability = name => { if (!capabilityNames.has(name)) throw new TypeError(`Unknown bot capability: ${name}`); return BotCapabilityType[name] }