@oxidezap/baileyrs 0.1.0 → 0.1.2

package/lib/Socket/chat-actions.js

@@ -1,89 +1,177 @@
-export const makeChatActionMethods = (ctx) => ({
-    pinChat: async (jid, pin) => {
-        await (await ctx.getClient()).pinChat(jid, pin);
-    },
-    muteChat: async (jid, muteUntil) => {
-        await (await ctx.getClient()).muteChat(jid, muteUntil);
-    },
-    archiveChat: async (jid, archive) => {
-        await (await ctx.getClient()).archiveChat(jid, archive);
-    },
-    starMessage: async (jid, messageId, star) => {
-        await (await ctx.getClient()).starMessage(jid, messageId, star);
-    },
-    /**
-     * Compatibility wrapper for original Baileys chatModify API.
-     * Routes to the appropriate bridge method based on the modification type.
-     *
-     * Fully supported: archive, pin, mute, star, markRead, delete, deleteForMe, pushNameSetting, contact, clear
-     * Not yet in bridge (app-state patches): disableLinkPreviews, labels, quickReply
-     */
-    chatModify: async (mod, jid) => {
-        const client = await ctx.getClient();
-        if ('archive' in mod) {
-            await client.archiveChat(jid, mod.archive);
-        }
-        else if ('pin' in mod) {
-            await client.pinChat(jid, mod.pin);
-        }
-        else if ('mute' in mod) {
-            await client.muteChat(jid, mod.mute);
-        }
-        else if ('star' in mod) {
-            for (const msg of mod.star.messages) {
-                await client.starMessage(jid, msg.id, mod.star.star);
+import { Boom } from '../Utils/boom.js';
+/**
+ * Refuse a field the mutation carries but the wire call cannot. Dropping it
+ * would report success for a change that never happened, which is the failure
+ * this whole path exists to stop.
+ */
+const rejectUnsupportedFields = (where, value, fields) => {
+    const present = fields.filter(field => value[field] != null);
+    if (present.length) {
+        throw new Boom(`${where}: ${present.join(', ')} cannot be set through this client`, {
+            statusCode: 400,
+            data: { fields: present }
+        });
+    }
+};
+export const makeChatActionMethods = (ctx) => {
+    const methods = {
+        pinChat: async (jid, pin) => {
+            await (await ctx.getClient()).pinChat(jid, pin);
+        },
+        muteChat: async (jid, muteUntil) => {
+            await (await ctx.getClient()).muteChat(jid, muteUntil);
+        },
+        archiveChat: async (jid, archive) => {
+            await (await ctx.getClient()).archiveChat(jid, archive);
+        },
+        starMessage: async (jid, messageId, star) => {
+            await (await ctx.getClient()).starMessage(jid, messageId, star);
+        },
+        /**
+         * Compatibility wrapper for original Baileys chatModify API.
+         * Routes to the appropriate bridge method based on the modification type.
+         *
+         * Every variant either runs or throws. A variant that resolved without
+         * doing anything told the caller their chat was labelled when nothing was
+         * synced, and no signature or type catches that.
+         */
+        chatModify: async (mod, jid) => {
+            const client = await ctx.getClient();
+            if ('archive' in mod) {
+                await client.archiveChat(jid, mod.archive);
             }
-        }
-        else if ('markRead' in mod) {
-            await client.markChatAsRead(jid, mod.markRead);
-        }
-        else if ('delete' in mod) {
-            await client.deleteChat(jid);
-        }
-        else if ('deleteForMe' in mod) {
-            await client.deleteMessageForMe(jid, mod.deleteForMe.key.id, !!mod.deleteForMe.key.fromMe);
-        }
-        else if ('pushNameSetting' in mod) {
-            await client.setPushName(mod.pushNameSetting);
-        }
-        else if ('contact' in mod) {
-            // Save/rename a contact (syncs the name to linked devices). `jid` is the
-            // contact's bare PN jid.
-            if (mod.contact) {
-                await client.saveContact(jid, mod.contact.fullName ?? undefined, mod.contact.firstName ?? undefined, mod.contact.saveOnPrimaryAddressbook ?? true);
+            else if ('pin' in mod) {
+                await client.pinChat(jid, mod.pin);
             }
-            else {
-                // `contact: null` = remove-contact in upstream Baileys; no
-                // bridge/core path yet — warn instead of silently dropping.
-                ctx.logger.warn({ jid }, 'chatModify: contact removal (contact: null) not yet supported by bridge');
+            else if ('mute' in mod) {
+                await client.muteChat(jid, mod.mute);
             }
-        }
-        else if ('clear' in mod) {
-            // Clear a chat's messages while keeping the chat. `lastMessages` (the
-            // message range) is ignored, same as the `delete` branch — the bridge
-            // clears the whole chat. deleteStarred/deleteMedia aren't part of the
-            // Baileys `clear` shape, so default both to false (keep starred + media).
-            if (mod.clear) {
-                await client.clearChat(jid, false, false);
+            else if ('star' in mod) {
+                for (const msg of mod.star.messages) {
+                    await client.starMessage(jid, msg.id, mod.star.star);
+                }
             }
+            else if ('markRead' in mod) {
+                await client.markChatAsRead(jid, mod.markRead);
+            }
+            else if ('delete' in mod) {
+                await client.deleteChat(jid);
+            }
+            else if ('deleteForMe' in mod) {
+                await client.deleteMessageForMe(jid, mod.deleteForMe.key.id, !!mod.deleteForMe.key.fromMe);
+            }
+            else if ('pushNameSetting' in mod) {
+                await client.setPushName(mod.pushNameSetting);
+            }
+            else if ('contact' in mod) {
+                // Save/rename a contact (syncs the name to linked devices). `jid` is the
+                // contact's bare PN jid.
+                if (mod.contact) {
+                    rejectUnsupportedFields('chatModify contact', mod.contact, ['lidJid', 'pnJid', 'username']);
+                    await client.saveContact(jid, mod.contact.fullName ?? undefined, mod.contact.firstName ?? undefined, mod.contact.saveOnPrimaryAddressbook ?? true);
+                }
+                else {
+                    // Its own method, not `saveContact` with empty fields: removal is
+                    // the one contact mutation the wire models as a `Remove`, and a
+                    // `Set` carrying empty values renames the contact to "".
+                    await client.removeContact(jid);
+                }
+            }
+            else if ('clear' in mod) {
+                // Clear a chat's messages while keeping the chat. `lastMessages` (the
+                // message range) is ignored, same as the `delete` branch — the bridge
+                // clears the whole chat. deleteStarred/deleteMedia aren't part of the
+                // Baileys `clear` shape, so default both to false (keep starred + media).
+                if (mod.clear) {
+                    await client.clearChat(jid, false, false);
+                }
+            }
+            else if ('disableLinkPreviews' in mod) {
+                await client.setLinkPreviewsDisabled(mod.disableLinkPreviews.isPreviewsDisabled ?? false);
+            }
+            else if ('addLabel' in mod) {
+                // One upstream variant, two wire actions: an edit carrying
+                // `deleted` is the delete, not a separate modification.
+                if (mod.addLabel.deleted) {
+                    await client.deleteLabel(mod.addLabel.id);
+                }
+                else {
+                    rejectUnsupportedFields('chatModify addLabel', mod.addLabel, ['predefinedId']);
+                    // The mutation replaces the whole label, so a missing field is
+                    // not "leave it alone", it is "set it to nothing". Upstream can
+                    // omit one because it builds the proto directly; this call
+                    // cannot, so both are required rather than defaulted.
+                    if (mod.addLabel.name === undefined || mod.addLabel.color === undefined) {
+                        throw new Boom('chatModify addLabel: name and color are both required, because the label mutation is a full replace and an omitted field would reset it', { statusCode: 400 });
+                    }
+                    await client.createLabel(mod.addLabel.id, mod.addLabel.name, mod.addLabel.color);
+                }
+            }
+            else if ('addChatLabel' in mod) {
+                await client.addChatLabel(mod.addChatLabel.labelId, jid);
+            }
+            else if ('removeChatLabel' in mod) {
+                await client.removeChatLabel(mod.removeChatLabel.labelId, jid);
+            }
+            else if ('addMessageLabel' in mod) {
+                await client.addMessageLabel(mod.addMessageLabel.labelId, jid, mod.addMessageLabel.messageId);
+            }
+            else if ('removeMessageLabel' in mod) {
+                await client.removeMessageLabel(mod.removeMessageLabel.labelId, jid, mod.removeMessageLabel.messageId);
+            }
+            else if ('quickReply' in mod) {
+                // Upstream's `timestamp` is the app-state index key, the same slot
+                // the core calls `id`. Deleting is the same upsert with `deleted`.
+                // `||`, not `??`: upstream treats an empty timestamp as absent and
+                // mints a key, and the core rejects an empty index outright.
+                const id = mod.quickReply.timestamp || String(Math.floor(Date.now() / 1000));
+                if (mod.quickReply.deleted) {
+                    await client.deleteQuickReply(id);
+                }
+                else {
+                    await client.setQuickReply(id, mod.quickReply.shortcut ?? '', mod.quickReply.message ?? '', mod.quickReply.keywords ?? [], mod.quickReply.count ?? 0);
+                }
+            }
+            else {
+                const variant = Object.keys(mod)[0] ?? '(empty)';
+                throw new Boom(`chatModify: unsupported modification '${variant}'`, { statusCode: 400, data: { variant, jid } });
+            }
+        },
+        // Upstream models all of these as sugar over `chatModify`, and so do we:
+        // one place decides which bridge call a modification becomes, so the
+        // method and the modification can never disagree.
+        addOrEditContact: async (jid, contact) => {
+            await methods.chatModify({ contact }, jid);
+        },
+        removeContact: async (jid) => {
+            await methods.chatModify({ contact: null }, jid);
+        },
+        addLabel: async (jid, labels) => {
+            await methods.chatModify({ addLabel: { ...labels } }, jid);
+        },
+        addChatLabel: async (jid, labelId) => {
+            await methods.chatModify({ addChatLabel: { labelId } }, jid);
+        },
+        removeChatLabel: async (jid, labelId) => {
+            await methods.chatModify({ removeChatLabel: { labelId } }, jid);
+        },
+        addMessageLabel: async (jid, messageId, labelId) => {
+            await methods.chatModify({ addMessageLabel: { labelId, messageId } }, jid);
+        },
+        removeMessageLabel: async (jid, messageId, labelId) => {
+            await methods.chatModify({ removeMessageLabel: { labelId, messageId } }, jid);
+        },
+        star: async (jid, messages, star) => {
+            await methods.chatModify({ star: { messages, star } }, jid);
+        },
+        // No jid: a quick reply is account-wide, keyed only by its index.
+        addOrEditQuickReply: async (quickReply) => {
+            await methods.chatModify({ quickReply }, '');
+        },
+        removeQuickReply: async (timestamp) => {
+            await methods.chatModify({ quickReply: { timestamp, deleted: true } }, '');
         }
-        else {
-            // App-state-patch variants not yet exposed by bridge:
-            // disableLinkPreviews, addLabel, addChatLabel,
-            // removeChatLabel, addMessageLabel, removeMessageLabel, quickReply
-            const variant = Object.keys(mod)[0];
-            ctx.logger.warn({ variant, jid }, 'chatModify: variant requires app-state patch support not yet available in bridge');
-        }
-    },
-    /**
-     * Force re-sync of app state collections.
-     *
-     * In the Rust bridge architecture, app state is managed internally by the engine
-     * and synced automatically on connect. This method is a no-op provided for API
-     * compatibility with upstream Baileys.
-     */
-    resyncAppState: async (_collections, _isInitialSync) => {
-        ctx.logger.info('resyncAppState: app state is synced automatically by the Rust bridge');
-    }
-});
+    };
+    return methods;
+};
 //# sourceMappingURL=chat-actions.js.map

package/lib/Socket/events.js

@@ -813,7 +813,7 @@ const dispatchCanonicalEvent = (canonical, dispatchCtx) => {
     }
     catch (err) {
         // One bad event must not poison the rest of the pipeline.
-        dispatchCtx.ctx.logger.error({ err, type: canonical.type }, 'dispatcher threw — dropping event');
+        dispatchCtx.ctx.reportUnexpectedError(err, `dispatching a '${canonical.type}' event`);
     }
 };
 /** Aggregate adjacent ordinary messages while preserving every side-effecting
@@ -852,7 +852,7 @@ const dispatchCanonicalBatch = (ctx, dispatchCtx, count, canonicalAt) => {
             }
         }
         catch (err) {
-            ctx.logger.error({ err, type: CANONICAL_MESSAGE_EVENT }, 'dispatcher threw — dropping event');
+            ctx.reportUnexpectedError(err, `dispatching a '${CANONICAL_MESSAGE_EVENT}' event`);
         }
     }
     if (pending)
@@ -884,7 +884,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             view = decodeMessageWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode the message wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the message wire batch');
             return;
         }
         const { messageData, messageOffsets, infos } = view;
@@ -923,7 +923,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             receipts = decodeReceiptWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode receipt wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the receipt wire batch');
             return;
         }
         // The decoded payload matches the single-event wire shape; the union's
@@ -937,7 +937,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             acks = decodeServerAckWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode server-ack wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the server-ack wire batch');
             return;
         }
         for (const data of acks)

package/lib/Socket/index.d.ts

@@ -2,7 +2,7 @@ import { Buffer } from 'node:buffer';
 import { type UploadMediaResult } from '@oxidezap/whatsapp-rust-bridge';
 import { WebSocketClient } from '../Compatibility/websocket-client.js';
 import { type MediaType } from '../Defaults/index.js';
-import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WAPrivacyGroupAddValue, WAPrivacyOnlineValue, WAPrivacyValue, WABusinessProfile, WAReadReceiptsValue, WAMessage, WAMessageKey } from '../Types/index.js';
+import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WABusinessProfile, WAMessage, WAMessageKey } from '../Types/index.js';
 import type Long from 'long';
 import type { MediaDownloadOptions } from '../Utils/messages-media.js';
 import type { proto } from '../WAProto/runtime.js';
@@ -12,12 +12,33 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     updateBlockStatus: (jid: string, action: 'block' | 'unblock') => Promise<void>;
     fetchBlocklist: () => Promise<Array<string | undefined>>;
+    getCatalog: ({ jid, limit, cursor }: import("../index.js").GetCatalogOptions) => Promise<import("../index.js").CatalogPage>;
+    getCollections: (jid?: string, limit?: number) => Promise<import("../index.js").CollectionsPage>;
+    getOrderDetails: (orderId: string, tokenBase64: string, sellerJid?: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").OrderResult>;
+    updateBussinesProfile: (args: import("../Types/Bussines.js").UpdateBussinesProfileProps) => Promise<void>;
+    updateCoverPhoto: (photo: import("../index.js").WAMediaUpload) => Promise<never>;
+    removeCoverPhoto: (id: string) => Promise<void>;
+    productCreate: (create: import("../index.js").ProductCreate) => Promise<never>;
+    productUpdate: (productId: string, update: import("../index.js").ProductUpdate) => Promise<never>;
+    productDelete: (productIds: string[]) => Promise<never>;
     pinChat: (jid: string, pin: boolean) => Promise<void>;
     muteChat: (jid: string, muteUntil?: number | null) => Promise<void>;
     archiveChat: (jid: string, archive: boolean) => Promise<void>;
     starMessage: (jid: string, messageId: string, star: boolean) => Promise<void>;
     chatModify: (mod: import("../index.js").ChatModification, jid: string) => Promise<void>;
-    resyncAppState: (_collections?: readonly import("../index.js").WAPatchName[], _isInitialSync?: boolean) => Promise<void>;
+    addOrEditContact: (jid: string, contact: proto.SyncActionValue.IContactAction) => Promise<void>;
+    removeContact: (jid: string) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean;
+    }[], star: boolean) => Promise<void>;
+    addOrEditQuickReply: (quickReply: import("../Types/Bussines.js").QuickReplyAction) => Promise<void>;
+    removeQuickReply: (timestamp: string) => Promise<void>;
     onWhatsApp: (...phoneNumber: string[]) => Promise<import("./contacts.js").OnWhatsAppResult[] | undefined>;
     profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
     fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
@@ -74,6 +95,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     communityMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
     communityJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
     communityFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
+    waitForSocketOpen: () => Promise<void>;
+    upsertMessage: (msg: WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
+    onUnexpectedError: (err: Error, msg: string) => void;
+    resyncAppState: (collections?: readonly ('critical_block' | 'critical_unblock_low' | 'regular_high' | 'regular_low' | 'regular')[], isInitialSync?: boolean) => Promise<void>;
+    updateServerTimeOffset: (node: BinaryNode) => never;
+    sendUnifiedSession: () => Promise<never>;
+    appPatch: (patchCreate: import("../index.js").WAPatchCreate) => Promise<never>;
+    messageRetryManager: null;
     sendMessage: (jid: string, content: import("../index.js").AnyMessageContent, options?: Omit<import("../index.js").MessageGenerationOptions, 'waClient' | 'logger' | 'userJid' | 'mediaInNote'>) => Promise<WAMessage>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;
     relayMessage: (jid: string, message: proto.IMessage, options: import("../index.js").MessageRelayOptions) => Promise<string>;
@@ -81,12 +110,31 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../index.js").MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: WAMessageKey[], type: import("../index.js").MessageReceiptType) => Promise<void>;
     requestPlaceholderResend: (messageKey: WAMessageKey, msgData?: Partial<WAMessage>) => Promise<string | undefined>;
-    newsletterCreate: (name: string, description?: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterMetadata: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<import("../index.js").NewsletterMetadata | null>;
+    newsletterUpdate: (jid: string, updates: import("../index.js").NewsletterUpdate) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdatePicture: (jid: string, content: import("../index.js").WAMediaUpload) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterRemovePicture: (jid: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterFollow: (jid: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
     newsletterSubscribe: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
     newsletterUnsubscribe: (jid: string) => Promise<void>;
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
     newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
-    newsletterMute: (jid: string, mute: boolean) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since?: number, after?: number) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMessageResult[]>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
@@ -94,6 +142,30 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
     sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    fetchPrivacySettings: (force?: boolean) => Promise<any>;
+    updatePrivacySetting: (category: string, value: string) => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../index.js").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../index.js").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../index.js").WAPrivacyGroupAddValue) => Promise<void>;
+    updateCallPrivacy: (value: import("../index.js").WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: import("../index.js").WAPrivacyMessagesValue) => Promise<void>;
+    issuePrivacyTokens: (jids: string[], timestamp?: number) => Promise<void>;
+    refreshMediaConn: (forceGet?: boolean) => Promise<Omit<import("../index.js").MediaConnInfo, 'hosts'> & {
+        hosts: {
+            hostname: string;
+        }[];
+    }>;
+    getMediaHost: () => string;
+    getBotListV2: () => Promise<import("../index.js").BotListInfo[]>;
+    fetchNewChatMessageCap: () => Promise<import("../index.js").NewChatMessageCapInfo & {
+        remaining_quota?: number;
+    }>;
+    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    sendPeerDataOperationMessage: (_pdoMessage: unknown) => Promise<never>;
+    createCallLink: (_type: 'audio' | 'video', _event?: unknown, _timeoutMs?: number) => Promise<never>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
     setPushName: (name: string) => Promise<void>;
     updateProfileName: (name: string) => Promise<void>;
@@ -176,7 +248,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
     query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
-    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode['attrs']) => Promise<{
+    /**
+     * `dsmMessage` is accepted so the signature matches upstream, and
+     * refused rather than ignored. Upstream uses it to encrypt a different
+     * plaintext for the caller's own other devices; the engine encrypts one
+     * payload for every recipient, so honouring it is not possible here and
+     * dropping it would send those devices the wrong message.
+     */
+    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode['attrs'], dsmMessage?: proto.IMessage) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
@@ -203,14 +282,6 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     waUploadToServer: (data: Uint8Array | Buffer, opts: {
         mediaType: MediaType;
     }) => Promise<UploadMediaResult>;
-    fetchPrivacySettings: (force?: boolean) => Promise<any>;
-    updatePrivacySetting: (category: string, value: string) => Promise<void>;
-    updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateOnlinePrivacy: (value: WAPrivacyOnlineValue) => Promise<void>;
-    updateProfilePicturePrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateStatusPrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateReadReceiptsPrivacy: (value: WAReadReceiptsValue) => Promise<void>;
-    updateGroupsAddPrivacy: (value: WAPrivacyGroupAddValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     /**

package/lib/Socket/index.js

@@ -21,6 +21,7 @@ import { makeNativeCryptoProvider } from '../Utils/native-crypto-provider.js';
 import { wrapLegacyStore } from '../Utils/wrap-legacy-store.js';
 import { assertNodeErrorFree } from '../WABinary/generic-utils.js';
 import { makeBlockingMethods } from './blocking.js';
+import { makeBusinessMethods } from './business.js';
 import { makeChatActionMethods } from './chat-actions.js';
 import { makeContactMethods } from './contacts.js';
 import { makeCommunityMethods } from './communities.js';
@@ -28,10 +29,13 @@ import { makeBridgeClientOwner } from './bridge-client-owner.js';
 import { makeTerminalCloseReporter } from './terminal-close-reporter.js';
 import { makeEventHandlers } from './events.js';
 import { makeGroupMethods } from './groups.js';
+import { makeInternalMethods, makeUnexpectedErrorReporter } from './internals.js';
 import { makeMessageMethods } from './messages.js';
 import { makeNewsletterMethods } from './newsletter.js';
 import { makePreKeyMethods } from './prekeys.js';
 import { makePresenceMethods } from './presence.js';
+import { makePrivacyMethods } from './privacy.js';
+import { makeServerQueryMethods } from './server-queries.js';
 import { makeProfileMethods } from './profile.js';
 import { mapReachoutTimelock } from './reachout.js';
 import { makeHttpClient, makeTransport } from './transport.js';
@@ -249,11 +253,18 @@ const makeWASocket = (config) => {
     let autoReconnectEnabled = true;
     /** Owns reporting the terminal close: once, after teardown, never not at all. */
     const terminalClose = makeTerminalCloseReporter({ logger });
+    /**
+     * Held in a reporter rather than captured, because `sock.onUnexpectedError`
+     * is an assignable property: a consumer that replaces it has to be the one
+     * the socket's own failure paths reach afterwards.
+     */
+    const unexpectedErrors = makeUnexpectedErrorReporter(logger);
     const ctx = {
         ev,
         logger,
         fullConfig,
         ws,
+        reportUnexpectedError: unexpectedErrors.report,
         getUser: () => user,
         getMe: () => {
             const me = auth.creds.me;
@@ -783,7 +794,17 @@ const makeWASocket = (config) => {
         sendRawMessage: async (data) => {
             return (await ctx.getClient()).sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data));
         },
-        createParticipantNodes: async (jids, message, extraAttrs) => {
+        /**
+         * `dsmMessage` is accepted so the signature matches upstream, and
+         * refused rather than ignored. Upstream uses it to encrypt a different
+         * plaintext for the caller's own other devices; the engine encrypts one
+         * payload for every recipient, so honouring it is not possible here and
+         * dropping it would send those devices the wrong message.
+         */
+        createParticipantNodes: async (jids, message, extraAttrs, dsmMessage) => {
+            if (dsmMessage) {
+                throw new Boom('createParticipantNodes: dsmMessage is not supported, the engine encrypts one payload for every recipient and cannot substitute a different one for your own devices', { statusCode: 501 });
+            }
             const bytes = encodeProto('Message', message);
             return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
         },
@@ -826,31 +847,7 @@ const makeWASocket = (config) => {
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
             return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
         },
-        fetchPrivacySettings: async (force) => {
-            void force;
-            return (await ctx.getClient()).fetchPrivacySettings();
-        },
-        updatePrivacySetting: async (category, value) => {
-            await (await ctx.getClient()).updatePrivacySetting(category, value);
-        },
-        updateLastSeenPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('last', value);
-        },
-        updateOnlinePrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('online', value);
-        },
-        updateProfilePicturePrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('profile', value);
-        },
-        updateStatusPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('status', value);
-        },
-        updateReadReceiptsPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
-        },
-        updateGroupsAddPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
-        },
+        ...makePrivacyMethods(ctx),
         updateDefaultDisappearingMode: async (duration) => {
             await (await ctx.getClient()).updateDefaultDisappearingMode(duration);
         },
@@ -891,11 +888,14 @@ const makeWASocket = (config) => {
         ...makeContactMethods(ctx),
         ...makeProfileMethods(ctx),
         ...makeChatActionMethods(ctx),
+        ...makeInternalMethods(ctx),
         ...usyncMethods,
         ...makeStanzaResponseMethods(ctx),
         ...makePresenceMethods(ctx),
         ...makeBlockingMethods(ctx),
         ...makeNewsletterMethods(ctx),
+        ...makeBusinessMethods(ctx),
+        ...makeServerQueryMethods(ctx),
         downloadMedia: async (message, type, options = {}) => {
             return downloadMediaMessage(message, type, options, {
                 logger,
@@ -904,6 +904,16 @@ const makeWASocket = (config) => {
             });
         }
     };
+    // Assigning replaces the handler the socket itself reports through, rather
+    // than shadowing it with a second one only a consumer could reach.
+    Object.defineProperty(sock, 'onUnexpectedError', {
+        get: () => unexpectedErrors.handler,
+        set: (handler) => {
+            unexpectedErrors.handler = handler;
+        },
+        enumerable: true,
+        configurable: true
+    });
     return sock;
 };
 export default makeWASocket;