@oxidezap/baileyrs 0.2.13 → 0.3.0

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

@@ -546,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

@@ -20,36 +20,15 @@ export const JOIN_APPROVAL_MODES = ['on', 'off'];
 // exact as a double, and that shape carries no methods. The helper reads both
 // forms, and reconstructs the high word instead of dropping it.
 const inviteExpirationNumber = (value) => toNumber(value);
-// The core's V4 join parser only accepts a `<group>`, `<community>` or
-// `<membership_approval_request>` child, but the server also answers a
-// successful join with a bare `<iq type="result">` (WA Web's own
-// `AcceptGroupAddResponseSuccess` variant requires no child at all — only the
-// result envelope whose `from` echoes the request's `to`). The core reports
-// that shape as an `IqError::ParseError`, which the bridge surfaces as
-// `kind: 'internal'`. Error stanzas never reach the parser (they become
-// `kind: 'server'` one layer below), so this substring can only mean the join
-// was accepted and the JID carrier is missing — never a rejection.
-const BARE_JOIN_SUCCESS_FRAGMENT = 'expected <group>, <community>, or <membership_approval_request> in join response';
-// A bare `<iq type="result">` join success, as described above. Anything else
-// (server rejections, timeouts, transport loss, protocol violations) must keep
-// propagating.
-const isBareJoinSuccess = (error) => {
-    if (!(error instanceof Error) || error.name !== 'WhatsAppError')
-        return false;
-    const kind = error.kind;
-    if (kind !== 'internal')
-        return false;
-    return typeof error.message === 'string' && error.message.includes(BARE_JOIN_SUCCESS_FRAGMENT);
-};
 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>.
