@oxidezap/baileyrs 0.2.12 → 0.3.0

package/lib/Socket/chat-actions.js

@@ -16,16 +16,16 @@ const rejectUnsupportedFields = (where, value, fields) => {
 export const makeChatActionMethods = (ctx) => {
     const methods = {
         pinChat: async (jid, pin) => {
-            await (await ctx.getClient()).pinChat(jid, pin);
+            await ctx.withClient(client => client.pinChat(jid, pin));
         },
         muteChat: async (jid, muteUntil) => {
-            await (await ctx.getClient()).muteChat(jid, muteUntil);
+            await ctx.withClient(client => client.muteChat(jid, muteUntil));
         },
         archiveChat: async (jid, archive) => {
-            await (await ctx.getClient()).archiveChat(jid, archive);
+            await ctx.withClient(client => client.archiveChat(jid, archive));
         },
         starMessage: async (jid, messageId, star) => {
-            await (await ctx.getClient()).starMessage(jid, messageId, star);
+            await ctx.withClient(client => client.starMessage(jid, messageId, star));
         },
         /**
          * Compatibility wrapper for original Baileys chatModify API.
@@ -36,106 +36,110 @@ export const makeChatActionMethods = (ctx) => {
          * 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 ('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);
-                }
-            }
-            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);
+            return ctx.withClient(async (client) => {
+                if ('archive' in mod) {
+                    await client.archiveChat(jid, mod.archive);
                 }
-                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 if ('pin' in mod) {
+                    await client.pinChat(jid, mod.pin);
                 }
-                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 });
+                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);
+                    }
+                }
+                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);
                     }
-                    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);
+                    const variant = Object.keys(mod)[0] ?? '(empty)';
+                    throw new Boom(`chatModify: unsupported modification '${variant}'`, {
+                        statusCode: 400,
+                        data: { variant, jid }
+                    });
                 }
-            }
-            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

package/lib/Socket/client-operations.d.ts

@@ -0,0 +1,6 @@
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
+export interface ClientOperations<Client = WasmWhatsAppClient> {
+    withClient<T>(operation: (client: Client) => T | Promise<T>): Promise<T>;
+}
+export declare const makeWithClient: <Client>(getClient: () => Promise<Client>) => ClientOperations<Client>['withClient'];
+//# sourceMappingURL=client-operations.d.ts.map

package/lib/Socket/client-operations.js

@@ -0,0 +1,2 @@
+export const makeWithClient = (getClient) => async (operation) => operation(await getClient());
+//# sourceMappingURL=client-operations.js.map

package/lib/Socket/communities.js

@@ -6,7 +6,7 @@ import { GROUP_REQUEST_ACTIONS, GROUP_SETTINGS, JOIN_APPROVAL_MODES, makeGroupMe
 export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
     const communityMetadata = async (jid) => groups.groupMetadata(jid);
     const communityFetchAllParticipating = async () => {
-        const bridgeCommunities = await (await ctx.getClient()).communityFetchAllParticipating();
+        const bridgeCommunities = await ctx.withClient(client => client.communityFetchAllParticipating());
         const result = {};
         for (const [communityJid, metadata] of Object.entries(bridgeCommunities)) {
             result[communityJid] = bridgeGroupMetadataToBaileys(metadata);
@@ -17,30 +17,30 @@ export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
     return {
         communityMetadata,
         communityCreate: async (subject, body) => {
-            const metadata = await (await ctx.getClient()).createCommunity(subject, body || undefined, true, true, true);
+            const metadata = await ctx.withClient(client => client.createCommunity(subject, body || undefined, true, true, true));
             return bridgeGroupMetadataToBaileys(metadata);
         },
         communityCreateGroup: async (subject, participants, parentCommunityJid) => {
-            const metadata = await (await ctx.getClient()).createCommunitySubgroup(subject, participants, parentCommunityJid);
+            const metadata = await ctx.withClient(client => client.createCommunitySubgroup(subject, participants, parentCommunityJid));
             return bridgeGroupMetadataToBaileys(metadata);
         },
         communityLeave: async (id) => {
-            await (await ctx.getClient()).deactivateCommunity(id);
+            await ctx.withClient(client => client.deactivateCommunity(id));
         },
         communityUpdateSubject: async (jid, subject) => {
             await groups.groupUpdateSubject(jid, subject);
         },
         communityLinkGroup: async (groupJid, parentCommunityJid) => {
-            await (await ctx.getClient()).linkCommunitySubgroups(parentCommunityJid, [groupJid]);
+            await ctx.withClient(client => client.linkCommunitySubgroups(parentCommunityJid, [groupJid]));
         },
         communityUnlinkGroup: async (groupJid, parentCommunityJid) => {
-            await (await ctx.getClient()).unlinkCommunitySubgroups(parentCommunityJid, [groupJid], false);
+            await ctx.withClient(client => client.unlinkCommunitySubgroups(parentCommunityJid, [groupJid], false));
         },
         communityFetchLinkedGroups: async (jid) => {
             const metadata = await groups.groupMetadata(jid);
             const communityJid = metadata.linkedParent || jid;
             const isCommunity = !metadata.linkedParent;
-            const subgroups = await (await ctx.getClient()).getCommunitySubgroups(communityJid);
+            const subgroups = await ctx.withClient(client => client.getCommunitySubgroups(communityJid));
             const linkedGroups = subgroups.map(group => ({
                 id: group.id,
                 subject: group.subject,
@@ -61,7 +61,7 @@ export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
         },
         communityParticipantsUpdate: async (jid, participants, action) => {
             assertArgumentDomain('communityParticipantsUpdate', 'action', action, PARTICIPANT_ACTIONS);
-            return bridgeParticipantChangesToBaileys(await (await ctx.getClient()).communityParticipantsUpdate(jid, participants, action));
+            return bridgeParticipantChangesToBaileys(await ctx.withClient(client => client.communityParticipantsUpdate(jid, participants, action)));
         },
         communityUpdateDescription: groups.groupUpdateDescription,
         communityInviteCode: groups.groupInviteCode,

package/lib/Socket/contacts.js

@@ -1,29 +1,32 @@
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const PROFILE_PICTURE_TYPES = ['preview', 'image'];
-export const makeContactMethods = (ctx) => ({
-    onWhatsApp: async (...phoneNumber) => {
-        const client = await ctx.getClient();
-        // Single batched usync — the bridge splits PN/LID inputs internally and
-        // returns lid/pnJid/isBusiness in the same payload, so no secondary IQ.
-        const results = await client.isOnWhatsApp(phoneNumber);
-        return results.map(r => {
-            const out = { exists: r.isRegistered, jid: r.jid, isBusiness: r.isBusiness };
-            if (r.lid)
-                out.lid = r.lid;
-            if (r.pnJid)
-                out.pnJid = r.pnJid;
-            if (r.verifiedName)
-                out.verifiedName = r.verifiedName;
-            return out;
-        });
-    },
-    profilePictureUrl: async (jid, type = 'preview', timeoutMs) => {
-        assertArgumentDomain('profilePictureUrl', 'type', type, PROFILE_PICTURE_TYPES);
-        const result = await (await ctx.getClient()).profilePictureUrl(jid, type, timeoutMs);
-        return result?.url;
-    },
-    fetchUserInfo: async (...jids) => {
-        return await (await ctx.getClient()).fetchUserInfo(jids);
-    }
-});
+export const makeContactMethods = (ctx) => {
+    return {
+        onWhatsApp: async (...phoneNumber) => {
+            return ctx.withClient(async (client) => {
+                // Single batched usync — the bridge splits PN/LID inputs internally and
+                // returns lid/pnJid/isBusiness in the same payload, so no secondary IQ.
+                const results = await client.isOnWhatsApp(phoneNumber);
+                return results.map(r => {
+                    const out = { exists: r.isRegistered, jid: r.jid, isBusiness: r.isBusiness };
+                    if (r.lid)
+                        out.lid = r.lid;
+                    if (r.pnJid)
+                        out.pnJid = r.pnJid;
+                    if (r.verifiedName)
+                        out.verifiedName = r.verifiedName;
+                    return out;
+                });
+            });
+        },
+        profilePictureUrl: async (jid, type = 'preview', timeoutMs) => {
+            assertArgumentDomain('profilePictureUrl', 'type', type, PROFILE_PICTURE_TYPES);
+            const result = await ctx.withClient(client => client.profilePictureUrl(jid, type, timeoutMs));
+            return result?.url;
+        },
+        fetchUserInfo: async (...jids) => {
+            return await ctx.withClient(client => client.fetchUserInfo(jids));
+        }
+    };
+};
 //# sourceMappingURL=contacts.js.map

package/lib/Socket/events.js

@@ -22,7 +22,7 @@ import { buildGroupCreateStubMessage, buildGroupJoinRequestEvents, buildGroupNot
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
 import { extractMessageCappingPayload } from './message-capping.js';
 import { mapReachoutTimelock } from './reachout.js';
-import { isReconnectableConnectFailure } from './terminal-close.js';
+import { isReconnectableConnectFailure, mapConnectFailureToDisconnect } from './terminal-close.js';
 const CANONICAL_MESSAGE_EVENT = 'message';
 const MESSAGE_UPSERT_APPEND = 'append';
 const MESSAGE_UPSERT_NOTIFY = 'notify';
@@ -191,41 +191,6 @@ const emitRetrying = (ctx) => ctx.ev.emit('connection.update', {
  * dispatcher for why `badSession` was the wrong home.
  */
 const CLIENT_OUTDATED_STATUS = 405;
-/**
- * Map bridge `ConnectFailureReason` wire codes (per the bridge's
- * `.d.ts` annotation) onto upstream Baileys' `DisconnectReason`.
- * Unknown codes fall through to `connectionClosed` so existing
- * reconnect heuristics keep working.
- *
- * Several cases here are belt-and-braces: the engine dispatches its own event
- * for `is_logged_out()` reasons (401/403/406) and for 405, so those never
- * reach `connectFailure` in practice. Kept because they cost nothing and the
- * engine's routing is not ours to depend on.
- */
-const mapConnectFailureToDisconnect = (reason) => {
-    switch (reason) {
-        case 401: // LoggedOut
-        case 403: // MainDeviceGone
-        case 406: // UnknownLogout
-            return DisconnectReason.loggedOut;
-        case 402: // TempBanned
-            return DisconnectReason.forbidden;
-        case 405: // ClientOutdated
-            return CLIENT_OUTDATED_STATUS;
-        case 411: // MultideviceMismatch (legacy alias)
-            return DisconnectReason.multideviceMismatch;
-        case 503: // ServiceUnavailable
-        case 501: // Experimental
-            return DisconnectReason.unavailableService;
-        case 408: // Timed out
-            return DisconnectReason.timedOut;
-        case 515: // RestartRequired
-            return DisconnectReason.restartRequired;
-        // 400, 409, 413, 414, 415, 418, 500, undefined → generic close
-        default:
-            return DisconnectReason.connectionClosed;
-    }
-};
 const describeTempBan = (code) => {
     switch (code) {
         case 101:
@@ -581,7 +546,7 @@ const DISPATCHERS = {
             // the same complete lifecycle and ordering as upstream.
             void (async () => {
                 try {
-                    const bridgeMetadata = await (await ctx.getClient()).getGroupMetadata(evt.groupJid);
+                    const bridgeMetadata = await ctx.withClient(client => client.getGroupMetadata(evt.groupJid));
                     const metadata = bridgeGroupMetadataToBaileys(bridgeMetadata);
                     ctx.ev.emit('chats.upsert', [
                         { id: metadata.id, name: metadata.subject, conversationTimestamp: metadata.creation }

package/lib/Socket/groups.js

@@ -22,22 +22,23 @@ export const JOIN_APPROVAL_MODES = ['on', 'off'];
 const inviteExpirationNumber = (value) => toNumber(value);
 export const makeGroupMethods = (ctx) => {
     const groupMetadata = async (jid) => {
-        const metadata = await (await ctx.getClient()).getGroupMetadata(jid);
+        const metadata = await ctx.withClient(client => client.getGroupMetadata(jid));
         return bridgeGroupMetadataToBaileys(metadata);
     };
     const groupSettingUpdate = async (jid, setting) => {
         const checked = assertArgumentDomain('groupSettingUpdate', 'setting', setting, GROUP_SETTINGS);
         const mapped = GROUP_SETTING_ALIASES[checked];
-        await (await ctx.getClient()).groupSettingUpdate(jid, mapped.setting, mapped.value);
+        await ctx.withClient(client => client.groupSettingUpdate(jid, mapped.setting, mapped.value));
     };
     const groupAcceptInviteV4 = ctx.ev.createBufferedFunction(async (key, inviteMessage
     // oxlint-disable-next-line typescript/no-explicit-any -- the established public contract returns Promise<any>.
     ) => {
         const messageKey = typeof key === 'string' ? { remoteJid: key } : key;
-        if (!inviteMessage.groupJid || !inviteMessage.inviteCode || !messageKey.remoteJid) {
+        const groupJid = inviteMessage.groupJid;
+        if (!groupJid || !inviteMessage.inviteCode || !messageKey.remoteJid) {
             throw new TypeError('groupAcceptInviteV4 requires groupJid, inviteCode and inviter JID');
         }
-        const joinedJid = await (await ctx.getClient()).groupAcceptInviteV4(inviteMessage.groupJid, inviteMessage.inviteCode, inviteExpirationNumber(inviteMessage.inviteExpiration), messageKey.remoteJid);
+        const joinedJid = await ctx.withClient(client => client.groupAcceptInviteV4(groupJid, inviteMessage.inviteCode, inviteExpirationNumber(inviteMessage.inviteExpiration), messageKey.remoteJid));
         if (messageKey.id) {
             const expiredInvite = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
             expiredInvite.inviteExpiration = 0;
@@ -68,61 +69,61 @@ export const makeGroupMethods = (ctx) => {
     return {
         groupMetadata,
         groupCreate: async (subject, participants) => {
-            const metadata = await (await ctx.getClient()).createGroup(subject, participants);
+            const metadata = await ctx.withClient(client => client.createGroup(subject, participants));
             return bridgeGroupMetadataToBaileys(metadata);
         },
         groupLeave: async (id) => {
-            await (await ctx.getClient()).groupLeave(id);
+            await ctx.withClient(client => client.groupLeave(id));
         },
         groupUpdateSubject: async (jid, subject) => {
-            await (await ctx.getClient()).groupUpdateSubject(jid, subject);
+            await ctx.withClient(client => client.groupUpdateSubject(jid, subject));
         },
         groupRequestParticipantsList: async (jid) => {
-            return bridgeMembershipRequestsToBaileys(await (await ctx.getClient()).groupRequestParticipantsList(jid));
+            return bridgeMembershipRequestsToBaileys(await ctx.withClient(client => client.groupRequestParticipantsList(jid)));
         },
         groupRequestParticipantsUpdate: async (jid, participants, action) => {
             assertArgumentDomain('groupRequestParticipantsUpdate', 'action', action, GROUP_REQUEST_ACTIONS);
-            return bridgeMembershipRequestUpdatesToBaileys(await (await ctx.getClient()).groupRequestParticipantsUpdate(jid, participants, action));
+            return bridgeMembershipRequestUpdatesToBaileys(await ctx.withClient(client => client.groupRequestParticipantsUpdate(jid, participants, action)));
         },
         groupParticipantsUpdate: async (jid, participants, action) => {
             assertArgumentDomain('groupParticipantsUpdate', 'action', action, PARTICIPANT_ACTIONS);
-            return bridgeParticipantChangesToBaileys(await (await ctx.getClient()).groupParticipantsUpdate(jid, participants, action));
+            return bridgeParticipantChangesToBaileys(await ctx.withClient(client => client.groupParticipantsUpdate(jid, participants, action)));
         },
         groupUpdateDescription: async (jid, description) => {
-            await (await ctx.getClient()).groupUpdateDescription(jid, description);
+            await ctx.withClient(client => client.groupUpdateDescription(jid, description));
         },
         groupInviteCode: async (jid) => {
-            return bridgeInviteLinkToCode(await (await ctx.getClient()).groupInviteCode(jid));
+            return bridgeInviteLinkToCode(await ctx.withClient(client => client.groupInviteCode(jid)));
         },
         groupRevokeInvite: async (jid) => {
-            return bridgeInviteLinkToCode(await (await ctx.getClient()).groupRevokeInvite(jid));
+            return bridgeInviteLinkToCode(await ctx.withClient(client => client.groupRevokeInvite(jid)));
         },
         groupAcceptInvite: async (code) => {
-            return (await ctx.getClient()).groupAcceptInvite(code);
+            return ctx.withClient(client => client.groupAcceptInvite(code));
         },
         groupRevokeInviteV4: async (groupJid, invitedJid) => {
-            return (await ctx.getClient()).groupRevokeInviteV4(groupJid, invitedJid);
+            return ctx.withClient(client => client.groupRevokeInviteV4(groupJid, invitedJid));
         },
         groupAcceptInviteV4,
         groupGetInviteInfo: async (code) => {
-            return bridgeGroupMetadataToBaileys(await (await ctx.getClient()).groupGetInviteInfo(code));
+            return bridgeGroupMetadataToBaileys(await ctx.withClient(client => client.groupGetInviteInfo(code)));
         },
         groupToggleEphemeral: async (jid, ephemeralExpiration) => {
-            await (await ctx.getClient()).groupToggleEphemeral(jid, ephemeralExpiration);
+            await ctx.withClient(client => client.groupToggleEphemeral(jid, ephemeralExpiration));
         },
         groupSettingUpdate,
         groupMemberAddMode: async (jid, mode) => {
             assertArgumentDomain('groupMemberAddMode', 'mode', mode, MEMBER_ADD_MODES);
-            await (await ctx.getClient()).groupMemberAddMode(jid, mode);
+            await ctx.withClient(client => client.groupMemberAddMode(jid, mode));
         },
         groupJoinApprovalMode: async (jid, mode) => {
             // Anything but 'on' used to mean off, so a typo turned approvals off
             // and reported success.
             assertArgumentDomain('groupJoinApprovalMode', 'mode', mode, JOIN_APPROVAL_MODES);
-            await (await ctx.getClient()).groupSettingUpdate(jid, 'membership_approval', mode === 'on');
+            await ctx.withClient(client => client.groupSettingUpdate(jid, 'membership_approval', mode === 'on'));
         },
         groupFetchAllParticipating: async () => {
-            const bridgeGroups = await (await ctx.getClient()).groupFetchAllParticipating();
+            const bridgeGroups = await ctx.withClient(client => client.groupFetchAllParticipating());
             const result = {};
             for (const [groupJid, metadata] of Object.entries(bridgeGroups)) {
                 result[groupJid] = bridgeGroupMetadataToBaileys(metadata);
@@ -131,7 +132,7 @@ export const makeGroupMethods = (ctx) => {
             return result;
         },
         updateMemberLabel: async (jid, memberLabel) => {
-            return (await ctx.getClient()).updateMemberLabel(jid, memberLabel.slice(0, 30));
+            return ctx.withClient(client => client.updateMemberLabel(jid, memberLabel.slice(0, 30)));
         }
     };
 };

package/lib/Socket/index.d.ts

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { type UploadMediaResult } from '@oxidezap/whatsapp-rust-bridge';
+import { type WasmWhatsAppClient, 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, WABusinessProfile, WAMessage, WAMessageKey, WAPresence } from '../Types/index.js';
@@ -220,7 +220,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
      */
     [Symbol.asyncDispose](): Promise<void>;
     user: Contact | undefined;
-    waClient: import("@oxidezap/whatsapp-rust-bridge").WasmWhatsAppClient | undefined;
+    waClient: WasmWhatsAppClient | undefined;
     isConnected: boolean;
     isLoggedIn: boolean;
     authState: {