@vanzxy/baileys 1.6.7 → 1.7.0

package/lib/Utils/MessageBuilder.js

@@ -763,6 +763,46 @@ class Button extends BaseBuilder {
 	//   - a node can carry a builder-only `ref: 'name'` tag; another prop can then point back
 	//     at it with `{ $ref: 'name' }`, resolved to that node's real id after the whole tree
 	//     is walked (order-independent). `ref` itself is stripped and never reaches the wire.
+	//
+	// Vanz@Add 01-09-26 --- JSDoc typedefs for the "basic" A2UI catalog below (component set +
+	// props confirmed from captured traffic — see /areas/vanzxy-baileys.md). This is NOT the
+	// official A2UI spec (there isn't a public one we have access to), just what's been observed
+	// on the wire, so BloksNode ends with a permissive `AnyBloksNode` fallback: known components
+	// get full editor autocomplete + prop hints, anything else still type-checks and still works
+	// at runtime (setBloksWidget()'s own validation only ever requires a "component" string).
+	/**
+	 * @typedef {{ $ref: string }} BloksRef
+	 * Points back at a sibling node tagged `ref: 'name'` elsewhere in the same tree (currently
+	 * only needed for `Modal.trigger`/`Modal.content` — everything else nests directly).
+	 */
+	/**
+	 * @typedef {Object} BloksNodeBase
+	 * @property {string} [ref] Builder-only tag so another node can reference this one via `{ $ref: ref }`. Stripped before send.
+	 */
+	/**
+	 * @typedef {BloksNodeBase & { component: 'Column'|'Row', weight?: number, justify?: string, children?: BloksNode[] }} ColumnRowNode
+	 * @typedef {BloksNodeBase & { component: 'Text', text: string, variant?: string }} TextNode
+	 * @typedef {BloksNodeBase & { component: 'Icon', name: string }} IconNode
+	 * @typedef {BloksNodeBase & { component: 'Divider' }} DividerNode
+	 * @typedef {BloksNodeBase & { component: 'Image', url: string, variant?: string, fit?: string }} ImageNode
+	 * @typedef {BloksNodeBase & { component: 'Video', url: string }} VideoNode
+	 * @typedef {BloksNodeBase & { component: 'List', children?: BloksNode[] }} ListNode
+	 * @typedef {BloksNodeBase & { component: 'TextField', label?: string, value?: string, variant?: string }} TextFieldNode
+	 * @typedef {BloksNodeBase & { component: 'DateTimeInput', label?: string, value?: string, enableDate?: boolean, enableTime?: boolean }} DateTimeInputNode
+	 * @typedef {BloksNodeBase & { component: 'Slider', label?: string, min?: number, max?: number, value?: number }} SliderNode
+	 * @typedef {BloksNodeBase & { component: 'CheckBox', label?: string, value?: boolean }} CheckBoxNode
+	 * @typedef {BloksNodeBase & { component: 'ChoicePicker', label?: string, variant?: string, displayStyle?: string, options?: Array<{label: string, value: string}>, value?: string }} ChoicePickerNode
+	 * @typedef {BloksNodeBase & { component: 'Button', child?: BloksNode, variant?: string, action?: { call: string, args?: Record<string, any> } }} BloksButtonNode
+	 *   Note: unlike the CTA/native-flow `Button` class elsewhere in this file, an A2UI Button node
+	 *   has no `label`/`type`+`name` — its label comes from a nested `child` (usually a `Text` node),
+	 *   and tapping it fires `action.call` (with `action.args`), not a native-flow button name.
+	 * @typedef {BloksNodeBase & { component: 'Modal', trigger: string|BloksRef, content: BloksNode|string|BloksRef }} ModalNode
+	 * @typedef {BloksNodeBase & { component: 'Tabs', tabs: Array<{title: string, child: BloksNode}> }} TabsNode
+	 * @typedef {BloksNodeBase & { component: 'Card', child?: BloksNode }} CardNode
+	 * @typedef {BloksNodeBase & { component: 'AudioPlayer', url: string, description?: string }} AudioPlayerNode
+	 * @typedef {BloksNodeBase & { component: string, [key: string]: any }} AnyBloksNode Fallback for components not yet confirmed on the wire — still works, just no prop-level autocomplete.
+	 * @typedef {ColumnRowNode|TextNode|IconNode|DividerNode|ImageNode|VideoNode|ListNode|TextFieldNode|DateTimeInputNode|SliderNode|CheckBoxNode|ChoicePickerNode|BloksButtonNode|ModalNode|TabsNode|CardNode|AudioPlayerNode|AnyBloksNode} BloksNode
+	 */
 	#flattenBloks(tree, out, ctx = { n: 0, refs: new Map(), pending: [] }, id = 'root') {
 		if (!tree || typeof tree !== 'object') throw new TypeError('setBloksWidget: every node needs a "component" type');
 		const { component, children, child, ref, ...rest } = tree;
@@ -804,7 +844,7 @@ class Button extends BaseBuilder {
 	 * `Modal.trigger` — tag the source node with `ref: 'someName'` and point at it with
 	 * `{ $ref: 'someName' }`. Everything else (including `Modal.content`) can just be nested
 	 * directly, no special key needed.
-	 * @param {Record<string, any>} tree Root node, e.g. `{ component: 'Column', children: [...] }`.
+	 * @param {BloksNode} tree Root node, e.g. `{ component: 'Column', children: [...] }`.
 	 * @param {{uuid?: string, catalogId?: string, surfaceId?: string, version?: string}} [options]
 	 */
 	setBloksWidget(tree, { uuid = crypto.randomUUID(), catalogId = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json', surfaceId, version = 'v0.9' } = {}) {
@@ -2102,6 +2142,19 @@ class AIRich extends BaseBuilder {
 		// last item that belongs to the block named by insertAt. Blocks are tracked by *object
 		// reference*, not saved numeric index, so earlier insertions shifting the array around never
 		// invalidates a later insertAt lookup (indexOf on the reference always finds the live position).
+		//
+		// Vanz@Note (bug 71, behavior — not fixed, documented) --- insertAt always inserts right after
+		// the ANCHOR's block, not after "whatever was most recently inserted there". Chaining (each new
+		// item gets its own id, and the next call's insertAt points at THAT id — exactly what the
+		// addText/addSuggest streaming-reveal example does) produces the expected order. But calling
+		// insertAt at the SAME static anchor id repeatedly, without giving each new item its own id to
+		// chain onto, inserts every one of them right after the original anchor — so the order comes out
+		// reversed relative to call order (confirmed by test: id:'x' then 3x insertAt:'x' with no id of
+		// their own on the new items produces [x, third, second, first], not [x, first, second, third]).
+		// Left as-is rather than "fixed": making insertAt self-advance (re-pointing the anchor's block at
+		// whatever was just inserted) would silently change what an id resolves to for any OTHER caller
+		// still holding that id for a later replace()/delete()/insertAt() — a subtler, harder-to-diagnose
+		// bug than the surprising-but-deterministic order this produces. Chain with fresh ids instead.
 		this._blocks = new Map(); // id -> { subItems: object[], secItems: object[] }
 		return new Proxy(this, {
 			get(target, prop, receiver) {
@@ -2129,6 +2182,19 @@ class AIRich extends BaseBuilder {
 					const insertAt = opts?.insertAt;
 					const replace = opts?.replace;
 
+					// Vanz@Fix (bug 70) --- `id` reuse across two different add*/set* calls was silently
+					// accepted: target._blocks.set(id, ...) below just clobbers the previous registration,
+					// so the FIRST block with that id becomes an untracked ghost — still in _sections/
+					// _submessages (still renders), but no longer reachable via hasId/peek/delete/replace/
+					// insertAt (the id now only resolves to the second block). Confirmed by direct test:
+					// addText('first',{id:'dup'}); addText('second',{id:'dup'}) left both in the message
+					// but getIds() only ever had one 'dup', pointing at 'second'. Fail fast instead — same
+					// as re-registering the same id you're actively `replace`-ing (that's a legitimate
+					// "update this block, keep its id" call, not a collision).
+					if (id && target._blocks.has(id) && replace !== id) {
+						throw new Error(`add*/set*: id "${id}" is already registered — each id must be unique (pass { replace: "${id}" } to update that block instead, or use a different id)`);
+					}
+
 					const subBefore = target._submessages.length;
 					const secBefore = target._sections.length;
 
@@ -2977,6 +3043,14 @@ class AIRich extends BaseBuilder {
 	addWidget(data = {}, { layout } = {}) {
 		const items = Array.isArray(data) ? data : [data];
 
+		// Vanz@Fix (bug 44) --- layout: 'Single' forces `widgets[0]` below (a "Single" layout's
+		// view_model can only ever hold one `primitive`, never a `primitives` array — see
+		// newLayout()). Previously an explicit { layout: 'Single' } combined with a multi-item
+		// array silently dropped every item past the first with no error. Fail loud instead.
+		if (layout === 'Single' && items.length > 1) {
+			throw new TypeError(`addWidget(): layout "Single" can only hold one widget (got ${items.length}) — use "HScroll"/"ActionRow" (or omit layout) for multiple`);
+		}
+
 		items.forEach((item, i) => {
 			// header.title or top-level title required
 			const hasTitle = item?.title || item?.header?.title;
@@ -2994,6 +3068,13 @@ class AIRich extends BaseBuilder {
 			messageText: items.map((item) => item.header?.title ?? item.title).join(', '),
 		});
 
+		// Vanz@Fix (bug 45) --- auto tool_call_id used to be `idx` scoped per-item (ctas.map's own
+		// index), resetting to 0 for every widget item. Two items (or two separate addWidget()
+		// calls) that both omit tool_call_id/id ended up minting the identical auto id ("00"),
+		// so a CTA tap could route to the wrong widget's tool call. Track the counter on the
+		// instance instead so every auto-generated id is unique for this AIRich's lifetime.
+		this._widgetCtaCounter ??= 0;
+
 		const widgets = items.map((item) => {
 			const ctas = item.ctas ?? item.actions;
 			// header accepts either a string title (legacy) or an object { title, subtitle }
@@ -3007,11 +3088,11 @@ class AIRich extends BaseBuilder {
 				},
 				body: {
 					sections: item.sections ?? [],
-					ctas: ctas.map((cta, idx) => ({
+					ctas: ctas.map((cta) => ({
 						label: cta.label ?? '',
 						state: cta.state ?? 'PENDING',
 						kind: cta.kind ?? 'OTHER',
-						tool_call_id: cta.tool_call_id ?? cta.id ?? String(idx).padStart(2, '0'),
+						tool_call_id: cta.tool_call_id ?? cta.id ?? String(this._widgetCtaCounter++).padStart(2, '0'),
 						...(cta.toast !== false && {
 							toast: { label: typeof cta.toast === 'string' ? cta.toast : headerTitle, __typename: 'GenAI3PExtWidgetToast' },
 						}),

package/lib/Utils/MessageBuilder_d.ts

@@ -37,6 +37,138 @@ export interface TapTargetConfigurationParams {
 	buttonIndex?: number;
 }
 
+/**
+ * A2UI/Bloks "basic" catalog node types — confirmed from captured traffic (see
+ * /areas/vanzxy-baileys.md), not a public spec, so treat this as best-effort autocomplete
+ * rather than an exhaustive guarantee. `ref` is a builder-only tag (stripped before send) so
+ * another node can reference this one via `BloksRef`.
+ */
+export interface BloksRef {
+	$ref: string;
+}
+export interface BloksNodeBase {
+	/** Builder-only tag so another node can reference this one via `{ $ref: ref }`. Stripped before send. */
+	ref?: string;
+}
+export interface ColumnRowNode extends BloksNodeBase {
+	component: 'Column' | 'Row';
+	weight?: number;
+	justify?: string;
+	children?: BloksNode[];
+}
+export interface TextNode extends BloksNodeBase {
+	component: 'Text';
+	text: string;
+	variant?: string;
+}
+export interface IconNode extends BloksNodeBase {
+	component: 'Icon';
+	name: string;
+}
+export interface DividerNode extends BloksNodeBase {
+	component: 'Divider';
+}
+export interface ImageNode extends BloksNodeBase {
+	component: 'Image';
+	url: string;
+	variant?: string;
+	fit?: string;
+}
+export interface VideoNode extends BloksNodeBase {
+	component: 'Video';
+	url: string;
+}
+export interface ListNode extends BloksNodeBase {
+	component: 'List';
+	children?: BloksNode[];
+}
+export interface TextFieldNode extends BloksNodeBase {
+	component: 'TextField';
+	label?: string;
+	value?: string;
+	variant?: string;
+}
+export interface DateTimeInputNode extends BloksNodeBase {
+	component: 'DateTimeInput';
+	label?: string;
+	value?: string;
+	enableDate?: boolean;
+	enableTime?: boolean;
+}
+export interface SliderNode extends BloksNodeBase {
+	component: 'Slider';
+	label?: string;
+	min?: number;
+	max?: number;
+	value?: number;
+}
+export interface CheckBoxNode extends BloksNodeBase {
+	component: 'CheckBox';
+	label?: string;
+	value?: boolean;
+}
+export interface ChoicePickerNode extends BloksNodeBase {
+	component: 'ChoicePicker';
+	label?: string;
+	variant?: string;
+	displayStyle?: string;
+	options?: Array<{ label: string; value: string }>;
+	value?: string;
+}
+/**
+ * Unlike the CTA/native-flow `Button` class elsewhere in this file, an A2UI Button node has no
+ * `label`/`type`+`name` — its label comes from a nested `child` (usually a `Text` node), and
+ * tapping it fires `action.call` (with `action.args`), not a native-flow button name.
+ */
+export interface BloksButtonNode extends BloksNodeBase {
+	component: 'Button';
+	child?: BloksNode;
+	variant?: string;
+	action?: { call: string; args?: Record<string, any> };
+}
+export interface ModalNode extends BloksNodeBase {
+	component: 'Modal';
+	trigger: string | BloksRef;
+	content: BloksNode | string | BloksRef;
+}
+export interface TabsNode extends BloksNodeBase {
+	component: 'Tabs';
+	tabs: Array<{ title: string; child: BloksNode }>;
+}
+export interface CardNode extends BloksNodeBase {
+	component: 'Card';
+	child?: BloksNode;
+}
+export interface AudioPlayerNode extends BloksNodeBase {
+	component: 'AudioPlayer';
+	url: string;
+	description?: string;
+}
+/** Fallback for components not yet confirmed on the wire — still works at runtime, just no prop-level autocomplete. */
+export interface AnyBloksNode extends BloksNodeBase {
+	component: string;
+	[key: string]: any;
+}
+export type BloksNode =
+	| ColumnRowNode
+	| TextNode
+	| IconNode
+	| DividerNode
+	| ImageNode
+	| VideoNode
+	| ListNode
+	| TextFieldNode
+	| DateTimeInputNode
+	| SliderNode
+	| CheckBoxNode
+	| ChoicePickerNode
+	| BloksButtonNode
+	| ModalNode
+	| TabsNode
+	| CardNode
+	| AudioPlayerNode
+	| AnyBloksNode;
+
 export class Button extends BaseBuilder {
 	constructor(client: any);
 	setVideo(path: string | Buffer, options?: Record<string, any>): this;
@@ -45,7 +177,7 @@ export class Button extends BaseBuilder {
 	setMedia(obj: Record<string, any>): this;
 	clearButtons(): this;
 	setParams(obj: Record<string, any>): this;
-	setBloksWidget(tree: Record<string, any>, options?: { uuid?: string; catalogId?: string; surfaceId?: string; version?: string }): this;
+	setBloksWidget(tree: BloksNode, options?: { uuid?: string; catalogId?: string; surfaceId?: string; version?: string }): this;
 	addButton(name: string, params: string | Record<string, any>): this;
 	makeRow(header?: string, title?: string, description?: string, id?: string): this;
 	makeSection(title?: string, highlight_label?: string): this;

package/lib/Utils/anti-delete.js

@@ -80,12 +80,20 @@ export class MessageStore {
         stored.isDeleted = true;
         stored.deletedAt = now;
         stored.deletedBy = deletedBy;
+        // Vanz@Fix (bug 66): the old check (`deletedBy === stored.message.key.participant`)
+        // only works in groups, where `participant` identifies who sent/revoked a message.
+        // In a private chat `key.participant` is always undefined (it's a group-only field),
+        // while `deletedBy` there falls back to `remoteJid` — so the comparison could never
+        // match and isRevokedBySender was always false for every DM, even though
+        // delete-for-everyone in a DM can only be done by the original sender. Treat a
+        // missing `participant` (i.e. not a group message) as "revoked by sender" by definition.
+        const isGroupMessage = !!stored.message.key.participant;
         const info = {
             originalMessage: stored.message,
             key,
             deletedAt: now,
             deletedBy,
-            isRevokedBySender: !deletedBy || deletedBy === stored.message.key.participant
+            isRevokedBySender: !deletedBy || !isGroupMessage || deletedBy === stored.message.key.participant
         };
         this.deletedMessages.set(this.getKey(key), info);
         return info;

package/lib/Utils/generics.js

@@ -71,7 +71,25 @@ export const encodeBigEndian = (e, t = 4) => {
 };
 export const toNumber = (t) => typeof t === 'object' && t ? ('toNumber' in t ? t.toNumber() : t.low) : t || 0;
 /** unix timestamp of a date in seconds */
-export const unixTimestampSeconds = (date = new Date()) => date.getTime() / 1000 | 0;
+// Vanz@Fix (bug 69): unixTimestampSeconds(date) assumed `date` is always a real Date
+// instance and called date.getTime() unconditionally. Any caller that passed a raw
+// number (Date.now(), or an already-converted unix timestamp) or an ISO string instead
+// of a Date crashed here with "date.getTime is not a function" — this is a coercion
+// bug in THIS function, not a proto/BloksWidget/InteractiveMessage issue (traced and
+// confirmed: normalizeMessageContent/getContentType never touch nested message content,
+// and this function is called before any encode/serialize step even starts). Coerce the
+// common input shapes instead of assuming Date, but keep throwing on genuinely invalid
+// input (NaN) so silent bad-timestamp bugs don't get hidden.
+export const unixTimestampSeconds = (date) => {
+    if (date == null) date = new Date(); // null AND undefined both mean "now" (default params only catch undefined)
+    const d = date instanceof Date
+        ? date
+        : new Date(typeof date === 'number' && date < 1e12 ? date * 1000 : date); // treat sub-1e12 numbers as already-seconds
+    if (Number.isNaN(d.getTime())) {
+        throw new TypeError(`unixTimestampSeconds: invalid timestamp input (${typeof date}): ${date}`);
+    }
+    return d.getTime() / 1000 | 0;
+};
 export const debouncedTimeout = (intervalMs = 1000, task) => {
     let timeout;
     return {

package/lib/Utils/media-set.js

@@ -145,7 +145,11 @@ export const groupLabel = async (jid, text, sock) => {
                 type: 30,
                 memberLabel: {
                     label: text.slice(0, 30),
-                    labelTimestamp: Date.now()
+                    // Vanz@Fix (bug 67): this used Date.now() (milliseconds) while the
+                    // sibling groupSetMemberLabel() correctly uses unixTimestampSeconds()
+                    // for the same proto field — WA's *Timestamp fields are unix-seconds,
+                    // so this was sending a timestamp ~1000x too large.
+                    labelTimestamp: unixTimestampSeconds() || Date.now()
                 }
             }
         }, {

package/lib/VoIP/worker-bootstrap.js

@@ -346,7 +346,7 @@ global.importScripts = function (...urls) {
             const code = fs.readFileSync(url, "utf8");
             eval(code);
         }
-        catch (e) { }
+        catch (e) { console.error(`[VoIP worker-bootstrap] importScripts failed for "${url}":`, e); }
     }
 };
 if (typeof global.location === "undefined") {
@@ -550,7 +550,7 @@ const resolveLoaderModule = () => {
                 return resolved;
             }
         }
-        catch (e) { }
+        catch (e) { console.error(`[VoIP worker-bootstrap] resolveLoaderModule failed for "${moduleName}":`, e); }
     }
     return null;
 };
@@ -621,7 +621,7 @@ global.self.WhatsAppVoipWasmWorkerCompatibleCallbacks = {
         try {
             e.postMessage(Object.assign({ type: "waWasmWorkerCompatibleCallback", __name: "loggingCallback" }, n));
         }
-        catch (err) { }
+        catch (err) { console.error("[VoIP worker-bootstrap] loggingCallback postMessage failed:", err); }
     },
     initCaptureDriverJS: function (n) {
         e.postMessage(Object.assign({ type: "waWasmWorkerCompatibleCallback", __name: "initCaptureDriverJS" }, n));
@@ -762,9 +762,9 @@ if (typedWorkerData && (typedWorkerData.loaderCode || typedWorkerData.workerModu
                 WAWebVoipJsWorkerMessageHandler = jsWorkerModule.default ?? jsWorkerModule;
             }
         }
-        catch (e) { }
+        catch (e) { console.error("[VoIP worker-bootstrap] WAWebVoipJsWorkerMessageHandler resolution failed:", e); }
     }
-    catch (e) { }
+    catch (e) { console.error("[VoIP worker-bootstrap] loaderCode block failed:", e); }
 }
 if (!wasmLoader) {
     const resourcesPath = typedWorkerData?.resourcesPath || path.join(__dirname, "wasm-resources");
@@ -780,7 +780,7 @@ if (!wasmLoader) {
             }
             wasmLoader = resolveLoaderModule();
         }
-        catch (e) { }
+        catch (e) { console.error(`[VoIP worker-bootstrap] failed to run loader.js from "${rsrcPath}":`, e); }
     }
 }
 let s = {};
@@ -936,7 +936,7 @@ function f(t) {
                     try {
                         yield WAWebVoipPersistentFS.initPersistentFS(_);
                     }
-                    catch (err) { }
+                    catch (err) { console.error("[VoIP worker-bootstrap] initPersistentFS failed:", err); }
                 }));
             }
             else {
@@ -1035,7 +1035,7 @@ e.addMessageListener("waWasmWorkerCompatibleCallback", function (msg) {
             global.self.WhatsAppVoipWasmWorkerCompatibleCallbacks[callbackName](args);
         }
     }
-    catch (err) { }
+    catch (err) { console.error("[VoIP worker-bootstrap] message handler failed:", err); }
 });
 if (parentPort) {
     parentPort.postMessage({ type: "worker_ready" });

package/lib/WABinary/generic-utils.js

@@ -160,7 +160,9 @@ const FLOWS_MAP = {
     // routed anything real; kept as a harmless alias in case any external caller
     // is still constructing a raw button object with the old (wrong) name.
     flow: true,
-    flow_action: true,
+    // Vanz@Fix (bug 68): removed duplicate `flow_action: true` key — already declared
+    // above (Vanzxy extended button types block); this was a leftover copy-paste dupe,
+    // harmless (same value) but confusing on re-read.
     // Vanz@Fix (single_select never renders alone) --- single_select must NEVER get
     // its own dedicated native_flow node here. WhatsApp only renders a single_select
     // button through the generic <native_flow v='9' name='mixed'> node — the same one

package/lib/index.js

@@ -8,6 +8,9 @@ export * from './WABinary/index.js';
 export * from './WAM/index.js';
 export * from './WAUSync/index.js';
 export { Dugong } from './Socket/dugong.js';
+// Vanz@Port --- Enterprise Bot Framework (Bot/Context/SessionManager/
+// StatsManager/MediaManager/SQLiteStore). See lib/Framework/index.js.
+export { Bot, Context, MediaManager, SessionManager, StatsManager, SQLiteStore } from './Framework/index.js';
 // Vanz@Add --- ported from ourin-baileys 9.0.11. Audio-only WhatsApp voice-call
 // handling (WASM call stack + WebRTC relay via optional `@roamhq/wrtc`). See
 // lib/VoIP/index.js for usage — instantiate VoipClient(sock) after connection.open.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanzxy/baileys",
-  "version": "1.6.7",
+  "version": "1.7.0",
   "description": "Enhanced Baileys fork by Vanzxy \u2014 based on @itsliaaa/baileys + @whiskeysockets/baileys with fixes for audio group status and clean media without newsletter button.",
   "type": "module",
   "main": "./lib/index.js",
@@ -34,39 +34,39 @@
     "NOTICE.md"
   ],
   "keywords": [
-  "vanzxy",
-  "vanzxybaileys",
-  "vanzxy-baileys",
-  "vanzxy-whatsapp",
-  "vanzxy-baileys-md",
-  "baileys-fork-vanzxy",
-  "baileys",
-  "baileys-md",
-  "baileys-multi-device",
-  "baileys-multidevice",
-  "baileys-whatsapp",
-  "baileys-whatsapp-api",
-  "baileys-whatsapp-bot",
-  "baileys-bot",
-  "baileys-api",
-  "baileys-library",
-  "baileys-node",
-  "baileys-nodejs",
-  "baileys-javascript",
-  "baileys-js",
-  "baileys-esm",
-  "baileys-fork",
-  "whatsapp-baileys",
-  "whatsapp-bot-baileys",
-  "whatsapp-api-baileys",
-  "whatsapp-web-baileys",
-  "whatsapp-multi-device",
-  "whatsapp-automation",
-  "whatsapp-bot",
-  "whatsapp-api",
-  "whatsapp-web",
-  "multi-device",
-  "interactive-messages"
+    "vanzxy",
+    "vanzxybaileys",
+    "vanzxy-baileys",
+    "vanzxy-whatsapp",
+    "vanzxy-baileys-md",
+    "baileys-fork-vanzxy",
+    "baileys",
+    "baileys-md",
+    "baileys-multi-device",
+    "baileys-multidevice",
+    "baileys-whatsapp",
+    "baileys-whatsapp-api",
+    "baileys-whatsapp-bot",
+    "baileys-bot",
+    "baileys-api",
+    "baileys-library",
+    "baileys-node",
+    "baileys-nodejs",
+    "baileys-javascript",
+    "baileys-js",
+    "baileys-esm",
+    "baileys-fork",
+    "whatsapp-baileys",
+    "whatsapp-bot-baileys",
+    "whatsapp-api-baileys",
+    "whatsapp-web-baileys",
+    "whatsapp-multi-device",
+    "whatsapp-automation",
+    "whatsapp-bot",
+    "whatsapp-api",
+    "whatsapp-web",
+    "multi-device",
+    "interactive-messages"
   ],
   "homepage": "https://github.com/vanzxysenpai/vanzxybaileys#readme",
   "author": "Vanzxy",
@@ -98,7 +98,8 @@
     "mongodb": "^6.10.0",
     "mysql2": "^3.11.0",
     "pg": "^8.13.0",
-    "sharp": "*"
+    "sharp": "*",
+    "node-webpmux": "^3.2.0"
   },
   "peerDependenciesMeta": {
     "@napi-rs/image": {
@@ -133,6 +134,9 @@
     },
     "pg": {
       "optional": true
+    },
+    "node-webpmux": {
+      "optional": true
     }
   },
   "resolutions": {