@@ -59,18 +38,7 @@ export const makeGroupMethods = (ctx) => {
         if (!groupJid || !inviteMessage.inviteCode || !messageKey.remoteJid) {
             throw new TypeError('groupAcceptInviteV4 requires groupJid, inviteCode and inviter JID');
         }
-        let joinedJid;
-        try {
-            joinedJid = await (await ctx.getClient()).groupAcceptInviteV4(groupJid, inviteMessage.inviteCode, inviteExpirationNumber(inviteMessage.inviteExpiration), messageKey.remoteJid);
-        }
-        catch (error) {
-            // The join was accepted but the response carried no JID node.
-            // Baileys returns the envelope's `from` here, which echoes the
-            // request's `to` — the group JID we already hold.
-            if (!isBareJoinSuccess(error))
-                throw error;
-            joinedJid = groupJid;
-        }
+        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;
@@ -101,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);
@@ -164,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: {

package/lib/Socket/index.js

@@ -44,6 +44,7 @@ import { makeServerQueryMethods } from './server-queries.js';
 import { makeProfileMethods } from './profile.js';
 import { mapReachoutTimelock } from './reachout.js';
 import { makeHttpClient, makeTransport } from './transport.js';
+import { makeWithClient } from './client-operations.js';
 import { makeUSyncMethods } from './usync.js';
 let wasmInitialized = false;
 /**
@@ -216,24 +217,19 @@ const makeWASocket = (config) => {
                 throw firstFlushError;
         },
         release: async (client) => {
-            // `disconnect()` before `free()` is defence in depth, not a fix for a
-            // reproduced bug on this path.
+            // `disconnect()` before `free()` drains exactly one shape: a
+            // `disconnect()` still in flight. Since bridge 0.21.1, freeing
+            // with ordinary calls pending (`fetchBlocklist()`, `logout()`) is
+            // safe — its `Drop` signals shutdown and aborts the background
+            // tasks — but freeing mid-`disconnect()` still aborts the process
+            // (`async-lock` panicking while panicking). See
+            // `__tests__/bridge-free-safety.test.ts`.
             //
-            // The hazard is real and reproducible at the bridge: freeing a client
-            // with any call still pending corrupts the wasm heap — dlmalloc trips
-            // `assertion failed: psize <= size + max_overhead` and the process
-            // dies on `RuntimeError: unreachable`, from a microtask no try/catch
-            // here can reach, since `free()` itself returns normally.
-            // `logout()`, `disconnect()` and a plain `fetchBlocklist()` all
-            // reproduce it — see `__tests__/bridge-free-safety.test.ts`.
-            //
-            // What keeps teardown off that path is the `ws.close()` above, which
-            // is itself a `client.disconnect()` (`Compatibility/websocket-client.ts`).
-            // This is the belt to that braces, and the gap it closes is
-            // `WebSocketClient.close()`'s early return when `closing`/`closed` is
-            // already set: that path does NOT await the disconnect it skipped, so
-            // `void sock.ws.close(); await sock.end()` could otherwise reach
-            // `free()` with the first disconnect still running.
+            // That shape is reachable: `WebSocketClient.close()` early-returns
+            // when `closing`/`closed` is already set without awaiting the
+            // disconnect it skipped, so `void sock.ws.close(); await sock.end()`
+            // could otherwise reach `free()` with the first disconnect still
+            // running. Awaiting it here is the belt to `ws.close()`'s braces.
             let disconnected = true;
             try {
                 await client.disconnect();
@@ -339,61 +335,42 @@ const makeWASocket = (config) => {
         setUser: u => {
             user = u;
         },
-        getClient: () => {
-            // `peek()` keeps returning the client through `closing` so teardown
-            // can still close the transport with it — but that is teardown's
-            // client, not everyone's. Handing it to an ordinary call racing
-            // shutdown, or made from an end handler, starts a bridge operation
-            // while the client is being disconnected and freed, which is the
-            // heap-corruption hazard the whole teardown ordering exists to
-            // avoid. Refuse from the moment `close()` is called.
-            if (owner.isClosing()) {
-                return Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
-            }
-            // Otherwise gated on `initialized`, not merely on the client
-            // existing. `adopt()` publishes it several awaits before
-            // `setDeviceProps`, the account lookups and `run()`, so keying off
-            // `peek()` alone would hand ordinary calls like `sendMessage()` a
-            // half-built client whose read loop has not started — and skip the
-            // `initError` check when startup later fails.
-            if (initialized) {
-                const ready = owner.peek();
-                if (ready)
-                    return Promise.resolve(wrapBridgeClient(ready));
-            }
-            return initPromise.then(() => {
-                // Rechecked after the await: a close landing while startup was
-                // still running would otherwise be handed the client anyway.
-                //
-                // The window between handing a client back and the call reaching
-                // wasm cannot be closed here — that needs in-flight call
-                // tracking. What covers it is `release`, which awaits
-                // `client.disconnect()` before `free()`; the corruption comes
-                // from freeing with a call pending, and the disconnect drains
-                // those first (`__tests__/bridge-free-safety.test.ts`).
-                if (owner.isClosing()) {
-                    throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
-                }
-                if (initError) {
-                    throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
-                }
-                const built = owner.peek();
-                if (!built)
-                    throw new Boom('Client not initialized', { statusCode: 500 });
-                return wrapBridgeClient(built);
-            });
-        },
-        getClientSync: () => {
-            // Same rule as `getClient` — see there.
+        withClient: makeWithClient(getClient)
+    };
+    function getClient() {
+        // Teardown retains the client through closing to disconnect the transport.
+        // Ordinary operations must stop being admitted when close() is called.
+        if (owner.isClosing()) {
+            return Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+        }
+        // Otherwise gated on `initialized`, not merely on the client
+        // existing. `adopt()` publishes it several awaits before
+        // `setDeviceProps`, the account lookups and `run()`, so keying off
+        // `peek()` alone would hand ordinary calls like `sendMessage()` a
+        // half-built client whose read loop has not started — and skip the
+        // `initError` check when startup later fails.
+        if (initialized) {
+            const ready = owner.peek();
+            if (ready)
+                return Promise.resolve(wrapBridgeClient(ready));
+        }
+        return initPromise.then(() => {
+            // Closing may have started while initialization was pending.
+            // This gate does not track admitted operations. Bridge 0.21.1 tolerates
+            // free() during ordinary calls, but not during disconnect(); release
+            // still awaits that drain before freeing the client.
             if (owner.isClosing()) {
                 throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
             }
+            if (initError) {
+                throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
+            }
             const built = owner.peek();
             if (!built)
                 throw new Boom('Client not initialized', { statusCode: 500 });
             return wrapBridgeClient(built);
-        }
-    };
+        });
+    }
     // The native repository delegates Signal state directly to the core and does
     // not need the standalone transaction facade. Keep that facade lazy for the
     // public authState and custom repository contracts that can observe it.
@@ -776,7 +753,7 @@ const makeWASocket = (config) => {
         });
     };
     const fetchReachoutTimelock = async () => {
-        const payload = await (await ctx.getClient()).fetchReachoutTimelock();
+        const payload = await ctx.withClient(client => client.fetchReachoutTimelock());
         const state = mapReachoutTimelock(payload) ?? { isActive: false };
         ev.emit('connection.update', { reachoutTimeLock: state });
         return state;
@@ -784,14 +761,14 @@ const makeWASocket = (config) => {
     const query = async (node, timeoutMs) => {
         if (!node.attrs.id)
             node.attrs.id = generateMessageTag();
-        const result = (await (await ctx.getClient()).queryNode(node, timeoutMs));
+        const result = (await ctx.withClient(client => client.queryNode(node, timeoutMs)));
         assertNodeErrorFree(result);
         return result;
     };
     const waitForMessage = makeTaggedMessageWaiter(ws, logger, fullConfig.defaultQueryTimeoutMs);
     const usyncMethods = makeUSyncMethods({
         queryNode: query,
-        queryUsync: async (typedQuery) => (await ctx.getClient()).queryUsync(typedQuery)
+        queryUsync: async (typedQuery) => ctx.withClient(client => client.queryUsync(typedQuery))
     });
     const sock = {
         ev,
@@ -876,18 +853,18 @@ const makeWASocket = (config) => {
         notificationMutex,
         generateMessageTag,
         sendNode: async (frame) => {
-            return (await ctx.getClient()).sendNode(frame);
+            return ctx.withClient(client => client.sendNode(frame));
         },
         assertSessions: async (jids, force) => {
-            return (await ctx.getClient()).assertSessions(jids, force ?? false);
+            return ctx.withClient(client => client.assertSessions(jids, force ?? false));
         },
         getUSyncDevices: async (jids, useCache, ignoreZeroDevices) => {
-            return (await ctx.getClient()).getUSyncDevices(jids, useCache, ignoreZeroDevices);
+            return ctx.withClient(client => client.getUSyncDevices(jids, useCache, ignoreZeroDevices));
         },
         waitForMessage,
         query,
         sendRawMessage: async (data) => {
-            return (await ctx.getClient()).sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data));
+            return ctx.withClient(client => client.sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data)));
         },
         /**
          * `dsmMessage` is accepted so the signature matches upstream, and
@@ -901,7 +878,7 @@ const makeWASocket = (config) => {
                 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 = encodeProtoCompat('Message', message);
-            return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
+            return ctx.withClient(client => client.createParticipantNodesBytes(jids, bytes, extraAttrs ?? {}));
         },
         signalRepository,
         ...makePreKeyMethods(ctx),
@@ -926,14 +903,15 @@ const makeWASocket = (config) => {
             // Ahead of the client: an off-union value used to fall through to the
             // chat-state branch and be reported as a missing jid.
             assertArgumentDomain('sendPresenceUpdate', 'type', type, WA_PRESENCES);
-            const c = await ctx.getClient();
-            if (type === 'available' || type === 'unavailable') {
-                return c.sendPresence(type);
-            }
-            if (!toJid) {
-                throw new Boom(`sendPresenceUpdate('${type}') requires a target jid`, { statusCode: 400 });
-            }
-            return c.sendChatState(toJid, type);
+            return ctx.withClient(async (c) => {
+                if (type === 'available' || type === 'unavailable') {
+                    return c.sendPresence(type);
+                }
+                if (!toJid) {
+                    throw new Boom(`sendPresenceUpdate('${type}') requires a target jid`, { statusCode: 400 });
+                }
+                return c.sendChatState(toJid, type);
+            });
         },
         /**
          * Plaintext media upload helper, source-compatible with the upstream
@@ -946,15 +924,15 @@ const makeWASocket = (config) => {
             // `toBridgeMediaType` below still refuses the ones it cannot map.
             assertArgumentDomain('waUploadToServer', 'mediaType', opts?.mediaType, MEDIA_TYPES);
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
-            return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
+            return ctx.withClient(client => client.uploadMedia(bytes, toBridgeMediaType(opts.mediaType)));
         },
         ...makePrivacyMethods(ctx),
         updateDefaultDisappearingMode: async (duration) => {
-            await (await ctx.getClient()).updateDefaultDisappearingMode(duration);
+            await ctx.withClient(client => client.updateDefaultDisappearingMode(duration));
         },
         rejectCall: async (callId, callFrom) => {
             const context = activeCallContexts.get(callId);
-            await (await ctx.getClient()).rejectCall(callId, context?.peer ?? callFrom, context?.callCreator ?? callFrom);
+            await ctx.withClient(client => client.rejectCall(callId, context?.peer ?? callFrom, context?.callCreator ?? callFrom));
             activeCallContexts.delete(callId);
         },
         /**
@@ -974,14 +952,14 @@ const makeWASocket = (config) => {
         /** Upstream Baileys-compatible name. */
         fetchAccountReachoutTimelock: fetchReachoutTimelock,
         getBusinessProfile: async (jid) => {
-            return bridgeBusinessProfileToBaileys(await (await ctx.getClient()).getBusinessProfile(jid));
+            return bridgeBusinessProfileToBaileys(await ctx.withClient(client => client.getBusinessProfile(jid)));
         },
         fetchMessageHistory: async (count, oldestMsgKey, oldestMsgTimestamp) => {
-            return (await ctx.getClient()).fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber());
+            return ctx.withClient(client => client.fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber()));
         },
         sendStatusMessage: async (message, recipients) => {
             const bytes = encodeProtoCompat('Message', message);
-            return (await ctx.getClient()).sendStatusMessageBytes(bytes, recipients);
+            return ctx.withClient(client => client.sendStatusMessageBytes(bytes, recipients));
         },
         ...makeMessageMethods(ctx),
         ...groupMethods,
@@ -1002,11 +980,11 @@ const makeWASocket = (config) => {
             // the context below is built, and a check past that await reports a
             // stack without the caller in it.
             assertArgumentDomain('downloadMedia', 'type', type, MEDIA_DOWNLOAD_TYPES);
-            return downloadMediaMessage(message, type, options, {
+            return ctx.withClient(client => downloadMediaMessage(message, type, options, {
                 logger,
                 reuploadRequest: (m) => sock.updateMediaMessage(m),
-                waClient: await ctx.getClient()
-            });
+                waClient: client
+            }));
         }
     };
     // Assigning replaces the handler the socket itself reports through, rather

package/lib/Socket/internals.js

@@ -65,7 +65,7 @@ export const makeInternalMethods = (ctx) => {
          * that wants the next attempt waits again.
          */
         waitForSocketOpen: async () => {
-            await (await ctx.getClient()).waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS);
+            await ctx.withClient(client => client.waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS));
         },
         /**
          * Publishes a message onto the event bus, which is this layer's own job.