@oxidezap/baileyrs 0.2.13 → 0.3.0

package/lib/Compatibility/signal-repository.d.ts

@@ -1,7 +1,7 @@
 import type { LIDMapping, SignalAuthState, SignalRepositoryWithLIDStore } from '../Types/index.js';
 import type { ILogger } from '../Utils/logger.js';
 import type { SocketContext } from '../Socket/types.js';
-type SignalRepositoryContext = Pick<SocketContext, 'getClient' | 'logger'>;
+type SignalRepositoryContext = Pick<SocketContext, 'logger' | 'withClient'>;
 export declare const jidToSignalProtocolAddressCompat: (jid: string) => string;
 export declare const bindSignalRepositoryContext: (auth: SignalAuthState, ctx: SignalRepositoryContext) => void;
 /** Default public factory; the socket binds its native context before invoking it. */

package/lib/Compatibility/signal-repository.js

@@ -34,12 +34,12 @@ export const bindSignalRepositoryContext = (auth, ctx) => {
 /** Default public factory; the socket binds its native context before invoking it. */
 export const makeDefaultSignalRepository = (auth, logger, _pnToLIDFunc) => makeSignalRepository({
     logger,
-    getClient: () => {
+    withClient: operation => {
         const ctx = nativeContexts.get(auth);
         if (!ctx) {
             return Promise.reject(new Error('Signal repository is not bound to an active socket; pass it through SocketConfig'));
         }
-        return ctx.getClient();
+        return ctx.withClient(operation);
     }
 });
 const resolveMappings = async (client, inputs, direction, ctx) => {
@@ -69,63 +69,67 @@ const resolveMappings = async (client, inputs, direction, ctx) => {
     return mappings.length ? mappings : null;
 };
 /** Translate the neutral bridge Signal surface into the public repository contract. */
-export const makeSignalRepository = (ctx) => ({
-    decryptMessage: async (opts) => (await ctx.getClient()).signalDecryptMessage(opts.jid, opts.type, opts.ciphertext),
-    encryptMessage: async (opts) => (await ctx.getClient()).signalEncryptMessage(opts.jid, opts.data),
-    decryptGroupMessage: async (opts) => (await ctx.getClient()).signalDecryptGroupMessage(opts.group, opts.authorJid, opts.msg),
-    encryptGroupMessage: async (opts) => (await ctx.getClient()).signalEncryptGroupMessage(opts.group, opts.data, opts.meId),
-    processSenderKeyDistributionMessage: async ({ item, authorJid }) => {
-        if (!item.groupId) {
-            throw new Error('Group ID is required for sender key distribution message');
-        }
-        const distribution = item.axolotlSenderKeyDistributionMessage;
-        if (!distribution) {
-            throw new Error('Sender key distribution payload is required');
-        }
-        await (await ctx.getClient()).signalProcessSenderKeyDistribution(item.groupId, authorJid, distribution);
-    },
-    getSenderKeyDistributionMessage: async ({ group, meId }) => (await ctx.getClient()).signalGetSenderKeyDistribution(group, meId),
-    hasSenderKey: async ({ group, meId }) => (await ctx.getClient()).signalHasSenderKey(group, meId),
-    getSessionInfo: async (jid) => (await (await ctx.getClient()).signalGetSessionInfo(jid)) ?? null,
-    injectE2ESession: async ({ jid, session }) => {
-        await (await ctx.getClient()).signalInstallPreKeyBundle(jid, session);
-    },
-    validateSession: async (jid) => ({ exists: await (await ctx.getClient()).signalValidateSession(jid) }),
-    jidToSignalProtocolAddress: jidToSignalProtocolAddressCompat,
-    migrateSession: async (fromJid, toJid) => {
-        if (!fromJid || !isLidNamespace(toJid))
-            return { migrated: 0, skipped: 0, total: 0 };
-        if (!isPnNamespace(fromJid))
-            return { migrated: 0, skipped: 0, total: 1 };
-        return (await ctx.getClient()).signalMigrateSessions(fromJid, toJid);
-    },
-    deleteSession: async (jids) => {
-        if (jids.length)
-            await (await ctx.getClient()).signalDeleteSessions(jids);
-    },
-    lidMapping: {
-        storeLIDPNMappings: async (pairs) => {
-            const valid = pairs.filter(({ lid, pn }) => {
-                const accepted = isLidNamespace(lid) && isPnNamespace(pn);
-                if (!accepted)
-                    ctx.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
-                return accepted;
-            });
-            if (valid.length)
-                await (await ctx.getClient()).addLidPnMappings(valid);
+export const makeSignalRepository = (ctx) => {
+    return {
+        decryptMessage: async (opts) => ctx.withClient(client => client.signalDecryptMessage(opts.jid, opts.type, opts.ciphertext)),
+        encryptMessage: async (opts) => ctx.withClient(client => client.signalEncryptMessage(opts.jid, opts.data)),
+        decryptGroupMessage: async (opts) => ctx.withClient(client => client.signalDecryptGroupMessage(opts.group, opts.authorJid, opts.msg)),
+        encryptGroupMessage: async (opts) => ctx.withClient(client => client.signalEncryptGroupMessage(opts.group, opts.data, opts.meId)),
+        processSenderKeyDistributionMessage: async ({ item, authorJid }) => {
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
+            const distribution = item.axolotlSenderKeyDistributionMessage;
+            if (!distribution) {
+                throw new Error('Sender key distribution payload is required');
+            }
+            await ctx.withClient(client => client.signalProcessSenderKeyDistribution(item.groupId, authorJid, distribution));
+        },
+        getSenderKeyDistributionMessage: async ({ group, meId }) => ctx.withClient(client => client.signalGetSenderKeyDistribution(group, meId)),
+        hasSenderKey: async ({ group, meId }) => ctx.withClient(client => client.signalHasSenderKey(group, meId)),
+        getSessionInfo: async (jid) => (await ctx.withClient(client => client.signalGetSessionInfo(jid))) ?? null,
+        injectE2ESession: async ({ jid, session }) => {
+            await ctx.withClient(client => client.signalInstallPreKeyBundle(jid, session));
         },
-        getLIDForPN: async (pn) => {
-            const client = await ctx.getClient();
-            return (await resolveMappings(client, [pn], 'pn-to-lid', ctx))?.[0]?.lid ?? null;
+        validateSession: async (jid) => ({ exists: await ctx.withClient(client => client.signalValidateSession(jid)) }),
+        jidToSignalProtocolAddress: jidToSignalProtocolAddressCompat,
+        migrateSession: async (fromJid, toJid) => {
+            if (!fromJid || !isLidNamespace(toJid))
+                return { migrated: 0, skipped: 0, total: 0 };
+            if (!isPnNamespace(fromJid))
+                return { migrated: 0, skipped: 0, total: 1 };
+            return ctx.withClient(client => client.signalMigrateSessions(fromJid, toJid));
         },
-        getLIDsForPNs: async (pns) => resolveMappings(await ctx.getClient(), pns, 'pn-to-lid', ctx),
-        getPNForLID: async (lid) => {
-            const client = await ctx.getClient();
-            return (await resolveMappings(client, [lid], 'lid-to-pn', ctx))?.[0]?.pn ?? null;
+        deleteSession: async (jids) => {
+            if (jids.length)
+                await ctx.withClient(client => client.signalDeleteSessions(jids));
+        },
+        lidMapping: {
+            storeLIDPNMappings: async (pairs) => {
+                const valid = pairs.filter(({ lid, pn }) => {
+                    const accepted = isLidNamespace(lid) && isPnNamespace(pn);
+                    if (!accepted)
+                        ctx.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                    return accepted;
+                });
+                if (valid.length)
+                    await ctx.withClient(client => client.addLidPnMappings(valid));
+            },
+            getLIDForPN: async (pn) => {
+                return ctx.withClient(async (client) => {
+                    return (await resolveMappings(client, [pn], 'pn-to-lid', ctx))?.[0]?.lid ?? null;
+                });
+            },
+            getLIDsForPNs: async (pns) => ctx.withClient(client => resolveMappings(client, pns, 'pn-to-lid', ctx)),
+            getPNForLID: async (lid) => {
+                return ctx.withClient(async (client) => {
+                    return (await resolveMappings(client, [lid], 'lid-to-pn', ctx))?.[0]?.pn ?? null;
+                });
+            },
+            getPNsForLIDs: async (lids) => ctx.withClient(client => resolveMappings(client, lids, 'lid-to-pn', ctx)),
+            close: () => undefined
         },
-        getPNsForLIDs: async (lids) => resolveMappings(await ctx.getClient(), lids, 'lid-to-pn', ctx),
         close: () => undefined
-    },
-    close: () => undefined
-});
+    };
+};
 //# sourceMappingURL=signal-repository.js.map

package/lib/Compatibility/stanza-responses.d.ts

@@ -1,11 +1,11 @@
 import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode } from '../Types/index.js';
+import type { ClientOperations } from '../Socket/client-operations.js';
 type StanzaResponseClient = Pick<WasmWhatsAppClient, 'acknowledgeStanza' | 'rejectStanza' | 'requestMessageRetry'>;
-export interface StanzaResponseContext {
-    getClient: () => Promise<StanzaResponseClient>;
+export interface StanzaResponseContext extends ClientOperations<StanzaResponseClient> {
 }
 /** Translate the public socket calls into the core-owned response operations. */
-export declare const makeStanzaResponseMethods: ({ getClient }: StanzaResponseContext) => {
+export declare const makeStanzaResponseMethods: (ctx: StanzaResponseContext) => {
     sendMessageAck: (node: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
 };

package/lib/Compatibility/stanza-responses.js

@@ -1,16 +1,19 @@
 /** Translate the public socket calls into the core-owned response operations. */
-export const makeStanzaResponseMethods = ({ getClient }) => ({
-    sendMessageAck: async (node, errorCode) => {
-        const client = await getClient();
-        if (errorCode) {
-            await client.rejectStanza(node, errorCode);
+export const makeStanzaResponseMethods = (ctx) => {
+    return {
+        sendMessageAck: async (node, errorCode) => {
+            return ctx.withClient(async (client) => {
+                if (errorCode) {
+                    await client.rejectStanza(node, errorCode);
+                }
+                else {
+                    await client.acknowledgeStanza(node);
+                }
+            });
+        },
+        sendRetryRequest: async (node, forceIncludeKeys = false) => {
+            await ctx.withClient(client => client.requestMessageRetry(node, forceIncludeKeys));
         }
-        else {
-            await client.acknowledgeStanza(node);
-        }
-    },
-    sendRetryRequest: async (node, forceIncludeKeys = false) => {
-        await (await getClient()).requestMessageRetry(node, forceIncludeKeys);
-    }
-});
+    };
+};
 //# sourceMappingURL=stanza-responses.js.map

package/lib/Socket/blocking.js

@@ -1,13 +1,15 @@
 import { bridgeBlocklistToBaileys } from '../Compatibility/socket-results.js';
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const BLOCK_ACTIONS = ['block', 'unblock'];
-export const makeBlockingMethods = (ctx) => ({
-    updateBlockStatus: async (jid, action) => {
-        assertArgumentDomain('updateBlockStatus', 'action', action, BLOCK_ACTIONS);
-        await (await ctx.getClient()).updateBlockStatus(jid, action);
-    },
-    fetchBlocklist: async () => {
-        return bridgeBlocklistToBaileys(await (await ctx.getClient()).fetchBlocklist());
-    }
-});
+export const makeBlockingMethods = (ctx) => {
+    return {
+        updateBlockStatus: async (jid, action) => {
+            assertArgumentDomain('updateBlockStatus', 'action', action, BLOCK_ACTIONS);
+            await ctx.withClient(client => client.updateBlockStatus(jid, action));
+        },
+        fetchBlocklist: async () => {
+            return bridgeBlocklistToBaileys(await ctx.withClient(client => client.fetchBlocklist()));
+        }
+    };
+};
 //# sourceMappingURL=blocking.js.map

package/lib/Socket/bridge-error-boundary.d.ts

@@ -21,8 +21,8 @@
  *  - Anything that is not the bridge's shape (an `Error` carrying a string
  *    `kind`) passes through with the same identity it arrived with.
  *
- * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
- * a `Proxy` whose method wrappers are built on first access and cached, so
+ * The private `getClient()` getter returns a cached `Proxy` for each client.
+ * Its method wrappers are built on first access and cached, so
  * the happy path pays one property trap and one extra promise layer, and the
  * error path pays for everything else.
  */

package/lib/Socket/bridge-error-boundary.js

@@ -21,8 +21,8 @@
  *  - Anything that is not the bridge's shape (an `Error` carrying a string
  *    `kind`) passes through with the same identity it arrived with.
  *
- * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
- * a `Proxy` whose method wrappers are built on first access and cached, so
+ * The private `getClient()` getter returns a cached `Proxy` for each client.
+ * Its method wrappers are built on first access and cached, so
  * the happy path pays one property trap and one extra promise layer, and the
  * error path pays for everything else.
  */

package/lib/Socket/business.js

@@ -39,66 +39,68 @@ const catalogSubject = (method, ctx, jid) => {
     }
     return subject;
 };
-export const makeBusinessMethods = (ctx) => ({
-    getCatalog: async ({ jid, limit, cursor }) => {
-        const subject = catalogSubject('getCatalog', ctx, jid);
-        return await (await ctx.getClient()).getCatalog(subject, { limit, after: cursor });
-    },
-    getCollections: async (jid, limit) => {
-        const subject = catalogSubject('getCollections', ctx, jid);
-        return await (await ctx.getClient()).getCollections(subject, { collectionLimit: limit });
-    },
-    /**
-     * `sellerJid` is not in upstream's signature because upstream reads orders
-     * over the legacy `fb:thrift_iq` route, which addresses the server. The
-     * route the real client uses is a MEX query keyed by the seller, so the JID
-     * is required here. It is on the order message the token came from.
-     */
-    getOrderDetails: async (orderId, tokenBase64, sellerJid) => {
-        if (!sellerJid) {
-            throw new Boom('getOrderDetails: a third argument with the seller jid is required, because orders are read through a query keyed by the business rather than the legacy server-addressed one', { statusCode: 400 });
-        }
-        return await (await ctx.getClient()).getOrder(sellerJid, orderId, tokenBase64);
-    },
-    updateBussinesProfile: async (args) => {
-        const update = {
-            address: args.address,
-            description: args.description,
-            email: args.email,
-            websites: args.websites,
-            ...(args.hours !== undefined
-                ? {
-                    businessHours: {
-                        timezone: args.hours.timezone,
-                        // Minutes past midnight as a number; upstream types the two
-                        // as strings and the core rejects them on the other modes.
-                        config: args.hours.days.map(day => ({
-                            dayOfWeek: day.day,
-                            mode: day.mode,
-                            openTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.openTimeInMinutes, 'open') : undefined,
-                            closeTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.closeTimeInMinutes, 'close') : undefined
-                        }))
+export const makeBusinessMethods = (ctx) => {
+    return {
+        getCatalog: async ({ jid, limit, cursor }) => {
+            const subject = catalogSubject('getCatalog', ctx, jid);
+            return await ctx.withClient(client => client.getCatalog(subject, { limit, after: cursor }));
+        },
+        getCollections: async (jid, limit) => {
+            const subject = catalogSubject('getCollections', ctx, jid);
+            return await ctx.withClient(client => client.getCollections(subject, { collectionLimit: limit }));
+        },
+        /**
+         * `sellerJid` is not in upstream's signature because upstream reads orders
+         * over the legacy `fb:thrift_iq` route, which addresses the server. The
+         * route the real client uses is a MEX query keyed by the seller, so the JID
+         * is required here. It is on the order message the token came from.
+         */
+        getOrderDetails: async (orderId, tokenBase64, sellerJid) => {
+            if (!sellerJid) {
+                throw new Boom('getOrderDetails: a third argument with the seller jid is required, because orders are read through a query keyed by the business rather than the legacy server-addressed one', { statusCode: 400 });
+            }
+            return await ctx.withClient(client => client.getOrder(sellerJid, orderId, tokenBase64));
+        },
+        updateBussinesProfile: async (args) => {
+            const update = {
+                address: args.address,
+                description: args.description,
+                email: args.email,
+                websites: args.websites,
+                ...(args.hours !== undefined
+                    ? {
+                        businessHours: {
+                            timezone: args.hours.timezone,
+                            // Minutes past midnight as a number; upstream types the two
+                            // as strings and the core rejects them on the other modes.
+                            config: args.hours.days.map(day => ({
+                                dayOfWeek: day.day,
+                                mode: day.mode,
+                                openTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.openTimeInMinutes, 'open') : undefined,
+                                closeTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.closeTimeInMinutes, 'close') : undefined
+                            }))
+                        }
                     }
-                }
-                : {})
-        };
-        await (await ctx.getClient()).updateBusinessProfile(update);
-    },
-    /**
-     * Declared but not callable end to end. The core and the bridge take the
-     * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
-     * package's upload path cannot produce one: it requires a url and a
-     * direct path, which that endpoint does not return.
-     */
-    updateCoverPhoto: async (photo) => {
-        void photo;
-        throw new Boom('updateCoverPhoto is not available yet: the cover photo upload returns an {fbid, meta_hmac, ts} receipt that this package cannot obtain. removeCoverPhoto works.', { statusCode: 501 });
-    },
-    removeCoverPhoto: async (id) => {
-        await (await ctx.getClient()).removeBusinessCoverPhoto(id);
-    },
-    productCreate: async (create) => noProductWriteRoute('productCreate', create),
-    productUpdate: async (productId, update) => noProductWriteRoute('productUpdate', productId, update),
-    productDelete: async (productIds) => noProductWriteRoute('productDelete', productIds)
-});
+                    : {})
+            };
+            await ctx.withClient(client => client.updateBusinessProfile(update));
+        },
+        /**
+         * Declared but not callable end to end. The core and the bridge take the
+         * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
+         * package's upload path cannot produce one: it requires a url and a
+         * direct path, which that endpoint does not return.
+         */
+        updateCoverPhoto: async (photo) => {
+            void photo;
+            throw new Boom('updateCoverPhoto is not available yet: the cover photo upload returns an {fbid, meta_hmac, ts} receipt that this package cannot obtain. removeCoverPhoto works.', { statusCode: 501 });
+        },
+        removeCoverPhoto: async (id) => {
+            await ctx.withClient(client => client.removeBusinessCoverPhoto(id));
+        },
+        productCreate: async (create) => noProductWriteRoute('productCreate', create),
+        productUpdate: async (productId, update) => noProductWriteRoute('productUpdate', productId, update),
+        productDelete: async (productIds) => noProductWriteRoute('productDelete', productIds)
+    };
+};
 //# sourceMappingURL=business.js.map

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