@oxidezap/baileyrs 0.2.12 → 0.3.0

package/lib/Socket/newsletter.js

@@ -4,140 +4,144 @@ import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { generateProfilePicture } from '../Utils/messages-media.js';
 export const NEWSLETTER_KEY_TYPES = ['invite', 'jid'];
-export const makeNewsletterMethods = (ctx) => ({
-    newsletterCreate: async (name, description) => {
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterCreate(name, description ?? null));
-    },
-    /**
-     * `type` selects which lookup runs: the bridge has a method per key kind
-     * rather than one that inspects the key. Resolves to null when the
-     * newsletter does not exist, matching upstream.
-     */
-    newsletterMetadata: async (type, key) => {
-        assertArgumentDomain('newsletterMetadata', 'type', type, NEWSLETTER_KEY_TYPES);
-        const client = await ctx.getClient();
-        const result = type === 'invite' ? await client.newsletterMetadataByInvite(key) : await client.newsletterMetadata(key);
-        return result ? bridgeNewsletterMetadataToBaileys(result) : null;
-    },
-    /**
-     * `picture` is base64 of an already-generated image, and the empty string
-     * means remove, as upstream builds it. The core splits those into two
-     * methods, so the field is dispatched rather than forwarded.
-     */
-    newsletterUpdate: async (jid, updates) => {
-        const client = await ctx.getClient();
-        let result;
-        if (updates.name !== undefined || updates.description !== undefined) {
-            result = await client.newsletterUpdate(jid, updates.name ?? null, updates.description ?? null);
-        }
-        if (updates.picture === '') {
-            result = await client.newsletterRemovePicture(jid);
-        }
-        else if (updates.picture !== undefined) {
-            result = await client.newsletterSetPicture(jid, new Uint8Array(Buffer.from(updates.picture, 'base64')));
-        }
-        // Only when the delta asked for nothing: every write above already
-        // answers with the refreshed metadata, so reading it would be a round
-        // trip whose result is thrown away.
-        return bridgeNewsletterMetadataToBaileys(result ?? (await client.newsletterMetadata(jid)));
-    },
-    newsletterUpdateName: async (jid, name) => {
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterUpdate(jid, name, null));
-    },
-    newsletterUpdateDescription: async (jid, description) => {
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterUpdate(jid, null, description));
-    },
-    newsletterUpdatePicture: async (jid, content) => {
-        const { img } = await generateProfilePicture(content);
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterSetPicture(jid, img));
-    },
-    newsletterRemovePicture: async (jid) => {
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterRemovePicture(jid));
-    },
-    newsletterFollow: async (jid) => {
-        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterSubscribe(jid));
-    },
-    newsletterUnfollow: async (jid) => {
-        await (await ctx.getClient()).newsletterUnsubscribe(jid);
-    },
-    /**
-     * The names this package used before it grew upstream's. Kept so existing
-     * callers do not break on a rename that buys them nothing, and returning
-     * the bridge result unmapped for the same reason: a caller reading `jid`
-     * or `subscriberCount` off it would find them renamed otherwise.
-     * `newsletterFollow` is the one that speaks upstream's shape.
-     */
-    newsletterSubscribe: async (jid) => {
-        return await (await ctx.getClient()).newsletterSubscribe(jid);
-    },
-    newsletterUnsubscribe: async (jid) => {
-        await (await ctx.getClient()).newsletterUnsubscribe(jid);
-    },
-    /**
-     * The follower-activity mute, which is the one a subscriber toggles. The
-     * core's other newsletter mute is for admin activity and is a different
-     * control, so the ambiguous alias is avoided here.
-     */
-    newsletterMute: async (jid) => {
-        await (await ctx.getClient()).newsletterFollowerMute(jid, true);
-    },
-    newsletterUnmute: async (jid) => {
-        await (await ctx.getClient()).newsletterFollowerMute(jid, false);
-    },
-    newsletterSubscribers: async (jid) => {
-        const metadata = await (await ctx.getClient()).newsletterMetadata(jid);
-        return { subscribers: metadata.subscriberCount };
-    },
-    newsletterReactMessage: async (jid, serverId, reaction) => {
-        await (await ctx.getClient()).newsletterReactMessage(jid, serverId, reaction ?? null);
-    },
-    /**
-     * `since` and `after` have no equivalent: the core's query pages backward
-     * from a `before` cursor and carries no time filter. Mapping `after` onto
-     * `before` would page the opposite direction and return a plausible wrong
-     * answer, so a caller asking for either is told instead.
-     *
-     * Zero is not asking. `since: 0` is the epoch and `after: 0` is no cursor,
-     * which is what the unfiltered query already does, so the common
-     * `(jid, count, 0, 0)` call runs rather than being refused for nothing.
-     */
-    newsletterFetchMessages: async (jid, count, since, after) => {
-        if (since) {
-            throw new Boom('newsletterFetchMessages: `since` is not supported, the message query carries no time filter', {
-                statusCode: 400
+export const makeNewsletterMethods = (ctx) => {
+    return {
+        newsletterCreate: async (name, description) => {
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterCreate(name, description ?? null)));
+        },
+        /**
+         * `type` selects which lookup runs: the bridge has a method per key kind
+         * rather than one that inspects the key. Resolves to null when the
+         * newsletter does not exist, matching upstream.
+         */
+        newsletterMetadata: async (type, key) => {
+            assertArgumentDomain('newsletterMetadata', 'type', type, NEWSLETTER_KEY_TYPES);
+            return ctx.withClient(async (client) => {
+                const result = type === 'invite' ? await client.newsletterMetadataByInvite(key) : await client.newsletterMetadata(key);
+                return result ? bridgeNewsletterMetadataToBaileys(result) : null;
             });
-        }
-        if (after) {
-            throw new Boom('newsletterFetchMessages: `after` is not supported, the message query pages backward from a `before` cursor', { statusCode: 400 });
-        }
-        return await (await ctx.getClient()).newsletterMessages(jid, count, null);
-    },
-    subscribeNewsletterUpdates: async (jid) => {
-        const duration = await (await ctx.getClient()).newsletterSubscribeLiveUpdates(jid);
-        return { duration: String(duration) };
-    },
-    /**
-     * The count rides on the admin-info result and the server omits it for an
-     * account that may not see it. Absent is reported as absent: `0` here would
-     * read as "no admins", which no newsletter can be.
-     */
-    newsletterAdminCount: async (jid) => {
-        const info = await (await ctx.getClient()).newsletterAdminInfo(jid);
-        if (info.adminCount === undefined) {
-            throw new Boom('newsletterAdminCount: the server did not return an admin count for this newsletter', {
-                statusCode: 404
+        },
+        /**
+         * `picture` is base64 of an already-generated image, and the empty string
+         * means remove, as upstream builds it. The core splits those into two
+         * methods, so the field is dispatched rather than forwarded.
+         */
+        newsletterUpdate: async (jid, updates) => {
+            return ctx.withClient(async (client) => {
+                let result;
+                if (updates.name !== undefined || updates.description !== undefined) {
+                    result = await client.newsletterUpdate(jid, updates.name ?? null, updates.description ?? null);
+                }
+                if (updates.picture === '') {
+                    result = await client.newsletterRemovePicture(jid);
+                }
+                else if (updates.picture !== undefined) {
+                    result = await client.newsletterSetPicture(jid, new Uint8Array(Buffer.from(updates.picture, 'base64')));
+                }
+                // Only when the delta asked for nothing: every write above already
+                // answers with the refreshed metadata, so reading it would be a round
+                // trip whose result is thrown away.
+                return bridgeNewsletterMetadataToBaileys(result ?? (await client.newsletterMetadata(jid)));
             });
+        },
+        newsletterUpdateName: async (jid, name) => {
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterUpdate(jid, name, null)));
+        },
+        newsletterUpdateDescription: async (jid, description) => {
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterUpdate(jid, null, description)));
+        },
+        newsletterUpdatePicture: async (jid, content) => {
+            const { img } = await generateProfilePicture(content);
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterSetPicture(jid, img)));
+        },
+        newsletterRemovePicture: async (jid) => {
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterRemovePicture(jid)));
+        },
+        newsletterFollow: async (jid) => {
+            return bridgeNewsletterMetadataToBaileys(await ctx.withClient(client => client.newsletterSubscribe(jid)));
+        },
+        newsletterUnfollow: async (jid) => {
+            await ctx.withClient(client => client.newsletterUnsubscribe(jid));
+        },
+        /**
+         * The names this package used before it grew upstream's. Kept so existing
+         * callers do not break on a rename that buys them nothing, and returning
+         * the bridge result unmapped for the same reason: a caller reading `jid`
+         * or `subscriberCount` off it would find them renamed otherwise.
+         * `newsletterFollow` is the one that speaks upstream's shape.
+         */
+        newsletterSubscribe: async (jid) => {
+            return await ctx.withClient(client => client.newsletterSubscribe(jid));
+        },
+        newsletterUnsubscribe: async (jid) => {
+            await ctx.withClient(client => client.newsletterUnsubscribe(jid));
+        },
+        /**
+         * The follower-activity mute, which is the one a subscriber toggles. The
+         * core's other newsletter mute is for admin activity and is a different
+         * control, so the ambiguous alias is avoided here.
+         */
+        newsletterMute: async (jid) => {
+            await ctx.withClient(client => client.newsletterFollowerMute(jid, true));
+        },
+        newsletterUnmute: async (jid) => {
+            await ctx.withClient(client => client.newsletterFollowerMute(jid, false));
+        },
+        newsletterSubscribers: async (jid) => {
+            const metadata = await ctx.withClient(client => client.newsletterMetadata(jid));
+            return { subscribers: metadata.subscriberCount };
+        },
+        newsletterReactMessage: async (jid, serverId, reaction) => {
+            await ctx.withClient(client => client.newsletterReactMessage(jid, serverId, reaction ?? null));
+        },
+        /**
+         * `since` and `after` have no equivalent: the core's query pages backward
+         * from a `before` cursor and carries no time filter. Mapping `after` onto
+         * `before` would page the opposite direction and return a plausible wrong
+         * answer, so a caller asking for either is told instead.
+         *
+         * Zero is not asking. `since: 0` is the epoch and `after: 0` is no cursor,
+         * which is what the unfiltered query already does, so the common
+         * `(jid, count, 0, 0)` call runs rather than being refused for nothing.
+         */
+        newsletterFetchMessages: async (jid, count, since, after) => {
+            if (since) {
+                throw new Boom('newsletterFetchMessages: `since` is not supported, the message query carries no time filter', {
+                    statusCode: 400
+                });
+            }
+            if (after) {
+                throw new Boom('newsletterFetchMessages: `after` is not supported, the message query pages backward from a `before` cursor', { statusCode: 400 });
+            }
+            return await ctx.withClient(client => client.newsletterMessages(jid, count, null));
+        },
+        subscribeNewsletterUpdates: async (jid) => {
+            const duration = await ctx.withClient(client => client.newsletterSubscribeLiveUpdates(jid));
+            return { duration: String(duration) };
+        },
+        /**
+         * The count rides on the admin-info result and the server omits it for an
+         * account that may not see it. Absent is reported as absent: `0` here would
+         * read as "no admins", which no newsletter can be.
+         */
+        newsletterAdminCount: async (jid) => {
+            const info = await ctx.withClient(client => client.newsletterAdminInfo(jid));
+            if (info.adminCount === undefined) {
+                throw new Boom('newsletterAdminCount: the server did not return an admin count for this newsletter', {
+                    statusCode: 404
+                });
+            }
+            return info.adminCount;
+        },
+        newsletterChangeOwner: async (jid, newOwnerJid) => {
+            await ctx.withClient(client => client.newsletterChangeOwner(jid, newOwnerJid));
+        },
+        newsletterDemote: async (jid, userJid) => {
+            await ctx.withClient(client => client.newsletterDemoteAdmin(jid, userJid));
+        },
+        newsletterDelete: async (jid) => {
+            await ctx.withClient(client => client.newsletterDelete(jid));
         }
-        return info.adminCount;
-    },
-    newsletterChangeOwner: async (jid, newOwnerJid) => {
-        await (await ctx.getClient()).newsletterChangeOwner(jid, newOwnerJid);
-    },
-    newsletterDemote: async (jid, userJid) => {
-        await (await ctx.getClient()).newsletterDemoteAdmin(jid, userJid);
-    },
-    newsletterDelete: async (jid) => {
-        await (await ctx.getClient()).newsletterDelete(jid);
-    }
-});
+    };
+};
 //# sourceMappingURL=newsletter.js.map

package/lib/Socket/prekeys.d.ts

@@ -1,5 +1,5 @@
 import type { SocketContext } from './types.js';
-type PreKeyContext = Pick<SocketContext, 'getClient' | 'logger'>;
+type PreKeyContext = Pick<SocketContext, 'logger' | 'withClient'>;
 export declare const makePreKeyMethods: (ctx: PreKeyContext) => {
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;

package/lib/Socket/prekeys.js

@@ -1,21 +1,23 @@
 import { MIN_PREKEY_COUNT } from '../Defaults/index.js';
-export const makePreKeyMethods = (ctx) => ({
-    uploadPreKeys: async (count = MIN_PREKEY_COUNT) => {
-        await (await ctx.getClient()).refreshPreKeys(count);
-    },
-    uploadPreKeysToServerIfRequired: async () => {
-        try {
-            await (await ctx.getClient()).ensurePreKeys();
+export const makePreKeyMethods = (ctx) => {
+    return {
+        uploadPreKeys: async (count = MIN_PREKEY_COUNT) => {
+            await ctx.withClient(client => client.refreshPreKeys(count));
+        },
+        uploadPreKeysToServerIfRequired: async () => {
+            try {
+                await ctx.withClient(client => client.ensurePreKeys());
+            }
+            catch (error) {
+                ctx.logger.error({ error }, 'Failed to check/upload pre-keys during initialization');
+            }
+        },
+        digestKeyBundle: async () => {
+            await ctx.withClient(client => client.validateKeyBundle());
+        },
+        rotateSignedPreKey: async () => {
+            await ctx.withClient(client => client.rotateSignedKey());
         }
-        catch (error) {
-            ctx.logger.error({ error }, 'Failed to check/upload pre-keys during initialization');
-        }
-    },
-    digestKeyBundle: async () => {
-        await (await ctx.getClient()).validateKeyBundle();
-    },
-    rotateSignedPreKey: async () => {
-        await (await ctx.getClient()).rotateSignedKey();
-    }
-});
+    };
+};
 //# sourceMappingURL=prekeys.js.map

package/lib/Socket/presence.js

@@ -1,16 +1,18 @@
 import { WA_CHAT_STATES, WA_PRESENCE_STATUSES } from '../Types/index.js';
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
-export const makePresenceMethods = (ctx) => ({
-    sendPresence: async (status) => {
-        assertArgumentDomain('sendPresence', 'status', status, WA_PRESENCE_STATUSES);
-        await (await ctx.getClient()).sendPresence(status);
-    },
-    presenceSubscribe: async (toJid) => {
-        await (await ctx.getClient()).presenceSubscribe(toJid);
-    },
-    sendChatState: async (jid, state) => {
-        assertArgumentDomain('sendChatState', 'state', state, WA_CHAT_STATES);
-        await (await ctx.getClient()).sendChatState(jid, state);
-    }
-});
+export const makePresenceMethods = (ctx) => {
+    return {
+        sendPresence: async (status) => {
+            assertArgumentDomain('sendPresence', 'status', status, WA_PRESENCE_STATUSES);
+            await ctx.withClient(client => client.sendPresence(status));
+        },
+        presenceSubscribe: async (toJid) => {
+            await ctx.withClient(client => client.presenceSubscribe(toJid));
+        },
+        sendChatState: async (jid, state) => {
+            assertArgumentDomain('sendChatState', 'state', state, WA_CHAT_STATES);
+            await ctx.withClient(client => client.sendChatState(jid, state));
+        }
+    };
+};
 //# sourceMappingURL=presence.js.map

package/lib/Socket/privacy.js

@@ -6,7 +6,7 @@ export const makePrivacyMethods = (ctx) => {
     return {
         fetchPrivacySettings: async (force) => {
             void force;
-            return (await ctx.getClient()).fetchPrivacySettings();
+            return ctx.withClient(client => client.fetchPrivacySettings());
         },
         /**
          * The untyped escape hatch, left open on purpose: the bridge takes both
@@ -15,39 +15,39 @@ export const makePrivacyMethods = (ctx) => {
          * name yet. The wrappers are the checked path.
          */
         updatePrivacySetting: async (category, value) => {
-            await (await ctx.getClient()).updatePrivacySetting(category, value);
+            await ctx.withClient(client => client.updatePrivacySetting(category, value));
         },
         updateLastSeenPrivacy: async (value) => {
             assertArgumentDomain('updateLastSeenPrivacy', 'value', value, WA_PRIVACY_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('last', value);
+            await ctx.withClient(client => client.updatePrivacySetting('last', value));
         },
         updateOnlinePrivacy: async (value) => {
             assertArgumentDomain('updateOnlinePrivacy', 'value', value, WA_PRIVACY_ONLINE_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('online', value);
+            await ctx.withClient(client => client.updatePrivacySetting('online', value));
         },
         updateProfilePicturePrivacy: async (value) => {
             assertArgumentDomain('updateProfilePicturePrivacy', 'value', value, WA_PRIVACY_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('profile', value);
+            await ctx.withClient(client => client.updatePrivacySetting('profile', value));
         },
         updateStatusPrivacy: async (value) => {
             assertArgumentDomain('updateStatusPrivacy', 'value', value, WA_PRIVACY_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('status', value);
+            await ctx.withClient(client => client.updatePrivacySetting('status', value));
         },
         updateReadReceiptsPrivacy: async (value) => {
             assertArgumentDomain('updateReadReceiptsPrivacy', 'value', value, WA_READ_RECEIPTS_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
+            await ctx.withClient(client => client.updatePrivacySetting('readreceipts', value));
         },
         updateGroupsAddPrivacy: async (value) => {
             assertArgumentDomain('updateGroupsAddPrivacy', 'value', value, WA_PRIVACY_GROUP_ADD_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
+            await ctx.withClient(client => client.updatePrivacySetting('groupadd', value));
         },
         updateCallPrivacy: async (value) => {
             assertArgumentDomain('updateCallPrivacy', 'value', value, WA_PRIVACY_CALL_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('calladd', value);
+            await ctx.withClient(client => client.updatePrivacySetting('calladd', value));
         },
         updateMessagesPrivacy: async (value) => {
             assertArgumentDomain('updateMessagesPrivacy', 'value', value, WA_PRIVACY_MESSAGES_VALUES);
-            await (await ctx.getClient()).updatePrivacySetting('messages', value);
+            await ctx.withClient(client => client.updatePrivacySetting('messages', value));
         },
         /**
          * Resolves without issuing anything. The engine already issues these

package/lib/Socket/profile.js

@@ -3,49 +3,51 @@ import { generateProfilePicture } from '../Utils/messages-media.js';
 import { isJidGroup } from '../WABinary/index.js';
 export const makeProfileMethods = (ctx) => {
     const setPushName = async (name) => {
-        await (await ctx.getClient()).setPushName(name);
+        await ctx.withClient(client => client.setPushName(name));
     };
     return {
         requestPairingCode: async (phoneNumber, customPairingCode) => {
-            return await (await ctx.getClient()).requestPairingCode(phoneNumber, customPairingCode);
+            return await ctx.withClient(client => client.requestPairingCode(phoneNumber, customPairingCode));
         },
         setPushName,
         /** Alias for setPushName (upstream Baileys compat) */
         updateProfileName: setPushName,
         getPushName: async () => {
-            return await (await ctx.getClient()).getPushName();
+            return await ctx.withClient(client => client.getPushName());
         },
         getJid: async () => {
-            return await (await ctx.getClient()).getJid();
+            return await ctx.withClient(client => client.getJid());
         },
         getLid: async () => {
-            return await (await ctx.getClient()).getLid();
+            return await ctx.withClient(client => client.getLid());
         },
         updateProfilePicture: async (jid, content, dimensions) => {
             if (!jid) {
                 throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update');
             }
             const { img } = await generateProfilePicture(content, dimensions);
-            const client = await ctx.getClient();
-            if (isJidGroup(jid)) {
-                await client.setGroupProfilePicture(jid, img);
-                return;
-            }
-            await client.updateProfilePicture(img);
+            return ctx.withClient(async (client) => {
+                if (isJidGroup(jid)) {
+                    await client.setGroupProfilePicture(jid, img);
+                    return;
+                }
+                await client.updateProfilePicture(img);
+            });
         },
         removeProfilePicture: async (jid) => {
             if (!jid) {
                 throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update');
             }
-            const client = await ctx.getClient();
-            if (isJidGroup(jid)) {
-                await client.removeGroupProfilePicture(jid);
-                return;
-            }
-            await client.removeProfilePicture();
+            return ctx.withClient(async (client) => {
+                if (isJidGroup(jid)) {
+                    await client.removeGroupProfilePicture(jid);
+                    return;
+                }
+                await client.removeProfilePicture();
+            });
         },
         updateProfileStatus: async (status) => {
-            await (await ctx.getClient()).updateProfileStatus(status);
+            await ctx.withClient(client => client.updateProfileStatus(status));
         }
     };
 };

package/lib/Socket/server-queries.js

@@ -70,7 +70,7 @@ export const makeServerQueryMethods = (ctx) => {
             // already hold a connection acquired by an upload, and stamping that
             // one as fetched now would report it fresher than it is.
             const held = fetched;
-            const conn = await (await ctx.getClient()).getMediaConn(forceGet || !held);
+            const conn = await ctx.withClient(client => client.getMediaConn(forceGet || !held));
             mediaHost = conn.hosts[0]?.hostname ?? mediaHost;
             const isFetch = forceGet || !held || held.auth !== conn.auth || !isLive(held);
             fetched = isFetch ? { auth: conn.auth, ttl: conn.ttl, at: new Date() } : held;
@@ -81,10 +81,10 @@ export const makeServerQueryMethods = (ctx) => {
         /** Synchronous, as upstream has it, so it reads what the last refresh saw. */
         getMediaHost: () => mediaHost,
         getBotListV2: async () => {
-            return flattenBotList(await (await ctx.getClient()).getBotList());
+            return flattenBotList(await ctx.withClient(client => client.getBotList()));
         },
         fetchNewChatMessageCap: async () => {
-            return toCapInfo(await (await ctx.getClient()).fetchNewChatMessageCappingInfo());
+            return toCapInfo(await ctx.withClient(client => client.fetchNewChatMessageCappingInfo()));
         },
         cleanDirtyBits: async (type, fromTimestamp) => {
             assertArgumentDomain('cleanDirtyBits', 'type', type, DIRTY_BIT_TYPES);
@@ -99,7 +99,7 @@ export const makeServerQueryMethods = (ctx) => {
                     throw new Boom(`cleanDirtyBits: fromTimestamp '${fromTimestamp}' is not a number`, { statusCode: 400 });
                 }
             }
-            await (await ctx.getClient()).cleanDirtyBits(type, timestamp);
+            await ctx.withClient(client => client.cleanDirtyBits(type, timestamp));
         },
         /**
          * Refused rather than wired up. The core already fires a peer data

package/lib/Socket/terminal-close.d.ts

@@ -1,39 +1,5 @@
-/**
- * Which bridge disconnects end the socket for good.
- *
- * This mirrors one decision that lives in the Rust engine, so keep it honest:
- * `whatsapp-rust` clears `enable_auto_reconnect` and breaks out of its run loop
- * on exactly these, and retries everything else on the WA Web Fibonacci backoff
- * (`client/lifecycle.rs`).
- *
- * The socket layer needs the answer because `WasmWhatsAppClient.run()` returns
- * `void` — it spawns the loop as a background task, so the loop's exit is not
- * observable from JS (`whatsapp_rust_bridge.d.ts`, `run(): void`). Until the
- * bridge exposes loop completion, this table is how the socket knows a client
- * has become dead weight that only `free()` can reclaim.
- *
- * The upstream Baileys contract this buys us: `connection.update { close }`
- * means "this socket is finished, build a new one" — which is what every
- * consumer written against upstream already assumes, because upstream has no
- * auto-reconnect at all. Transient drops therefore never surface as `close`;
- * they surface as `connecting`.
- *
- * Events deliberately absent from the terminal set, and why:
- *  - `disconnected` — the engine only dispatches `Event::Disconnected` for an
- *    *unexpected* loop exit, and every terminal path sets `expected_disconnect`
- *    first, which suppresses it (`client/lifecycle.rs`). So this one is the
- *    "engine is retrying" signal — with one exception the dispatcher handles:
- *    under `setAutoReconnect(false)` the run loop dispatches `Disconnected`
- *    and only *then* tests the flag and breaks out, which makes the very same
- *    event terminal. Absence from this list means "not terminal on its own",
- *    not "never terminal".
- *  - `streamError` — reaches JS only from the engine's catch-all `<stream:error>`
- *    branch (unknown code, `<ack/>`, `<xml-not-well-formed>`); the coded ones
- *    (401/409/515/516/429/503) dispatch their own events instead. Every case
- *    that gets here keeps the connection or recycles it deliberately.
- *  - `pairError` — pairing failed, but the engine keeps its loop and re-emits a
- *    QR; nothing about the client is dead.
- */
 /** True when the engine will keep retrying after this `<failure>`. */
 export declare const isReconnectableConnectFailure: (reason: number | undefined) => boolean;
+/** Map a typed bridge connect-failure code to Baileys' close status. */
+export declare const mapConnectFailureToDisconnect: (reason: number | undefined) => number;
 //# sourceMappingURL=terminal-close.d.ts.map

package/lib/Socket/terminal-close.js

@@ -1,3 +1,4 @@
+import { DisconnectReason } from '../Types/index.js';
 /**
  * Which bridge disconnects end the socket for good.
  *
@@ -6,11 +7,10 @@
  * on exactly these, and retries everything else on the WA Web Fibonacci backoff
  * (`client/lifecycle.rs`).
  *
- * The socket layer needs the answer because `WasmWhatsAppClient.run()` returns
- * `void` — it spawns the loop as a background task, so the loop's exit is not
- * observable from JS (`whatsapp_rust_bridge.d.ts`, `run(): void`). Until the
- * bridge exposes loop completion, this table is how the socket knows a client
- * has become dead weight that only `free()` can reclaim.
+ * The socket layer needs the answer for bridge events that classify a terminal
+ * close before the supervised run completion is observed. Bridge 0.21.0 also
+ * exposes `waitForRunCompletion()` for exits with no terminal event; that
+ * observer uses the same terminal-close reporter and owner as this table.
  *
  * The upstream Baileys contract this buys us: `connection.update { close }`
  * means "this socket is finished, build a new one" — which is what every
@@ -48,4 +48,28 @@ const RECONNECTABLE_CONNECT_FAILURE_REASONS = new Set([
 ]);
 /** True when the engine will keep retrying after this `<failure>`. */
 export const isReconnectableConnectFailure = (reason) => reason !== undefined && RECONNECTABLE_CONNECT_FAILURE_REASONS.has(reason);
+/** Map a typed bridge connect-failure code to Baileys' close status. */
+export const mapConnectFailureToDisconnect = (reason) => {
+    switch (reason) {
+        case 401:
+        case 403:
+        case 406:
+            return DisconnectReason.loggedOut;
+        case 402:
+            return DisconnectReason.forbidden;
+        case 405:
+            return 405;
+        case 411:
+            return DisconnectReason.multideviceMismatch;
+        case 503:
+        case 501:
+            return DisconnectReason.unavailableService;
+        case 408:
+            return DisconnectReason.timedOut;
+        case 515:
+            return DisconnectReason.restartRequired;
+        default:
+            return DisconnectReason.connectionClosed;
+    }
+};
 //# sourceMappingURL=terminal-close.js.map

package/lib/Socket/types.d.ts

@@ -1,10 +1,10 @@
 import type { EventEmitter } from 'events';
-import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { Contact, SocketConfig } from '../Types/index.js';
 import type { makeEventBuffer } from '../Utils/event-buffer.js';
 import type { ILogger } from '../Utils/logger.js';
+import type { ClientOperations } from './client-operations.js';
 /** Shared context passed to all Socket method factories */
-export interface SocketContext {
+export interface SocketContext extends ClientOperations {
     ev: ReturnType<typeof makeEventBuffer>;
     logger: ILogger;
     fullConfig: SocketConfig;
@@ -17,10 +17,6 @@ export interface SocketContext {
         id?: string;
         lid?: string;
     }) => void;
-    /** Returns the bridge client, awaiting initialization if needed */
-    getClient: () => Promise<WasmWhatsAppClient>;
-    /** Returns the bridge client synchronously, throws if not yet initialized */
-    getClientSync: () => WasmWhatsAppClient;
     /** Raw stanza EventEmitter for CB: pattern compat */
     ws: EventEmitter;
     /**